LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/intel[P]pf-bb-config/vrb2/vrb2_cfg_app.c
// Function: vrb2_enable_intr
int vrb2_enable_intr(void *dev)
{
	int ret;
	hw_device *accel_pci_dev = (hw_device *)dev;
	void *bar0addr = accel_pci_dev->bar0Addr;

	LOG(DEBUG, "Enable VRB2 interrupts");
	/* allocate info ring */
	ret = vrb2_allocate_info_ring(dev);
	if (ret < 0) {
		LOG(ERR, "vrb2allocate info ring failed");
		return -1;
	}

	vrb2_enable_ir_regs(bar0addr);

	LOG(DEBUG, "Done");
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
movq 0xb0(%rdi), %r13
callq 0x16854
leaq 0x1f0ee(%rip), %r12     # 0x33ed0
movq 0x18(%r12), %r8
leaq 0x81c0(%rip), %rdx      # 0x1cfae
leaq 0x81dd(%rip), %r9       # 0x1cfd2
xorl %ebx, %ebx
movl $0x3, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x19ca8
cmpq $0x0, 0x90(%r14)
jne 0x14f1d
movq 0xb0(%r14), %rbp
leaq 0x98(%r14), %rdx
movl $0x1000, %esi           # imm = 0x1000
movq %r14, %rdi
callq 0x18f47
movq %rax, %r15
movq %rax, 0x90(%r14)
callq 0x16854
testq %r15, %r15
je 0x14fc2
movq 0x18(%r12), %r8
movups 0x90(%r14), %xmm0
movups %xmm0, (%rsp)
leaq 0x7983(%rip), %rdx      # 0x1c7e4
leaq 0x88ea(%rip), %r9       # 0x1d752
movl $0x3, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x19ca8
movl 0x9c(%r14), %eax
movl %eax, 0xc84018(%rbp)
movl $0x1, %edi
callq 0xd460
movl 0x98(%r14), %eax
movl %eax, 0xc84014(%rbp)
movl $0x1, %edi
callq 0xd460
movl $0xf000, 0xc8401c(%rbp) # imm = 0xF000
movl $0x1, %edi
callq 0xd460
movl 0xc8401c(%rbp), %eax
shrl $0x2, %eax
andl $0x3ff, %eax            # imm = 0x3FF
movw %ax, 0xa8(%r14)
movq 0x90(%r14), %rdi
testq %rdi, %rdi
je 0x14ee9
movl $0x1000, %edx           # imm = 0x1000
xorl %esi, %esi
callq 0xd180
callq 0x16854
movq 0x18(%r12), %r8
movzwl 0xa8(%r14), %ecx
movl %ecx, (%rsp)
leaq 0x7928(%rip), %rdx      # 0x1c82d
leaq 0x8846(%rip), %r9       # 0x1d752
movl $0x3, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x19ca8
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, 0xc84020(%r13)
movl $0x1, %edi
callq 0xd460
movl %ebp, 0xc84040(%r13)
movl $0x1, %edi
callq 0xd460
movl %ebp, 0xc84028(%r13)
movl $0x1, %edi
callq 0xd460
movl %ebp, 0xc84024(%r13)
movl $0x1, %edi
callq 0xd460
movl %ebp, 0xc84048(%r13)
movl $0x1, %edi
callq 0xd460
movl %ebp, 0xc84044(%r13)
movl $0x1, %edi
callq 0xd460
callq 0x16854
movq 0x18(%r12), %r8
leaq 0x658b(%rip), %rdx      # 0x1b524
leaq 0x8032(%rip), %r9       # 0x1cfd2
movl $0x3, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x19ca8
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%r12), %r8
leaq 0x77e9(%rip), %rdx      # 0x1c7b6
xorl %edi, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x19ca8
callq 0x16854
movq (%r12), %r8
leaq 0x7ff8(%rip), %rdx      # 0x1cfe3
xorl %edi, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x19ca8
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0x14fb1
// File: /workspace/github_c_makefile_star2_O1/intel[P]pf-bb-config/vrb2/vrb2_cfg_app.c
// Function: vrb2_disable_intr
int
vrb2_disable_intr(void *dev)
{
	hw_device *accel_pci_dev = (hw_device *)dev;
	void *bar0addr = accel_pci_dev->bar0Addr;

	LOG(DEBUG, "Disable interrupts");

	vrb2_disable_ir_regs(bar0addr);

	vrb2_free_info_ring(dev);

	LOG(DEBUG, "Done");
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0xb0(%rdi), %r14
callq 0x16854
leaq 0x1eeb5(%rip), %r15     # 0x33ed0
movq 0x18(%r15), %r8
leaq 0x72b3(%rip), %rdx      # 0x1c2d9
leaq 0x7fdb(%rip), %r9       # 0x1d008
movl $0x3, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x19ca8
movq %r14, %rdi
callq 0x14d48
callq 0x16854
movq 0x18(%r15), %r8
leaq 0x77f7(%rip), %rdx      # 0x1c84d
leaq 0x870d(%rip), %r9       # 0x1d76a
movl $0x3, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x19ca8
movq 0x90(%rbx), %rdi
testq %rdi, %rdi
je 0x150c5
leaq 0x90(%rbx), %r14
movq 0xa0(%rbx), %rsi
callq 0x18f61
movw $0x0, 0xa8(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
callq 0x16854
movq 0x18(%r15), %r8
leaq 0x6477(%rip), %rdx      # 0x1b524
leaq 0x86b6(%rip), %r9       # 0x1d76a
movl $0x3, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x19ca8
callq 0x16854
movq 0x18(%r15), %r8
leaq 0x644f(%rip), %rdx      # 0x1b524
leaq 0x7f2c(%rip), %r9       # 0x1d008
movl $0x3, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x19ca8
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/intel[P]pf-bb-config/vrb2/vrb2_cfg_app.c
// Function: vrb2_disable_int_src
static void vrb2_disable_int_src(uint8_t *bar0addr, int int_src)
{
	uint32_t mask;

	mask = vrb2_reg_read(bar0addr, HWPfHiInfoRingIntWrEnRegPf);
	mask &= (0xFFFFFFFF - (1ULL << int_src));
	LOG(INFO, "Disable the Interrupt source %d new mask %x", int_src, mask);
	vrb2_reg_write(bar0addr, HWPfHiInfoRingIntWrEnRegPf, mask);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq $-0x1, %r15
movl %ebx, %ecx
shlq %cl, %r15
movq %rdi, %r14
decl %r15d
andl 0xc84020(%rdi), %r15d
callq 0x16854
leaq 0x1d602(%rip), %rcx     # 0x33ed0
movq 0x10(%rcx), %r8
movl %r15d, (%rsp)
leaq 0x6b1b(%rip), %rdx      # 0x1d3f8
movl $0x2, %edi
xorl %esi, %esi
movq %rax, %rcx
movl %ebx, %r9d
xorl %eax, %eax
callq 0x19ca8
movl %r15d, 0xc84020(%r14)
movl $0x1, %edi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0xd460
nop
// File: /workspace/github_c_makefile_star2_O1/intel[P]pf-bb-config/vrb2/vrb2_cfg_parser.c
// Function: vrb2_queue_range_check
int
vrb2_queue_range_check(struct q_topology_t q_conf)
{
	if ((q_conf.num_aqs_per_groups < 1) ||
			(q_conf.num_aqs_per_groups > VRB2_NUM_AQS)) {
		printf("ERROR: Number of AQs out of range %d\n",
				q_conf.num_aqs_per_groups);
		return -1;
	}
	if ((q_conf.aq_depth_log2 < 1) ||
			(q_conf.aq_depth_log2 > VRB2_MAX_QDEPTH)) {
		printf("ERROR: AQ Depth out of range %d\n",
				q_conf.aq_depth_log2);
		return -1;
	}
	if (q_conf.num_qgroups > VRB2_NUM_QGRPS) {
		printf("ERROR: Number of QG out of range %d\n",
				q_conf.num_qgroups);
		return -1;
	}
	if (q_conf.num_qgroups * q_conf.num_aqs_per_groups > VRB2_MAX_QGRPS_PER_OP) {
		printf("ERROR: Number of queues per op out of range %d %d\n",
				q_conf.num_qgroups * q_conf.num_aqs_per_groups,
				VRB2_MAX_QGRPS_PER_OP);
		return -1;
	}
	return 0;
}

// Assembly:
pushq %rax
movl %edi, %esi
shrl $0x10, %esi
leal -0x410000(%rdi), %eax
cmpl $0xffbfffff, %eax       # imm = 0xFFBFFFFF
ja 0x16928
leaq 0x51fa(%rip), %rdi      # 0x1bb20
jmp 0x16956
movq %rdi, %rax
shrq $0x20, %rax
movzwl %ax, %eax
leal -0x9(%rax), %ecx
cmpl $-0x9, %ecx
ja 0x16945
leaq 0x5205(%rip), %rdi      # 0x1bb46
movl %eax, %esi
jmp 0x16956
movzwl %di, %ecx
cmpl $0x21, %ecx
jb 0x16964
leaq 0x5213(%rip), %rdi      # 0x1bb67
movl %ecx, %esi
xorl %eax, %eax
callq 0xd150
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rcx
retq
imull %esi, %ecx
xorl %eax, %eax
cmpl $0x101, %ecx            # imm = 0x101
jb 0x16962
leaq 0x6f68(%rip), %rdi      # 0x1d8e0
movl %ecx, %esi
movl $0x100, %edx            # imm = 0x100
xorl %eax, %eax
callq 0xd150
jmp 0x1695d
// File: /workspace/github_c_makefile_star2_O1/intel[P]pf-bb-config/vrb2/vrb2_cfg_parser.c
// Function: vrb2_range_check
int
vrb2_range_check(struct vrb2_conf *vrb2_conf)
{
	uint16_t totalQgs = vrb2_conf->q_ul_4g.num_qgroups +
			vrb2_conf->q_ul_5g.num_qgroups +
			vrb2_conf->q_dl_4g.num_qgroups +
			vrb2_conf->q_dl_5g.num_qgroups +
			vrb2_conf->q_fft.num_qgroups +
			vrb2_conf->q_mld.num_qgroups;
	if (totalQgs > VRB2_NUM_QGRPS) {
		printf("ERROR: Number of Qgroups %d > %d\n",
				totalQgs, VRB2_NUM_QGRPS);
		return -1;
	}
	if (vrb2_conf->num_vf_bundles > VRB2_NUM_VFS) {
		printf("ERROR: Number of VFs bundle %d > %d\n",
				vrb2_conf->num_vf_bundles, VRB2_NUM_VFS);
		return -1;
	}
	if (vrb2_queue_range_check(vrb2_conf->q_ul_4g) != 0)
		return -1;
	if (vrb2_queue_range_check(vrb2_conf->q_dl_4g) != 0)
		return -1;
	if (vrb2_queue_range_check(vrb2_conf->q_ul_5g) != 0)
		return -1;
	if (vrb2_queue_range_check(vrb2_conf->q_dl_5g) != 0)
		return -1;
	if (vrb2_queue_range_check(vrb2_conf->q_fft) != 0)
		return -1;
	if (vrb2_queue_range_check(vrb2_conf->q_mld) != 0)
		return -1;
	return 0;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movzwl 0x12(%rdi), %eax
addw 0x6(%rdi), %ax
addw 0xc(%rdi), %ax
addw 0x18(%rdi), %ax
addw 0x1e(%rdi), %ax
addw 0x24(%rdi), %ax
cmpw $0x21, %ax
jb 0x169ba
movzwl %ax, %esi
leaq 0x51d9(%rip), %rdi      # 0x1bb8c
movl $0x20, %edx
jmp 0x169d2
movq %rdi, %rbx
movzwl 0x4(%rdi), %esi
cmpl $0x41, %esi
jb 0x169e7
leaq 0x51e1(%rip), %rdi      # 0x1bbae
movl $0x40, %edx
xorl %eax, %eax
callq 0xd150
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movl 0x6(%rbx), %eax
movzwl 0xa(%rbx), %edi
shlq $0x20, %rdi
orq %rax, %rdi
callq 0x1690c
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testl %eax, %eax
jne 0x169de
movl 0xc(%rbx), %eax
movl 0x10(%rbx), %edi
shlq $0x20, %rdi
orq %rax, %rdi
callq 0x1690c
testl %eax, %eax
jne 0x169de
movl 0x12(%rbx), %eax
movzwl 0x16(%rbx), %edi
shlq $0x20, %rdi
orq %rax, %rdi
callq 0x1690c
testl %eax, %eax
jne 0x169de
movl 0x18(%rbx), %eax
movl 0x1c(%rbx), %edi
shlq $0x20, %rdi
orq %rax, %rdi
callq 0x1690c
testl %eax, %eax
jne 0x169de
movl 0x1e(%rbx), %eax
movzwl 0x22(%rbx), %edi
shlq $0x20, %rdi
orq %rax, %rdi
callq 0x1690c
testl %eax, %eax
jne 0x169de
movl 0x24(%rbx), %eax
movl 0x28(%rbx), %edi
shlq $0x20, %rdi
orq %rax, %rdi
callq 0x1690c
xorl %ebp, %ebp
negl %eax
sbbl %ebp, %ebp
jmp 0x169de
// File: /workspace/github_c_makefile_star2_O1/intel[P]pf-bb-config/vrb2/vrb2_cfg_parser.c
// Function: vrb2_parse_conf_file
int
vrb2_parse_conf_file(const char *file_name, struct vrb2_conf *vrb2_conf)
{
	int ret;

	set_default_config(vrb2_conf);

	ret = cfg_parse(file_name, vrb2_handler, vrb2_conf);
	if (ret != 0) {
		printf("ERROR: Config file parser error\n");
		set_default_config(vrb2_conf);
		return -1;
	}

	ret = vrb2_range_check(vrb2_conf);
	if (ret != 0) {
		printf("ERROR: Parameter out of range\n");
		set_default_config(vrb2_conf);
		return -1;
	}

	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x16adc
leaq 0x164(%rip), %rsi       # 0x16bf7
movq %r14, %rdi
movq %rbx, %rdx
callq 0x13bb7
testl %eax, %eax
je 0x16aab
leaq 0x52e8(%rip), %rdi      # 0x1bd91
jmp 0x16abe
movq %rbx, %rdi
callq 0x16988
testl %eax, %eax
je 0x16ad8
leaq 0x52b5(%rip), %rdi      # 0x1bd73
callq 0xd0c0
movq %rbx, %rdi
callq 0x16adc
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorl %eax, %eax
jmp 0x16ad0
// File: /workspace/github_c_makefile_star2_O1/intel[P]pf-bb-config/agx100/agx100_cfg_parser.c
// Function: agx100_parse_conf_file
int
agx100_parse_conf_file(const char *file_name,
		struct agx100_conf *agx100_conf)
{
	int ret;

	set_default_config(agx100_conf);

	ret = cfg_parse(file_name, agx100_handler, agx100_conf);

	if (ret == -1) {
		printf("ERROR: Error loading configuration file %s\n",
			file_name);
		set_default_config(agx100_conf);
		return -ENOENT;
	} else if (ret == -2) {
		printf("ERROR: Memory allocation error\n");
		set_default_config(agx100_conf);
		return -ENOMEM;
	}

	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movb $0x1, (%rsi)
movw $0x4040, 0x11(%rsi)     # imm = 0x4040
movaps 0x4582(%rip), %xmm0     # 0x1c030
movups %xmm0, 0x1(%rsi)
leaq 0x5e(%rip), %rsi        # 0x17b17
movq %rbx, %rdx
callq 0x13bb7
cmpl $-0x2, %eax
je 0x17ae7
movl %eax, %ecx
xorl %eax, %eax
cmpl $-0x1, %ecx
jne 0x17b0f
leaq 0x456a(%rip), %rdi      # 0x1c040
movq %r14, %rsi
xorl %eax, %eax
callq 0xd150
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
jmp 0x17af8
leaq 0x4608(%rip), %rdi      # 0x1c0f6
callq 0xd0c0
movl $0xfffffff4, %eax       # imm = 0xFFFFFFF4
leaq 0x1(%rbx), %rcx
movb $0x1, (%rbx)
movw $0x4040, 0x11(%rbx)     # imm = 0x4040
movaps 0x4524(%rip), %xmm0     # 0x1c030
movups %xmm0, (%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/intel[P]pf-bb-config/agx100/agx100_cfg_parser.c
// Function: agx100_handler
static int
agx100_handler(void *user, const char *section,
	     const char *name, const char *value)
{
	struct agx100_conf *agx100_conf =
			(struct agx100_conf *) user;
	int ret = 1;

	if (!strcmp(section, MODE) && !strcmp(name, PFMODE)) {
		if (!strcmp(value, ZERO))
			agx100_conf->pf_mode_en = false;
		else if (!strcmp(value, ONE))
			agx100_conf->pf_mode_en = true;
		else
			ret = 0;
	} else if (!strcmp(section, UL) && !strcmp(name, LOAD_BALANCE)) {
		ret = parse_number8(value, &agx100_conf->ul_load_balance);
	} else if (!strcmp(section, DL) && !strcmp(name, LOAD_BALANCE)) {
		ret = parse_number8(value, &agx100_conf->dl_load_balance);
	} else if (!strcmp(section, UL) && !strcmp(name, QUEUE_MAP)) {
		ret = parse_array8(value, agx100_conf->vf_ul_queues_number);
	} else if (!strcmp(section, DL) && !strcmp(name, QUEUE_MAP)) {
		ret = parse_array8(value, agx100_conf->vf_dl_queues_number);
	} else {
		printf("ERROR: Section (%s) or name (%s) is not valid.\n",
		       section, name);
		return 0;
	}
	if (ret != 1)
		printf("Error: Conversion of value (%s) failed.\n", value);

	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
leaq 0x409e(%rip), %rsi      # 0x1bbd3
movq %r12, %rdi
callq 0xd200
testl %eax, %eax
jne 0x17b58
leaq 0x4090(%rip), %rsi      # 0x1bbd8
movq %r15, %rdi
callq 0xd200
testl %eax, %eax
je 0x17bf4
leaq 0x43b5(%rip), %rsi      # 0x1bf14
movq %r12, %rdi
callq 0xd200
movl %eax, %ebp
testl %eax, %eax
jne 0x17b84
leaq 0x4502(%rip), %rsi      # 0x1c076
movq %r15, %rdi
callq 0xd200
testl %eax, %eax
je 0x17c22
leaq 0x438c(%rip), %rsi      # 0x1bf17
movq %r12, %rdi
callq 0xd200
movl %eax, %r13d
testl %eax, %eax
jne 0x17bad
leaq 0x44d5(%rip), %rsi      # 0x1c076
movq %r15, %rdi
callq 0xd200
testl %eax, %eax
je 0x17c28
testl %ebp, %ebp
jne 0x17bc4
leaq 0x44cb(%rip), %rsi      # 0x1c083
movq %r15, %rdi
callq 0xd200
testl %eax, %eax
je 0x17c39
testl %r13d, %r13d
jne 0x17bdc
leaq 0x44b3(%rip), %rsi      # 0x1c083
movq %r15, %rdi
callq 0xd200
testl %eax, %eax
je 0x17c3e
leaq 0x44b8(%rip), %rdi      # 0x1c09b
xorl %ebp, %ebp
movq %r12, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0xd150
jmp 0x17c65
leaq 0x340e(%rip), %rsi      # 0x1b009
movq %rbx, %rdi
callq 0xd200
testl %eax, %eax
je 0x17c76
leaq 0x3429(%rip), %rsi      # 0x1b037
movq %rbx, %rdi
callq 0xd200
xorl %ebp, %ebp
testl %eax, %eax
jne 0x17c4f
movb $0x1, (%r14)
jmp 0x17c7a
addq $0x11, %r14
jmp 0x17c2c
addq $0x12, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x17c81
jmp 0x17c4d
incq %r14
jmp 0x17c42
addq $0x9, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x17cd5
movl %eax, %ebp
cmpl $0x1, %ebp
je 0x17c65
leaq 0x4470(%rip), %rdi      # 0x1c0cb
movq %rbx, %rsi
xorl %eax, %eax
callq 0xd150
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movb $0x0, (%r14)
movl $0x1, %ebp
jmp 0x17c4f
// File: /workspace/github_c_makefile_star2_O1/intel[P]pf-bb-config/bb_acc_vfio.c
// Function: vfio_intr_handler
static void vfio_intr_handler(int event_fd, void *dev)
{
	hw_device *hwd = (hw_device *)dev;
	int len;
	uint64_t buf;

	LOG(DEBUG, "VFIO interrupt handler:");

	do {
		len = read(event_fd, &buf, sizeof(buf));
		LOG(DEBUG, "event val: %lu, len:%d", buf, len);

		if (len < 0) {
			LOG(ERR, "vfio event irq recv() failed");
			return;
		}
	} while (len != sizeof(buf));

	if (hwd->ops.dev_isr)
		hwd->ops.dev_isr(hwd);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, 0x8(%rsp)
movl %edi, %ebp
callq 0x18f62
leaq 0x1bb9d(%rip), %rbx     # 0x33ed0
movq 0x18(%rbx), %r8
leaq 0x5d7e(%rip), %rdx      # 0x1e0bc
leaq 0x5d9c(%rip), %r14      # 0x1e0e1
movl $0x3, %edi
xorl %esi, %esi
movq %rax, %rcx
movq %r14, %r9
xorl %eax, %eax
callq 0x19ca8
leaq 0x10(%rsp), %r15
leaq 0x5d8e(%rip), %r12      # 0x1e0f3
movl $0x8, %edx
movl %ebp, %edi
movq %r15, %rsi
callq 0xd1e0
movq %rax, %r13
callq 0x18f62
movq 0x18(%rbx), %r8
movl $0x3, %edi
xorl %esi, %esi
movq %r12, %rdx
movq %rax, %rcx
movq %r14, %r9
xorl %eax, %eax
pushq %r13
pushq 0x18(%rsp)
callq 0x19ca8
addq $0x10, %rsp
testl %r13d, %r13d
js 0x183d1
andl $0x7fffffff, %r13d      # imm = 0x7FFFFFFF
cmpl $0x8, %r13d
jne 0x18365
movq 0x8(%rsp), %rdi
movq 0x60(%rdi), %rax
addq $0x18, %rsp
testq %rax, %rax
je 0x183fc
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
callq 0x18f62
movq (%rbx), %r8
leaq 0x5d37(%rip), %rdx      # 0x1e117
xorl %edi, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x19ca8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/intel[P]pf-bb-config/bb_acc_vfio.c
// Function: vfio_uuid_parse
int vfio_uuid_parse(char *uuid_str, unsigned char *uuid)
{
	int i, inx;
	int high_n = 1;
	unsigned char tmp;

	if (strlen(uuid_str) != VFIO_VF_TOKEN_STR_LEN) {
		LOG(ERR, "uuid string len is wrong: %d", (int)strlen(uuid_str));
		return -1;
	}
	for (i = 0, inx = 0;
			((i < VFIO_VF_TOKEN_STR_LEN) && (inx < VFIO_VF_TOKEN_LEN));
			i++) {
		if (uuid_str[i] == '-') {
			if ((i ==  8) || (i == 13) || (i == 18) || (i == 23))
				continue;
		}
		if (!isxdigit(uuid_str[i])) {
			LOG(ERR, "Unknown char in uuid string");
			return -1;
		}
		tmp = isdigit(uuid_str[i]) ? uuid_str[i] - '0' :
				tolower(uuid_str[i]) - 'a' + 0xA;

		if (high_n) {
			uuid[inx] = (tmp & 0xF) << 4;
			high_n = 0;
		} else {
			uuid[inx++] |= (tmp & 0xF);
			high_n = 1;
		}
	}

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, (%rsp)
movq %rdi, %rbx
callq 0xd110
cmpq $0x24, %rax
jne 0x186e0
movl $0x1, %r13d
xorl %r15d, %r15d
xorl %r12d, %r12d
movzbl (%rbx,%r15), %ebp
cmpl $0x2d, %ebp
jne 0x18663
cmpl $0x17, %r15d
ja 0x18663
movl $0x842100, %eax         # imm = 0x842100
btl %r15d, %eax
jb 0x186c9
callq 0xd450
movq (%rax), %rax
movsbq %bpl, %r14
movzwl (%rax,%r14,2), %eax
btl $0xc, %eax
jae 0x18717
btl $0xb, %eax
jb 0x18695
callq 0xd440
movq (%rax), %rax
movl (%rax,%r14,4), %ebp
addl $-0x57, %ebp
jmp 0x18698
addl $-0x30, %ebp
testl %r13d, %r13d
jne 0x186b7
movslq %r12d, %rax
incl %r12d
andb $0xf, %bpl
movq (%rsp), %rcx
orb %bpl, (%rcx,%rax)
movl $0x1, %r13d
jmp 0x186c9
shlb $0x4, %bpl
movslq %r12d, %rax
movq (%rsp), %rcx
movb %bpl, (%rcx,%rax)
xorl %r13d, %r13d
xorl %eax, %eax
cmpq $0x22, %r15
ja 0x18740
incq %r15
cmpl $0x10, %r12d
jl 0x18648
jmp 0x18740
callq 0x18f62
movq %rax, %r14
leaq 0x1b7e1(%rip), %rax     # 0x33ed0
movq (%rax), %r15
movq %rbx, %rdi
callq 0xd110
leaq 0x5492(%rip), %rdx      # 0x1db93
xorl %edi, %edi
xorl %esi, %esi
movq %r14, %rcx
movq %r15, %r8
movl %eax, %r9d
xorl %eax, %eax
callq 0x19ca8
jmp 0x1873b
callq 0x18f62
leaq 0x1b7ad(%rip), %rcx     # 0x33ed0
movq (%rcx), %r8
leaq 0x548a(%rip), %rdx      # 0x1dbb7
xorl %edi, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x19ca8
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/intel[P]pf-bb-config/daemon.c
// Function: reset_mode_exec
static int
reset_mode_exec(struct cmdDef *cmd, void *ci)
{
	struct cmdReq *cmd_req = (struct cmdReq *)ci;
	struct reset_mode_req *reset_mode = (struct reset_mode_req *)CMD_REQ(ci);
	const char *reset_mode_str[2] = {"cluster_reset", "pf_flr"};


	if ((reset_mode->mode != RESET_MODE_CLUSTER_LEVEL) &&
			(reset_mode->mode != RESET_MODE_FLR)) {
		LOG(ERR, "Unknown reset_mode request:%d", reset_mode->mode);
		return -1;
	}
	LOG(INFO, "reset_mode set to : %s", reset_mode_str[reset_mode->mode]);

	update_reset_mode(cmd_req->priv, reset_mode->mode);

	return 0;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl 0x10(%rsi), %ebp
callq 0x19c5d
movl 0x10(%rbx), %r9d
leaq 0x1af0b(%rip), %rcx     # 0x33ed0
cmpl $0x2, %ebp
jae 0x19004
movq 0x10(%rcx), %r8
leaq 0x59af(%rip), %rcx      # 0x1e984
movslq (%rcx,%r9,4), %r9
addq %rcx, %r9
leaq 0x5777(%rip), %rdx      # 0x1e75a
xorl %ebp, %ebp
movl $0x2, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x19ca8
movq 0x8(%rbx), %rdi
movl 0x10(%rbx), %esi
callq 0x1a3b8
jmp 0x19021
movq (%rcx), %r8
leaq 0x5727(%rip), %rdx      # 0x1e735
xorl %edi, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x19ca8
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/intel[P]pf-bb-config/daemon.c
// Function: auto_reset_exec
static int
auto_reset_exec(struct cmdDef *cmd, void *ci)
{
	struct cmdReq *cmd_req = (struct cmdReq *)ci;
	struct auto_reset_req *auto_reset = (struct auto_reset_req *)CMD_REQ(ci);
	const char *auto_reset_str[2] = {"off", "on"};

	if ((auto_reset->mode != AUTO_RESET_OFF) &&
			(auto_reset->mode != AUTO_RESET_ON)) {
		LOG(ERR, "Unknown auto_reset mode: %d", auto_reset->mode);
		return -1;
	}
	LOG(INFO, "Auto reset set to : %s", auto_reset_str[auto_reset->mode]);

	auto_reset_mode(cmd_req->priv, auto_reset->mode);

	return 0;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl 0x10(%rsi), %ebp
callq 0x19c5d
movl 0x10(%rbx), %r9d
leaq 0x1ae8d(%rip), %rcx     # 0x33ed0
cmpl $0x2, %ebp
jae 0x19082
movq 0x10(%rcx), %r8
leaq 0x5939(%rip), %rcx      # 0x1e98c
movslq (%rcx,%r9,4), %r9
addq %rcx, %r9
leaq 0x5741(%rip), %rdx      # 0x1e7a2
xorl %ebp, %ebp
movl $0x2, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x19ca8
movq 0x8(%rbx), %rdi
movl 0x10(%rbx), %esi
callq 0x1a432
jmp 0x1909f
movq (%rcx), %r8
leaq 0x56f3(%rip), %rdx      # 0x1e77f
xorl %edi, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x19ca8
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/intel[P]pf-bb-config/daemon.c
// Function: exit_app_exec
static int
exit_app_exec(struct cmdDef *cmd, void *ci)
{
	struct cmdReq *cmd_req = (struct cmdReq *)ci;
	hw_device *accel_dev = (hw_device *)cmd_req->priv;

	/* disable interrupts */
	if ((accel_dev->ops.disable_intr) &&
			(accel_dev->ops.disable_intr(accel_dev))) {
		LOG(ERR, "Disable interrupts failed");
		return -1;
	}

	LOG(INFO, "exit_app command received");
	sig_fun(0);
	return 0;
}

// Assembly:
pushq %rbx
movq 0x8(%rsi), %rdi
movq 0x48(%rdi), %rax
testq %rax, %rax
je 0x19127
callq *%rax
testl %eax, %eax
je 0x19127
callq 0x19c5d
leaq 0x1adc8(%rip), %rcx     # 0x33ed0
movq (%rcx), %r8
leaq 0x56e5(%rip), %rdx      # 0x1e7f7
xorl %edi, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x19ca8
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0x19158
callq 0x19c5d
leaq 0x1ad9d(%rip), %rcx     # 0x33ed0
movq 0x10(%rcx), %r8
leaq 0x56da(%rip), %rdx      # 0x1e818
xorl %ebx, %ebx
movl $0x2, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x19ca8
xorl %edi, %edi
callq 0x19bea
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/intel[P]pf-bb-config/daemon.c
// Function: mem_read_exec
static int
mem_read_exec(struct cmdDef *cmd, void *ci)
{
	struct cmdReq *cmd_req = (struct cmdReq *)ci;
	struct mm_read_req *mm_read = (struct mm_read_req *)CMD_REQ(ci);

	LOG(INFO, "mm_read command received");
	LOG(DEBUG, "mm_read: reg_op_flag	= 0x%x\n", mm_read->reg_op_flag);
	LOG(DEBUG, "mm_read: reg_rw_address	= 0x%x\n", mm_read->reg_rw_address);
	LOG(DEBUG, "mm_read: write_payload	= 0x%x\n", mm_read->write_payload);

	acc_mem_read(cmd_req->priv, mm_read->reg_op_flag,
			mm_read->reg_rw_address, mm_read->write_payload);

	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
callq 0x19c5d
leaq 0x1ace3(%rip), %r15     # 0x33ed0
movq 0x10(%r15), %r8
leaq 0x569d(%rip), %rdx      # 0x1e895
movl $0x2, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x19ca8
callq 0x19c5d
movq 0x18(%r15), %r8
movl 0x10(%rbx), %ecx
movl %ecx, (%rsp)
leaq 0x5696(%rip), %rdx      # 0x1e8b5
leaq 0x56b9(%rip), %r14      # 0x1e8df
movl $0x3, %edi
xorl %esi, %esi
movq %rax, %rcx
movq %r14, %r9
xorl %eax, %eax
callq 0x19ca8
callq 0x19c5d
movq 0x18(%r15), %r8
movl 0x14(%rbx), %ecx
movl %ecx, (%rsp)
leaq 0x569d(%rip), %rdx      # 0x1e8ed
movl $0x3, %edi
xorl %esi, %esi
movq %rax, %rcx
movq %r14, %r9
xorl %eax, %eax
callq 0x19ca8
callq 0x19c5d
movq 0x18(%r15), %r8
movl 0x18(%rbx), %ecx
movl %ecx, (%rsp)
leaq 0x56a0(%rip), %rdx      # 0x1e91a
movl $0x3, %edi
xorl %esi, %esi
movq %rax, %rcx
movq %r14, %r9
xorl %eax, %eax
callq 0x19ca8
movq 0x8(%rbx), %rdi
movl 0x10(%rbx), %esi
movl 0x14(%rbx), %edx
movl 0x18(%rbx), %ecx
callq 0x1a7f4
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/intel[P]pf-bb-config/daemon.c
// Function: event_add_fd
int event_add_fd(int fd, cbFp_t cbFp,  void *cbData)
{
	int i;

	if (eventFd.pollfd_count >= MAX_EVENTS) {
		LOG(ERR, "failed to add event fd");
		return -1;
	}

	for (i = 0; i < MAX_EVENTS; i++) {
		if (eventFd.fd[i] != -1)
			continue;

		eventFd.fd[i] = fd;
		eventFd.cbFp[i] = cbFp;
		eventFd.cbData[i] = cbData;
		eventFd.pollfd_count++;
		LOG(DEBUG, "location: %d, pollfd_count=%d", i, eventFd.pollfd_count);
		return 0;
	}

	LOG(ERR, "Event fd add failed");
	return -1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpl $0xa, 0x2154f(%rip)     # 0x3aa70
jle 0x1953b
callq 0x19c5d
leaq 0x1a9a1(%rip), %rcx     # 0x33ed0
movq (%rcx), %r8
leaq 0x4ef3(%rip), %rdx      # 0x1e42c
jmp 0x1956d
leaq 0x213f6(%rip), %rax     # 0x3a938
xorl %r14d, %r14d
cmpl $-0x1, (%rax)
je 0x19582
incq %r14
addq $0x4, %rax
cmpq $0xb, %r14
jne 0x19545
callq 0x19c5d
leaq 0x1a96d(%rip), %rcx     # 0x33ed0
movq (%rcx), %r8
leaq 0x4f15(%rip), %rdx      # 0x1e482
xorl %edi, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x19ca8
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0x195de
movl %edi, (%rax)
leaq 0x213ad(%rip), %rax     # 0x3a938
movq %rsi, 0x30(%rax,%r14,8)
movq %rdx, 0x88(%rax,%r14,8)
incl 0x214d2(%rip)           # 0x3aa70
callq 0x19c5d
leaq 0x1a926(%rip), %rcx     # 0x33ed0
movq 0x18(%rcx), %r8
movl 0x214bb(%rip), %r10d    # 0x3aa70
leaq 0x4e8e(%rip), %rdx      # 0x1e44a
leaq 0x4eb2(%rip), %r9       # 0x1e475
xorl %ebx, %ebx
movl $0x3, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
pushq %r10
pushq %r14
callq 0x19ca8
addq $0x10, %rsp
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/intel[P]pf-bb-config/daemon.c
// Function: event_del_fd
int event_del_fd(int fd)
{
	int i;

	for (i = 0; i < MAX_EVENTS; i++) {
		if (eventFd.fd[i] == fd) {
			eventFd.fd[i] = -1;
			eventFd.cbFp[i] = NULL;
			eventFd.cbData[i] = NULL;
			eventFd.pollfd_count--;
			LOG(DEBUG, "location: %d, pollfd_count=%d", i, eventFd.pollfd_count);
			return 0;
		}
	}

	LOG(ERR, "Event del failed");
	return -1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x21345(%rip), %rax     # 0x3a938
xorl %r14d, %r14d
cmpl %edi, (%rax)
je 0x19632
incq %r14
addq $0x4, %rax
cmpq $0xb, %r14
jne 0x195f6
callq 0x19c5d
leaq 0x1a8bd(%rip), %rcx     # 0x33ed0
movq (%rcx), %r8
leaq 0x4e8d(%rip), %rdx      # 0x1e4aa
xorl %edi, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x19ca8
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0x19692
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
leaq 0x212f9(%rip), %rax     # 0x3a938
xorl %ebx, %ebx
movq %rbx, 0x30(%rax,%r14,8)
movq %rbx, 0x88(%rax,%r14,8)
decl 0x2141c(%rip)           # 0x3aa70
callq 0x19c5d
leaq 0x1a870(%rip), %rcx     # 0x33ed0
movq 0x18(%rcx), %r8
movl 0x21405(%rip), %r10d    # 0x3aa70
leaq 0x4dd8(%rip), %rdx      # 0x1e44a
leaq 0x4e24(%rip), %r9       # 0x1e49d
movl $0x3, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
pushq %r10
pushq %r14
callq 0x19ca8
addq $0x10, %rsp
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/intel[P]pf-bb-config/daemon.c
// Function: cli_channel_init
int cli_channel_init(hw_device *dev)
{
	int fd;

	fd = unix_channel_srv_init(dev);
	if (fd < 0)
		return -1;

	if (event_add_fd(fd, cli_channel_event_processor, dev) < 0) {
		close(fd);
		return -1;
	}

	return fd;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
callq 0x192ec
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testl %eax, %eax
js 0x198fc
movl %eax, %ebp
leaq -0x247(%rip), %rsi      # 0x1969c
movl %eax, %edi
movq %r14, %rdx
callq 0x19516
testl %eax, %eax
js 0x198f5
movl %ebp, %ebx
jmp 0x198fc
movl %ebp, %edi
callq 0xd1a0
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/intel[P]pf-bb-config/daemon.c
// Function: sig_fun
void sig_fun(int sig)
{
	uint8_t loopCnt = 0;
	uint16_t fdCnt = eventFd.pollfd_count;
	LOG(INFO, "Signal Received with sigNum = %u", sig);
	while (loopCnt < fdCnt) {
		/* Close all the communications */
		close(eventFd.fd[eventFd.pollfd_count]);
		eventFd.pollfd_count--;
		loopCnt++;
	}
	/* set "is_sig_term_rcv = 1"; so that event_processor exits */
	is_sig_term_rcv = 1;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edi, %ebx
movzwl 0x20e79(%rip), %ebp     # 0x3aa70
callq 0x19c5d
leaq 0x1a2cd(%rip), %rcx     # 0x33ed0
movq 0x10(%rcx), %r8
leaq 0x491c(%rip), %rdx      # 0x1e52a
movl $0x2, %edi
xorl %esi, %esi
movq %rax, %rcx
movl %ebx, %r9d
xorl %eax, %eax
callq 0x19ca8
testl %ebp, %ebp
je 0x19c51
movb $0x1, %r14b
leaq 0x20d08(%rip), %rbx     # 0x3a938
movslq 0x20e39(%rip), %rax     # 0x3aa70
movl (%rbx,%rax,4), %edi
callq 0xd1a0
decl 0x20e2b(%rip)           # 0x3aa70
movzbl %r14b, %eax
leal 0x1(%rax), %r14d
cmpl %eax, %ebp
ja 0x19c30
movb $0x1, 0x20e40(%rip)     # 0x3aa98
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/intel[P]pf-bb-config/bb_acc_log.c
// Function: bb_acc_log
int
bb_acc_log(int level, int log_type, const char *format, ...)
{
	va_list ap;
	int ret;

	va_start(ap, format);
	ret = bb_acc_vlog(level, log_type, format, ap);
	va_end(ap);

	return ret;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xd8, %rsp
movq %rdx, %rbx
leaq 0x20(%rsp), %rdx
movq %rcx, 0x18(%rdx)
movq %r8, 0x20(%rdx)
movq %r9, 0x28(%rdx)
testb %al, %al
je 0x19d01
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rdx, 0x10(%rsp)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rsp)
movabsq $0x3000000018, %rax     # imm = 0x3000000018
movq %rax, (%rsp)
cmpl $0x0, 0x20d98(%rip)     # 0x3aac0
je 0x19d85
testl %esi, %esi
leaq 0x20d75(%rip), %rcx     # 0x3aaa8
leaq 0x20d76(%rip), %rax     # 0x3aab0
cmoveq %rcx, %rax
cmpl %edi, 0x20d5c(%rip)     # 0x3aaa0
jl 0x19d8d
movq (%rax), %r14
testq %r14, %r14
je 0x19da0
movq %r14, %rdi
callq 0xd220
cmpq 0x20d5b(%rip), %rax     # 0x3aab8
jbe 0x19d6b
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xd2c0
movq %rsp, %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xd380
movl %eax, %ebx
movq %r14, %rdi
callq 0xd290
jmp 0x19da5
cmpl %edi, 0x20d15(%rip)     # 0x3aaa0
jge 0x19d91
xorl %ebx, %ebx
jmp 0x19da5
movq %rsp, %rsi
movq %rbx, %rdi
callq 0xd2b0
movl %eax, %ebx
jmp 0x19da5
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
addq $0xd8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/intel[P]pf-bb-config/bb_acc_log.c
// Function: bb_acc_logInit
int
bb_acc_logInit(char *main_file_name, char *resp_file_name, uint64_t size, int level,
		int vfiopciMode)
{
	FILE *fp = NULL, *fp_2 = NULL;

	if (!vfiopciMode) {
		/* igb_uio mode. */
		logCtl.main_fp = fp;
		logCtl.secondary_fp = fp;
		logCtl.maxSize = size; /* having no use. */
		logCtl.level = level;
		logCtl.vfiopciMode = vfiopciMode;
	} else {
		if (logCtl.main_fp != NULL)
			return 0;

		fp = fopen(main_file_name, "r+");
		if (fp == NULL) {
			fp = fopen(main_file_name, "w+");
			if (fp == NULL) {
				perror("Log file open failed");
				return -1;
			}
		}
		fp_2 = fopen(resp_file_name, "r+");
		if (fp_2 == NULL) {
			fp_2 = fopen(resp_file_name, "w+");
			if (fp_2 == NULL) {
				perror("Log file open failed");
				fclose(fp);
				return -1;
			}
		}

		logCtl.main_fp = fp;
		logCtl.secondary_fp = fp_2;
		logCtl.maxSize = size;
		logCtl.level = level;
		logCtl.vfiopciMode = vfiopciMode;
		fseek(fp, 0, SEEK_END);
		fseek(fp_2, 0, SEEK_END);
	}
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %r14
xorl %r13d, %r13d
testl %r8d, %r8d
je 0x19e84
cmpq $0x0, 0x20cd2(%rip)     # 0x3aaa8
jne 0x19ea9
movl %r8d, %ebp
movq %rsi, %r12
movq %rdi, %r15
leaq 0x4bb8(%rip), %rsi      # 0x1e9a4
callq 0xd330
testq %rax, %rax
jne 0x19e0e
leaq 0x4baa(%rip), %rsi      # 0x1e9a7
movq %r15, %rdi
callq 0xd330
testq %rax, %rax
je 0x19ebb
movq %rax, %r13
leaq 0x4b8c(%rip), %rsi      # 0x1e9a4
movq %r12, %rdi
callq 0xd330
testq %rax, %rax
jne 0x19e3d
leaq 0x4b7b(%rip), %rsi      # 0x1e9a7
movq %r12, %rdi
callq 0xd330
testq %rax, %rax
je 0x19ec9
movq %rax, %r15
movq %r13, 0x20c61(%rip)     # 0x3aaa8
movq %rax, 0x20c62(%rip)     # 0x3aab0
movq %r14, 0x20c63(%rip)     # 0x3aab8
movl %ebx, 0x20c45(%rip)     # 0x3aaa0
movl %ebp, 0x20c5f(%rip)     # 0x3aac0
movq %r13, %rdi
xorl %r13d, %r13d
xorl %esi, %esi
movl $0x2, %edx
callq 0xd2c0
movq %r15, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0xd2c0
jmp 0x19ea9
movq %r13, 0x20c1d(%rip)     # 0x3aaa8
movq %r13, 0x20c1e(%rip)     # 0x3aab0
movq %r14, 0x20c1f(%rip)     # 0x3aab8
movl %ebx, 0x20c01(%rip)     # 0x3aaa0
movl $0x0, 0x20c17(%rip)     # 0x3aac0
movl %r13d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4ae8(%rip), %rdi      # 0x1e9aa
callq 0xd340
jmp 0x19edd
leaq 0x4ada(%rip), %rdi      # 0x1e9aa
callq 0xd340
movq %r13, %rdi
callq 0xd0f0
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
jmp 0x19ea9
// File: /workspace/github_c_makefile_star2_O1/intel[P]pf-bb-config/bb_acc_log.c
// Function: bb_acc_reset_logFile
void
bb_acc_reset_logFile(char *file_name, int log_type)
{
	char sysCmd[1024];
	memset(sysCmd, 0, sizeof(sysCmd));
	if (logCtl.main_fp == NULL)
		return;
	sprintf(sysCmd, "truncate -s 0 %s", file_name);
	if (system(sysCmd)) {
		perror("Failed to clear the log file");
		return;
	}
	if (log_type == 0)
		fseek(logCtl.main_fp, 0, SEEK_SET);
	else
		fseek(logCtl.secondary_fp, 0, SEEK_SET);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x400, %rsp            # imm = 0x400
movl %esi, %ebx
movq %rdi, %r14
movq %rsp, %rdi
movl $0x400, %edx            # imm = 0x400
xorl %esi, %esi
callq 0xd180
cmpq $0x0, 0x20b7b(%rip)     # 0x3aaa8
je 0x19f5f
leaq 0x4a89(%rip), %rsi      # 0x1e9bf
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0xd3e0
movq %r15, %rdi
callq 0xd140
testl %eax, %eax
jne 0x19f88
testl %ebx, %ebx
je 0x19f6c
movq 0x20b53(%rip), %rdi     # 0x3aab0
jmp 0x19f73
addq $0x400, %rsp            # imm = 0x400
popq %rbx
popq %r14
popq %r15
retq
movq 0x20b35(%rip), %rdi     # 0x3aaa8
xorl %esi, %esi
xorl %edx, %edx
addq $0x400, %rsp            # imm = 0x400
popq %rbx
popq %r14
popq %r15
jmp 0xd2c0
leaq 0x4a41(%rip), %rdi      # 0x1e9d0
addq $0x400, %rsp            # imm = 0x400
popq %rbx
popq %r14
popq %r15
jmp 0xd340
// File: /workspace/github_c_makefile_star2_O1/intel[P]pf-bb-config/bb_acc_common.c
// Function: bb_acc_dev_reset_and_reconfig
int
bb_acc_dev_reset_and_reconfig(void *dev)
{
	hw_device *accel_dev = (hw_device *)dev;

	if (dev == NULL) {
		LOG(ERR, "Device not set");
		return -1;
	}

	/* disable interrupts */
	if ((accel_dev->ops.disable_intr) &&
			(accel_dev->ops.disable_intr(accel_dev))) {
		LOG(ERR, "Disable interrupts failed");
		return -1;
	}

	/* reset */
	if ((accel_dev->ops.flr) &&
			(accel_dev->ops.flr(accel_dev))) {
		LOG(ERR, "Device reset failed");
	}

	/* re-init and configure the device */
	if (bb_acc_reconfigure_device(accel_dev))
		return -1;

	return 0;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x1a05e
movq %rdi, %rbx
movq 0x48(%rdi), %rax
testq %rax, %rax
je 0x1a016
movq %rbx, %rdi
callq *%rax
testl %eax, %eax
je 0x1a016
callq 0x1ab6e
leaq 0x19ec6(%rip), %rcx     # 0x33ed0
movq (%rcx), %r8
leaq 0x47e3(%rip), %rdx      # 0x1e7f7
jmp 0x1a074
movq 0x68(%rbx), %rax
testq %rax, %rax
je 0x1a04c
movq %rbx, %rdi
callq *%rax
testl %eax, %eax
je 0x1a04c
callq 0x1ab6e
leaq 0x19e9c(%rip), %rcx     # 0x33ed0
movq (%rcx), %r8
leaq 0x1435d(%rip), %rdx     # 0x2e39b
xorl %edi, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x19ca8
movq %rbx, %rdi
callq 0x1a089
movl %eax, %ecx
xorl %eax, %eax
negl %ecx
sbbl %eax, %eax
jmp 0x1a087
callq 0x1ab6e
leaq 0x19e66(%rip), %rcx     # 0x33ed0
movq (%rcx), %r8
leaq 0x14311(%rip), %rdx     # 0x2e385
xorl %edi, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x19ca8
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/intel[P]pf-bb-config/bb_acc_common.c
// Function: bb_acc_reconfigure_device
static int
bb_acc_reconfigure_device(hw_device *accel_dev)
{

	/* Call device specific configuration function */
	if (accel_dev->ops.conf(accel_dev, accel_dev->bar0Addr, accel_dev->config_file,
			BB_ACC_RECFG)) {
		LOG(ERR, "Reconfiguration failed");
		return -1;
	}

	/* enable intr if supported, applicable only in case of vfio */
	if ((accel_dev->ops.enable_intr) &&
			(accel_dev->ops.enable_intr(accel_dev))) {
		LOG(ERR, "Enable interrupts failed");
		return -1;
	}

	LOG(INFO, "%s PF [%s] Reconfiguration complete!",
			accel_dev->device_name, accel_dev->pci_address);

	bb_acc_set_all_device_status(accel_dev, RTE_BBDEV_DEV_CONFIGURED);

	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdx
movq 0xb0(%rdi), %rsi
xorl %ecx, %ecx
callq *0x38(%rdi)
testl %eax, %eax
je 0x1a0d5
leaq 0x146c2(%rip), %rbx     # 0x2e76d
callq 0x1ab6e
leaq 0x19e19(%rip), %rcx     # 0x33ed0
movq (%rcx), %r8
xorl %edi, %edi
xorl %esi, %esi
movq %rbx, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x19ca8
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x1a159
movq 0x40(%rbx), %rax
testq %rax, %rax
je 0x1a0f0
movq %rbx, %rdi
callq *%rax
testl %eax, %eax
je 0x1a0f0
leaq 0x1416(%rip), %rbx      # 0x1b504
jmp 0x1a0ab
callq 0x1ab6e
leaq 0x19dd4(%rip), %rcx     # 0x33ed0
movq 0x10(%rcx), %r8
movq (%rbx), %r9
leaq 0x20(%rbx), %rcx
movq %rcx, (%rsp)
leaq 0x14679(%rip), %rdx     # 0x2e78b
xorl %r14d, %r14d
movl $0x2, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x19ca8
movl $0x3, %eax
cmpq $0x5, 0xf0(%rbx,%r14,8)
jne 0x1a146
xorl %eax, %eax
cmpl $0x1, 0x4f4(%rbx)
sete %al
xorq $0x7, %rax
movq %rax, 0xf0(%rbx,%r14,8)
incq %r14
cmpq $0x40, %r14
jne 0x1a126
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/intel[P]pf-bb-config/bb_acc_common.c
// Function: bb_acc_cluster_reset_and_reconfig
int
bb_acc_cluster_reset_and_reconfig(void *dev)
{
	hw_device *accel_dev = (hw_device *)dev;

	LOG(DEBUG, "Cluster reset and reconfig");

	if (accel_dev == NULL)
		return 0;

	/* disable interrupts */
	if ((accel_dev->ops.disable_intr) &&
			(accel_dev->ops.disable_intr(accel_dev))) {
		LOG(ERR, "Disable interrupts failed");
		return -1;
	}

	if (accel_dev->ops.cluster_reset)
		accel_dev->ops.cluster_reset(accel_dev);
	else
		LOG(ERR, "Cluster reset is not supported");

	/* re-init and configure the device */
	if (bb_acc_reconfigure_device(accel_dev))
		return -1;

	LOG(DEBUG, "Done");
	return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x1ab6e
leaq 0x19d5c(%rip), %r14     # 0x33ed0
movq 0x18(%r14), %r8
leaq 0x14237(%rip), %rdx     # 0x2e3b6
leaq 0x14258(%rip), %r9      # 0x2e3de
xorl %ebp, %ebp
movl $0x3, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x19ca8
testq %rbx, %rbx
je 0x1a240
movq 0x48(%rbx), %rax
testq %rax, %rax
je 0x1a1d8
movq %rbx, %rdi
callq *%rax
testl %eax, %eax
je 0x1a1d8
callq 0x1ab6e
movq (%r14), %r8
leaq 0x4634(%rip), %rdx      # 0x1e7f7
xorl %edi, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x19ca8
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
jmp 0x1a240
movq 0x70(%rbx), %rax
testq %rax, %rax
je 0x1a1e8
movq %rbx, %rdi
callq *%rax
jmp 0x1a205
callq 0x1ab6e
movq (%r14), %r8
leaq 0x14209(%rip), %rdx     # 0x2e400
xorl %edi, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x19ca8
movq %rbx, %rdi
callq 0x1a089
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testl %eax, %eax
jne 0x1a240
callq 0x1ab6e
movq 0x18(%r14), %r8
leaq 0x12fe(%rip), %rdx      # 0x1b524
leaq 0x141b1(%rip), %r9      # 0x2e3de
xorl %ebp, %ebp
movl $0x3, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x19ca8
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/intel[P]pf-bb-config/bb_acc_common.c
// Function: bb_acc_cluster_reset_and_flr_reconfig
int
bb_acc_cluster_reset_and_flr_reconfig(void *dev)
{
	hw_device *accel_dev = (hw_device *)dev;

	LOG(DEBUG, "Cluster reset and reconfig");

	if (accel_dev == NULL)
		return 0;

	/* Disable interrupts. */
	if ((accel_dev->ops.disable_intr) &&
			(accel_dev->ops.disable_intr(accel_dev))) {
		LOG(ERR, "Disable interrupts failed");
		return -1;
	}

	/* Cluster reset first. */
	if (accel_dev->ops.cluster_reset)
		accel_dev->ops.cluster_reset(accel_dev);
	else
		LOG(ERR, "Cluster reset is not supported");

	/* PF FLR. */
	if ((accel_dev->ops.flr) &&
			(accel_dev->ops.flr(accel_dev))) {
		LOG(ERR, "Device reset failed");
	}

	/* Re-init and configure the device. */
	if (bb_acc_reconfigure_device(accel_dev))
		return -1;

	LOG(DEBUG, "Done");
	return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x1ab6e
leaq 0x19c76(%rip), %r14     # 0x33ed0
movq 0x18(%r14), %r8
leaq 0x14151(%rip), %rdx     # 0x2e3b6
leaq 0x141ba(%rip), %r9      # 0x2e426
xorl %ebp, %ebp
movl $0x3, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x19ca8
testq %rbx, %rbx
je 0x1a358
movq 0x48(%rbx), %rax
testq %rax, %rax
je 0x1a2c1
movq %rbx, %rdi
callq *%rax
testl %eax, %eax
je 0x1a2c1
callq 0x1ab6e
movq (%r14), %r8
leaq 0x454e(%rip), %rdx      # 0x1e7f7
xorl %edi, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x19ca8
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
jmp 0x1a358
movq 0x70(%rbx), %rax
testq %rax, %rax
je 0x1a2d1
movq %rbx, %rdi
callq *%rax
jmp 0x1a2ee
callq 0x1ab6e
movq (%r14), %r8
leaq 0x14120(%rip), %rdx     # 0x2e400
xorl %edi, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x19ca8
movq 0x68(%rbx), %rax
testq %rax, %rax
je 0x1a31d
movq %rbx, %rdi
callq *%rax
testl %eax, %eax
je 0x1a31d
callq 0x1ab6e
movq (%r14), %r8
leaq 0x1408c(%rip), %rdx     # 0x2e39b
xorl %edi, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x19ca8
movq %rbx, %rdi
callq 0x1a089
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testl %eax, %eax
jne 0x1a358
callq 0x1ab6e
movq 0x18(%r14), %r8
leaq 0x11e6(%rip), %rdx      # 0x1b524
leaq 0x140e1(%rip), %r9      # 0x2e426
xorl %ebp, %ebp
movl $0x3, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x19ca8
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/intel[P]pf-bb-config/bb_acc_common.c
// Function: bb_acc_set_all_device_status
void
bb_acc_set_all_device_status(void *dev, unsigned int status)
{
	unsigned int i;
	hw_device *accel_dev = (hw_device *)dev;

	for (i = 0; i < BB_ACC_MAX_VFS; i++) {
		if (status == RTE_BBDEV_DEV_CONFIGURED) {
			/* After Hard reset the application needs to restart/reconfigure */
			if (accel_dev->dev_status[i] == RTE_BBDEV_DEV_FATAL_ERR) {
				if (accel_dev->device_reset_using_flr == DEVICE_RESET_USING_FLR)
					accel_dev->dev_status[i] = RTE_BBDEV_DEV_RESTART_REQ;
				else
					accel_dev->dev_status[i] = RTE_BBDEV_DEV_RECONFIG_REQ;
			} else
				accel_dev->dev_status[i] = RTE_BBDEV_DEV_CONFIGURED;
		} else
			accel_dev->dev_status[i] = status;
	}
}

// Assembly:
movl %esi, %eax
xorl %ecx, %ecx
cmpl $0x3, %esi
jne 0x1a38a
cmpq $0x5, 0xf0(%rdi,%rcx,8)
jne 0x1a394
cmpl $0x1, 0x4f4(%rdi)
jne 0x1a3a2
movq $0x6, 0xf0(%rdi,%rcx,8)
jmp 0x1a3ae
movq %rax, 0xf0(%rdi,%rcx,8)
jmp 0x1a3ae
movq $0x3, 0xf0(%rdi,%rcx,8)
jmp 0x1a3ae
movq $0x7, 0xf0(%rdi,%rcx,8)
incq %rcx
cmpq $0x40, %rcx
jne 0x1a363
retq
// File: /workspace/github_c_makefile_star2_O1/intel[P]pf-bb-config/bb_acc_common.c
// Function: update_reset_mode
int
update_reset_mode(void *dev, int mode)
{
	hw_device *accel_dev = (hw_device *)dev;

	LOG(DEBUG, "Change reset mode:");

	accel_dev->device_reset_using_flr = mode;

	LOG(DEBUG, "Done");

	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
callq 0x1ab6e
leaq 0x19aff(%rip), %r12     # 0x33ed0
movq 0x18(%r12), %r8
leaq 0x1406f(%rip), %rdx     # 0x2e44c
leaq 0x14088(%rip), %r15     # 0x2e46c
movl $0x3, %edi
xorl %esi, %esi
movq %rax, %rcx
movq %r15, %r9
xorl %eax, %eax
callq 0x19ca8
movl %ebx, 0x4f4(%r14)
callq 0x1ab6e
movq 0x18(%r12), %r8
leaq 0x1114(%rip), %rdx      # 0x1b524
movl $0x3, %edi
xorl %esi, %esi
movq %rax, %rcx
movq %r15, %r9
xorl %eax, %eax
callq 0x19ca8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/intel[P]pf-bb-config/bb_acc_common.c
// Function: auto_reset_mode
int
auto_reset_mode(void *dev, int mode)
{
	hw_device *accel_dev = (hw_device *)dev;

	LOG(DEBUG, "Auto reset mode change: ");

	accel_dev->auto_reconfig_on_fatal_error = mode;

	LOG(DEBUG, "Done");

	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
callq 0x1ab6e
leaq 0x19a85(%rip), %r12     # 0x33ed0
movq 0x18(%r12), %r8
leaq 0x14027(%rip), %rdx     # 0x2e47e
leaq 0x14046(%rip), %r15     # 0x2e4a4
movl $0x3, %edi
xorl %esi, %esi
movq %rax, %rcx
movq %r15, %r9
xorl %eax, %eax
callq 0x19ca8
movl %ebx, 0x4f0(%r14)
callq 0x1ab6e
movq 0x18(%r12), %r8
leaq 0x109a(%rip), %rdx      # 0x1b524
movl $0x3, %edi
xorl %esi, %esi
movq %rax, %rcx
movq %r15, %r9
xorl %eax, %eax
callq 0x19ca8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/intel[P]pf-bb-config/bb_acc_common.c
// Function: clear_log_file
void
clear_log_file(void *dev)
{
	char log_file[BB_ACC_LOG_FILE_LEN];
	hw_device *accel_dev = (hw_device *)dev;
	sprintf(log_file, "%s/pf_bb_cfg_%s.log", BB_ACC_DEFAULT_LOG_PATH,
			accel_dev->pci_address);
	LOG(DEBUG, "log_file = %s", log_file);
	bb_acc_reset_logFile(log_file, BB_ACC_LOG_MAIN);
}

// Assembly:
pushq %rbx
subq $0x90, %rsp
leaq 0x20(%rdi), %rcx
leaq 0xcbc(%rip), %rsi       # 0x1b17b
leaq 0xcc9(%rip), %rdx       # 0x1b18f
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0xd3e0
callq 0x1ab6e
leaq 0x199ef(%rip), %rcx     # 0x33ed0
movq 0x18(%rcx), %r8
movq %rbx, (%rsp)
leaq 0x13fc4(%rip), %rdx     # 0x2e4b4
leaq 0x13fd8(%rip), %r9      # 0x2e4cf
movl $0x3, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x19ca8
movq %rbx, %rdi
xorl %esi, %esi
callq 0x19f05
addq $0x90, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/intel[P]pf-bb-config/bb_acc_common.c
// Function: clear_log_resp_file
void
clear_log_resp_file(void *dev)
{
	char log_file[BB_ACC_LOG_FILE_LEN];
	hw_device *accel_dev = (hw_device *)dev;
	sprintf(log_file, "%s/pf_bb_cfg_%s_response.log", BB_ACC_DEFAULT_LOG_PATH,
			accel_dev->pci_address);
	LOG(DEBUG, "logRespFile = %s", log_file);
	bb_acc_reset_logFile(log_file, BB_ACC_LOG_RESP);
}

// Assembly:
pushq %rbx
subq $0x90, %rsp
leaq 0x20(%rdi), %rcx
leaq 0xc6a(%rip), %rsi       # 0x1b198
leaq 0xc5a(%rip), %rdx       # 0x1b18f
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0xd3e0
callq 0x1ab6e
leaq 0x19980(%rip), %rcx     # 0x33ed0
movq 0x18(%rcx), %r8
movq %rbx, (%rsp)
leaq 0x13f7f(%rip), %rdx     # 0x2e4de
leaq 0x13f96(%rip), %r9      # 0x2e4fc
movl $0x3, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x19ca8
movq %rbx, %rdi
movl $0x1, %esi
callq 0x19f05
addq $0x90, %rsp
popq %rbx
retq