LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_transform.c
// Function: phi_lift_node_init
static void
phi_lift_node_init(struct phi_lift_node_list *nodes, phi_lift_node_t *pln,
                   ir_valuetype_t vt)
{
  pln->pln_vt = vt;
  LIST_INSERT_HEAD(nodes, pln, pln_link);
  LIST_INIT(&pln->pln_src);
  pln->pln_dst = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdx, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
je 0x280ef
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x28108
movq -0x18(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x18(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_transform.c
// Function: insert_move
static void
insert_move(ir_unit_t *iu, ir_valuetype_t to, ir_valuetype_t from,
            ir_instr_t *before)
{
  ir_instr_move_t *m =
    instr_add_before(sizeof(ir_instr_move_t), IR_IC_MOVE, before);
  m->super.ii_ret = to;
  m->value = from;
  value_bind_return_value(iu, &m->super);
  instr_bind_input(iu, m->value, &m->super);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rdx
movl $0x60, %edi
movl $0x15, %esi
callq 0x26380
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x8(%rbp), %rcx
movq %rcx, 0x2c(%rax)
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x58(%rax)
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x20cf0
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rax
movq -0x28(%rbp), %rdx
movq 0x58(%rax), %rsi
callq 0x267c0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_type.c
// Function: type_make
static int
type_make(ir_unit_t *iu, int code)
{
  for(int i = 0; i < VECTOR_LEN(&iu->iu_types); i++) {
    ir_type_t *it = &VECTOR_ITEM(&iu->iu_types, i);
    if(it->it_code == code)
      return i;
  }

  iu->iu_types_created = 1;

  ir_type_t it;
  int r = VECTOR_LEN(&iu->iu_types);
  it.it_code = code;
  VECTOR_PUSH_BACK(&iu->iu_types, it);
  return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movslq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x170(%rcx), %rax
jae 0x28204
movq -0x10(%rbp), %rax
movq 0x168(%rax), %rax
movslq -0x18(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0x281f7
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x282cc
jmp 0x281f9
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x281b6
movq -0x10(%rbp), %rax
movl $0x1, 0x368(%rax)
movq -0x10(%rbp), %rax
movq 0x170(%rax), %rax
movl %eax, -0x4c(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq 0x170(%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
addq $0x1, %rax
movq -0x10(%rbp), %rcx
cmpq 0x178(%rcx), %rax
jbe 0x28292
movq -0x58(%rbp), %rcx
addq $0x1, %rcx
shlq %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x178(%rax)
movq -0x10(%rbp), %rax
imulq $0x28, 0x178(%rax), %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rax
movq 0x168(%rax), %rdi
movq -0x60(%rbp), %rsi
callq 0x3390
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x168(%rax)
movq -0x58(%rbp), %rcx
addq $0x1, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x170(%rax)
movq -0x10(%rbp), %rax
movq 0x168(%rax), %rdi
imulq $0x28, -0x58(%rbp), %rax
addq %rax, %rdi
leaq -0x48(%rbp), %rsi
movl $0x28, %edx
callq 0x3330
movl -0x4c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_value.c
// Function: instr_bind_clear_inputs
static void
instr_bind_clear_inputs(ir_instr_t *ii)
{
  ir_value_instr_t *ivi, *next;
  for(ivi = LIST_FIRST(&ii->ii_values); ivi != NULL; ivi = next) {
    next = LIST_NEXT(ivi, ivi_instr_link);
    if(ivi->ivi_relation == IVI_INPUT)
      ivi_destroy(ivi);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x287aa
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x30(%rax)
jne 0x2879e
movq -0x10(%rbp), %rdi
callq 0x1cc50
jmp 0x287a0
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x28778
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_transform.c
// Function: legalize_aggregate_move
static void
legalize_aggregate_move(ir_unit_t *iu, ir_instr_move_t *ii)
{
  const ir_value_t *src = value_get(iu, ii->value.value);
  const ir_value_t *dst = value_get(iu, ii->super.ii_ret.value);

  assert(src->iv_num_values == dst->iv_num_values);
  const ir_valuetype_t *sv = src->iv_data;
  const ir_valuetype_t *dv = dst->iv_data;
  for(int i = 0; i < src->iv_num_values; i++)
    insert_move(iu, dv[i], sv[i], &ii->super);

  instr_destroy(&ii->super);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x58(%rax), %esi
callq 0x20ee0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x2c(%rax), %esi
callq 0x20ee0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl 0x30(%rax), %eax
movq -0x20(%rbp), %rcx
cmpl 0x30(%rcx), %eax
jne 0x28c5a
jmp 0x28c79
leaq 0x16dd9(%rip), %rdi     # 0x3fa3a
leaq 0x16785(%rip), %rsi     # 0x3f3ed
movl $0xa27, %edx            # imm = 0xA27
leaq 0x16d41(%rip), %rcx     # 0x3f9b5
callq 0x31c0
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x30(%rcx), %eax
jge 0x28cd4
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movslq -0x34(%rbp), %r8
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rdx
movq -0x10(%rbp), %rcx
movq (%rsi,%r8,8), %rsi
movq (%rax,%rdx,8), %rdx
callq 0x28130
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x28c98
movq -0x10(%rbp), %rdi
callq 0x1cad0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_transform.c
// Function: split_aggregated_load
static ir_instr_t *
split_aggregated_load(ir_unit_t *iu, ir_instr_load_t *ii)
{
  ir_instr_load_t *orig = ii;
  ir_instr_t *r = &ii->super;

  int esize;
  // Combined loads
  const ir_type_t *aggty = type_get(iu, type_get_pointee(iu, ii->ptr.type));
  switch(aggty->it_code) {
  case IR_TYPE_STRUCT:
    assert(aggty->it_struct.num_elements == -ii->super.ii_ret.value);
    for(int i = 0; i < -ii->super.ii_ret.value; i++) {
      int offset = aggty->it_struct.elements[i].offset;
      r = emit_partial_load(iu, orig, offset, r, ii->super.ii_rets[i]);
    }
    break;
  case IR_TYPE_ARRAY:
    esize = type_sizeof(iu, aggty->it_array.element_type);
    for(int i = 0; i < -ii->super.ii_ret.value; i++) {
      int offset = esize * i;
      r = emit_partial_load(iu, orig, offset, r, ii->super.ii_rets[i]);
    }
    break;
  default:
    abort();
  }
  instr_destroy(&orig->super);
  return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movq -0x10(%rbp), %rax
movl 0x5c(%rax), %esi
callq 0x291c0
movq -0x50(%rbp), %rdi
movl %eax, %esi
callq 0x1ee20
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x44(%rbp)
testl %eax, %eax
je 0x290a3
jmp 0x29092
movl -0x44(%rbp), %eax
subl $0xa, %eax
je 0x29137
jmp 0x291a0
movq -0x30(%rbp), %rax
movl 0x18(%rax), %eax
movq -0x10(%rbp), %rdx
xorl %ecx, %ecx
subl 0x2c(%rdx), %ecx
cmpl %ecx, %eax
jne 0x290b9
jmp 0x290d8
leaq 0x16a7f(%rip), %rdi     # 0x3fb3f
leaq 0x16326(%rip), %rsi     # 0x3f3ed
movl $0xb23, %edx            # imm = 0xB23
leaq 0x16aa5(%rip), %rcx     # 0x3fb78
callq 0x31c0
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
movq -0x10(%rbp), %rdx
xorl %ecx, %ecx
subl 0x2c(%rdx), %ecx
cmpl %ecx, %eax
jge 0x29135
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x34(%rbp), %rcx
movl 0x4(%rax,%rcx,8), %eax
movl %eax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x38(%rbp), %edx
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x34(%rbp), %r8
movq (%rax,%r8,8), %r8
callq 0x29260
movq %rax, -0x20(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x290df
jmp 0x291a5
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rax
movl 0xc(%rax), %esi
callq 0x1ecd0
movl %eax, -0x24(%rbp)
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movq -0x10(%rbp), %rdx
xorl %ecx, %ecx
subl 0x2c(%rdx), %ecx
cmpl %ecx, %eax
jge 0x2919e
movl -0x24(%rbp), %eax
imull -0x3c(%rbp), %eax
movl %eax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x40(%rbp), %edx
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x3c(%rbp), %r8
movq (%rax,%r8,8), %r8
callq 0x29260
movq %rax, -0x20(%rbp)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x29151
jmp 0x291a5
callq 0x3050
movq -0x18(%rbp), %rdi
callq 0x1cad0
movq -0x20(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_type.c
// Function: type_get_pointee
static unsigned int
type_get_pointee(ir_unit_t *iu, unsigned int id)
{
  ir_type_t *it = type_get(iu, id);
  if(it->it_code != IR_TYPE_POINTER)
    parser_error(iu, "Type (%s) (index:%d) is not a pointer",
                 type_str_index(iu, id), id);
  if(it->it_pointer.pointee == -1)
    parser_error(iu, "Attempting to dereference void pointer");
  return it->it_pointer.pointee;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x1ee20
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0xb, (%rax)
je 0x29221
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x22560
movq -0x20(%rbp), %rdi
movq %rax, %r8
movl -0xc(%rbp), %r9d
leaq 0x15aa2(%rip), %rsi     # 0x3ecb0
movl $0x8a, %edx
leaq 0x169a0(%rip), %rcx     # 0x3fbba
movb $0x0, %al
callq 0x18220
movq -0x18(%rbp), %rax
cmpl $-0x1, 0x8(%rax)
jne 0x29249
movq -0x8(%rbp), %rdi
leaq 0x15a7a(%rip), %rsi     # 0x3ecb0
movl $0x8c, %edx
leaq 0x1699e(%rip), %rcx     # 0x3fbe0
movb $0x0, %al
callq 0x18220
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_transform.c
// Function: emit_partial_load
static ir_instr_t *
emit_partial_load(ir_unit_t *iu, ir_instr_load_t *orig, int offset,
                  ir_instr_t *after, ir_valuetype_t ret)
{
  assert(orig->cast == -1);

  ir_instr_load_t *n =
    instr_add_after(sizeof(ir_instr_load_t), IR_IC_LOAD, after);
  n->immediate_offset = orig->immediate_offset + offset;
  n->ptr = orig->ptr;
  n->value_offset = orig->value_offset;
  n->value_offset_multiply = orig->value_offset_multiply;
  n->super.ii_ret = ret;
  n->cast = -1;

  value_bind_return_value(iu, &n->super);

  instr_bind_input(iu, n->ptr, &n->super);
  if(n->value_offset.value >= 0)
    instr_bind_input(iu, n->value_offset, &n->super);
  return &n->super;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %r8, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rax
movsbl 0x74(%rax), %eax
cmpl $-0x1, %eax
jne 0x2928a
jmp 0x292a9
leaq 0x16976(%rip), %rdi     # 0x3fc07
leaq 0x16155(%rip), %rsi     # 0x3f3ed
movl $0xb05, %edx            # imm = 0xB05
leaq 0x16974(%rip), %rcx     # 0x3fc18
callq 0x31c0
movq -0x28(%rbp), %rdx
movl $0x78, %edi
movl $0x4, %esi
callq 0x265e0
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movl 0x60(%rax), %ecx
addl -0x1c(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x60(%rax)
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x58(%rcx), %rcx
movq %rcx, 0x58(%rax)
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x64(%rcx), %rcx
movq %rcx, 0x64(%rax)
movq -0x18(%rbp), %rax
movl 0x6c(%rax), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x6c(%rax)
movq -0x30(%rbp), %rax
movq -0x8(%rbp), %rcx
movq %rcx, 0x2c(%rax)
movq -0x30(%rbp), %rax
movb $-0x1, 0x74(%rax)
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x20cf0
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rax
movq -0x30(%rbp), %rdx
movq 0x58(%rax), %rsi
callq 0x267c0
movq -0x30(%rbp), %rax
cmpl $0x0, 0x64(%rax)
jl 0x29354
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rax
movq -0x30(%rbp), %rdx
movq 0x64(%rax), %rsi
callq 0x267c0
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_transform.c
// Function: eliminate_dead_code_in_bb
static void
eliminate_dead_code_in_bb(ir_unit_t *iu, ir_function_t *f, ir_bb_t *ib)
{
  ir_instr_t *ii, *iip;
  ir_value_instr_t *ivi;
  for(ii = TAILQ_LAST(&ib->ib_instrs, ir_instr_queue); ii != NULL; ii = iip) {
    iip = TAILQ_PREV(ii, ir_instr_queue, ii_link);
    if(ii->ii_ret.value == -1 ||
       ii->ii_class == IR_IC_VMOP ||
       ii->ii_class == IR_IC_VAARG ||
       ii->ii_class == IR_IC_CALL ||
       ii->ii_class == IR_IC_INVOKE)
      continue;

    if(ii->ii_ret.value < 1)
      continue; // Maybe need to deal with multiple ret values in the future?

    ir_value_t *output = value_get(iu, ii->ii_ret.value);

    LIST_FOREACH(ivi, &output->iv_instructions, ivi_value_link) {
      if(ivi->ivi_relation == IVI_INPUT)
        break; // Someone is using our output for input ->
    }
    if(ivi != NULL)
      continue; // -> thus continue

    instr_destroy(ii);
    output->iv_class = IR_VC_DEAD;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x29450
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpl $-0x1, 0x2c(%rax)
je 0x293d7
movq -0x20(%rbp), %rax
cmpl $0x16, 0x28(%rax)
je 0x293d7
movq -0x20(%rbp), %rax
cmpl $0xf, 0x28(%rax)
je 0x293d7
movq -0x20(%rbp), %rax
cmpl $0xa, 0x28(%rax)
je 0x293d7
movq -0x20(%rbp), %rax
cmpl $0xb, 0x28(%rax)
jne 0x293d9
jmp 0x29443
movq -0x20(%rbp), %rax
cmpl $0x1, 0x2c(%rax)
jge 0x293e5
jmp 0x29443
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movl 0x2c(%rax), %esi
callq 0x20ee0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x29427
movq -0x30(%rbp), %rax
cmpl $0x0, 0x30(%rax)
jne 0x29418
jmp 0x29427
jmp 0x2941a
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x29405
cmpq $0x0, -0x30(%rbp)
je 0x29430
jmp 0x29443
movq -0x20(%rbp), %rdi
callq 0x1cad0
movq -0x38(%rbp), %rax
movl $0xc, (%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x29387
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_transform.c
// Function: liveness_set_value
static void
liveness_set_value(uint32_t *bs, ir_unit_t *iu, ir_valuetype_t vt)
{
  int value = vt.value;
  ir_value_t *iv = VECTOR_ITEM(&iu->iu_values, value);
  if(iv->iv_class != IR_VC_TEMPORARY)
    return;

  value -= iu->iu_first_func_value;
  assert(value >= 0);

  bitset(bs, value);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdx, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq 0x180(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x4, (%rax)
je 0x2a37c
jmp 0x2a3c1
movq -0x18(%rbp), %rax
movl 0x19c(%rax), %ecx
movl -0x1c(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jl 0x2a396
jmp 0x2a3b5
leaq 0x15975(%rip), %rdi     # 0x3fd12
leaq 0x15049(%rip), %rsi     # 0x3f3ed
movl $0x537, %edx            # imm = 0x537
leaq 0x1596d(%rip), %rcx     # 0x3fd1d
callq 0x31c0
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x2a3d0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_instr.c
// Function: instr_have_side_effects
static int
instr_have_side_effects(const ir_instr_t *ii)
{
  switch(ii->ii_class) {
  case IR_IC_UNREACHABLE:
  case IR_IC_RET:
  case IR_IC_VAARG:
  case IR_IC_STORE:
  case IR_IC_BR:
  case IR_IC_ALLOCA:
  case IR_IC_CALL:
  case IR_IC_VMOP:
  case IR_IC_INVOKE:
  case IR_IC_RESUME:
  case IR_IC_INSERTVAL:
  case IR_IC_LANDINGPAD:
  case IR_IC_STACKCOPY:
  case IR_IC_STACKSHRINK:
  case IR_IC_CMP_BRANCH:
    return 1;

  case IR_IC_GEP:
  case IR_IC_CAST:
  case IR_IC_LOAD:
  case IR_IC_BINOP:
  case IR_IC_CMP2:
  case IR_IC_SELECT:
  case IR_IC_LEA:
  case IR_IC_SWITCH:
  case IR_IC_PHI:
  case IR_IC_MOVE:
  case IR_IC_EXTRACTVAL:
  case IR_IC_CMP_SELECT:
  case IR_IC_MLA:
    return 0;
  }
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x28(%rax), %eax
movl %eax, -0x14(%rbp)
subl $0x2, %eax
jb 0x2a5a4
jmp 0x2a4ed
movl -0x14(%rbp), %eax
addl $-0x2, %eax
subl $0x3, %eax
jb 0x2a5ad
jmp 0x2a4fe
movl -0x14(%rbp), %eax
subl $0x5, %eax
je 0x2a5a4
jmp 0x2a50c
movl -0x14(%rbp), %eax
addl $-0x6, %eax
subl $0x2, %eax
jb 0x2a5ad
jmp 0x2a51d
movl -0x14(%rbp), %eax
subl $0x8, %eax
je 0x2a5a4
jmp 0x2a527
movl -0x14(%rbp), %eax
subl $0x9, %eax
je 0x2a5ad
jmp 0x2a531
movl -0x14(%rbp), %eax
addl $-0xa, %eax
subl $0x2, %eax
jb 0x2a5a4
jmp 0x2a53e
movl -0x14(%rbp), %eax
subl $0xc, %eax
je 0x2a5ad
jmp 0x2a548
movl -0x14(%rbp), %eax
subl $0xd, %eax
je 0x2a5a4
jmp 0x2a552
movl -0x14(%rbp), %eax
subl $0xe, %eax
je 0x2a5ad
jmp 0x2a55c
movl -0x14(%rbp), %eax
subl $0xf, %eax
je 0x2a5a4
jmp 0x2a566
movl -0x14(%rbp), %eax
subl $0x10, %eax
je 0x2a5ad
jmp 0x2a570
movl -0x14(%rbp), %eax
addl $-0x11, %eax
subl $0x3, %eax
jb 0x2a5a4
jmp 0x2a57d
movl -0x14(%rbp), %eax
addl $-0x14, %eax
subl $0x2, %eax
jb 0x2a5ad
jmp 0x2a58a
movl -0x14(%rbp), %eax
addl $-0x16, %eax
subl $0x4, %eax
jb 0x2a5a4
jmp 0x2a597
movl -0x14(%rbp), %eax
addl $-0x1a, %eax
subl $0x2, %eax
jb 0x2a5ad
jmp 0x2a5b6
movl $0x1, -0x4(%rbp)
jmp 0x2a5bd
movl $0x0, -0x4(%rbp)
jmp 0x2a5bd
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_transform.c
// Function: tribitmtx_alloc
static uint32_t *
tribitmtx_alloc(int size)
{
  if(size == 0)
    return NULL;
  size--;
  int bits = (size * size + size) / 2 + size + 1;
  int words = (bits + 31) / 32;
  return calloc(words, sizeof(int));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x2a5eb
movq $0x0, -0x8(%rbp)
jmp 0x2a632
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
imull -0xc(%rbp), %eax
addl -0xc(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
addl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
addl $0x1f, %eax
movl $0x20, %ecx
cltd
idivl %ecx
movl %eax, -0x14(%rbp)
movslq -0x14(%rbp), %rdi
movl $0x4, %esi
callq 0x32c0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_transform.c
// Function: tribitmtx_pos
static int __inline
tribitmtx_pos(const uint32_t *mtx, int x, int y)
{
  if(x > y) {
    int tmp = x;
    x = y;
    y = tmp;
  }
  return (y * y + y) / 2 + x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jle 0x2b398
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
imull -0x10(%rbp), %eax
addl -0x10(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
addl -0xc(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_vm.c
// Function: emit_i32
static void
emit_i32(ir_unit_t *iu, uint32_t i32)
{
  if(iu->iu_text_ptr + 4 >= iu->iu_text_alloc + iu->iu_text_alloc_memsize)
    parser_error(iu, "Function too big");
  *(uint32_t *)iu->iu_text_ptr = i32;
  iu->iu_text_ptr += 4;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x440(%rax), %rax
addq $0x4, %rax
movq -0x8(%rbp), %rcx
movq 0x438(%rcx), %rcx
movq -0x8(%rbp), %rdx
addq 0x448(%rdx), %rcx
cmpq %rcx, %rax
jb 0x2b4a7
movq -0x8(%rbp), %rdi
leaq 0x14a8b(%rip), %rsi     # 0x3ff1f
movl $0x94b, %edx            # imm = 0x94B
leaq 0x14ac1(%rip), %rcx     # 0x3ff61
movb $0x0, %al
callq 0x18220
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movq 0x440(%rax), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movq 0x440(%rax), %rcx
addq $0x4, %rcx
movq %rcx, 0x440(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_vm.c
// Function: emit_i16
static void
emit_i16(ir_unit_t *iu, uint16_t i16)
{
  if(iu->iu_text_ptr + 2 >= iu->iu_text_alloc + iu->iu_text_alloc_memsize)
    parser_error(iu, "Function too big");
  *(uint16_t *)iu->iu_text_ptr = i16;
  iu->iu_text_ptr += 2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movq -0x8(%rbp), %rax
movq 0x440(%rax), %rax
addq $0x2, %rax
movq -0x8(%rbp), %rcx
movq 0x438(%rcx), %rcx
movq -0x8(%rbp), %rdx
addq 0x448(%rdx), %rcx
cmpq %rcx, %rax
jb 0x2bb3b
movq -0x8(%rbp), %rdi
leaq 0x143f7(%rip), %rsi     # 0x3ff1f
movl $0x926, %edx            # imm = 0x926
leaq 0x1442d(%rip), %rcx     # 0x3ff61
movb $0x0, %al
callq 0x18220
movw -0xa(%rbp), %cx
movq -0x8(%rbp), %rax
movq 0x440(%rax), %rax
movw %cx, (%rax)
movq -0x8(%rbp), %rax
movq 0x440(%rax), %rcx
addq $0x2, %rcx
movq %rcx, 0x440(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_vm.c
// Function: emit_call
static void
emit_call(ir_unit_t *iu, ir_instr_call_t *ii, ir_function_t *f)
{
  int rf_offset = f->if_regframe_size;
  int return_reg;

  if(ii->super.ii_ret.value != -1) {
    const ir_value_t *ret = value_get(iu, ii->super.ii_ret.value);
    return_reg = value_reg(ret);
  } else {
    return_reg = 0;
  }

  ir_function_t *callee = value_function(iu, ii->callee.value);

  if(callee != NULL) {
    vm_op_t op;

    if(callee->if_ext_func != NULL) {
      op = VM_JSR_EXT;
    } else {
      op = VM_JSR;
    }

    emit_op3(iu, op, callee->if_gfid, rf_offset, return_reg);

  } else {

    const ir_value_t *iv = value_get(iu, ii->callee.value);

    if(iv->iv_class != IR_VC_REGFRAME)
      parser_error(iu, "Call via incompatible value class %d",
                   iv->iv_class);
    emit_op3(iu, VM_JSR_R, value_reg(iv), rf_offset, return_reg);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x2c(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x2c(%rax)
je 0x2fb2a
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x2c(%rax), %esi
callq 0x20ee0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x321a0
movl %eax, -0x20(%rbp)
jmp 0x2fb31
movl $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x58(%rax), %esi
callq 0x24040
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x2fb92
movq -0x30(%rbp), %rax
cmpq $0x0, 0x70(%rax)
je 0x2fb60
movl $0x170, -0x34(%rbp)     # imm = 0x170
jmp 0x2fb67
movl $0x16d, -0x34(%rbp)     # imm = 0x16D
movq -0x8(%rbp), %rdi
movl -0x34(%rbp), %esi
movq -0x30(%rbp), %rax
movl 0x34(%rax), %eax
movw %ax, %dx
movl -0x1c(%rbp), %eax
movw %ax, %cx
movl -0x20(%rbp), %eax
movzwl %dx, %edx
movzwl %cx, %ecx
movzwl %ax, %r8d
callq 0x32430
jmp 0x2fc09
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x58(%rax), %esi
callq 0x20ee0
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpl $0x5, (%rax)
je 0x2fbd4
movq -0x8(%rbp), %rdi
movq -0x40(%rbp), %rax
movl (%rax), %r8d
leaq 0x1035e(%rip), %rsi     # 0x3ff1f
movl $0x108a, %edx           # imm = 0x108A
leaq 0x10884(%rip), %rcx     # 0x40451
movb $0x0, %al
callq 0x18220
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
callq 0x321a0
movq -0x48(%rbp), %rdi
movw %ax, %dx
movl -0x1c(%rbp), %eax
movw %ax, %cx
movl -0x20(%rbp), %eax
movl $0x16e, %esi            # imm = 0x16E
movzwl %dx, %edx
movzwl %cx, %ecx
movzwl %ax, %r8d
callq 0x32430
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_vm.c
// Function: emit_alloca
static void
emit_alloca(ir_unit_t *iu, ir_instr_alloca_t *ii)
{
  const ir_value_t *ret = value_get(iu, ii->super.ii_ret.value);
  ir_value_t *iv = value_get(iu, ii->num_items_value.value);

  switch(iv->iv_class) {
  case IR_VC_CONSTANT:
    emit_op2(iu, VM_ALLOCA, value_reg(ret), ii->alignment);
    emit_i32(iu, ii->size * value_get_const32(iu, iv));
    break;

  case IR_VC_REGFRAME:
    switch(legalize_type(type_get(iu, ii->num_items_value.type))) {
    case IR_TYPE_INT32:
      emit_op3(iu, VM_ALLOCAD, value_reg(ret), ii->alignment, value_reg(iv));
      emit_i32(iu, ii->size);
      break;

    default:
      parser_error(iu, "Unable to alloca num_elements as %s",
                   type_str_index(iu, ii->num_items_value.type));
    }
    return;

  default:
    parser_error(iu, "Bad class %d for alloca elements",
                 iv->iv_class);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x2c(%rax), %esi
callq 0x20ee0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x5c(%rax), %esi
callq 0x20ee0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x24(%rbp)
subl $0x3, %eax
je 0x30715
jmp 0x30708
movl -0x24(%rbp), %eax
subl $0x5, %eax
je 0x30777
jmp 0x3082c
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x321a0
movq -0x40(%rbp), %rdi
movw %ax, %cx
movq -0x10(%rbp), %rax
movl 0x64(%rax), %eax
movl $0x1d6, %esi            # imm = 0x1D6
movzwl %cx, %edx
movzwl %ax, %ecx
callq 0x324a0
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movl 0x58(%rax), %eax
movl %eax, -0x34(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x261a0
movl -0x34(%rbp), %esi
movq -0x30(%rbp), %rdi
imull %eax, %esi
callq 0x2b450
jmp 0x30851
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x60(%rax), %esi
callq 0x1ee20
movq %rax, %rdi
callq 0x45d0
subl $0x5, %eax
jne 0x307f1
jmp 0x30796
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rdi
callq 0x321a0
movw %ax, -0x44(%rbp)
movq -0x10(%rbp), %rax
movl 0x64(%rax), %eax
movw %ax, -0x42(%rbp)
movq -0x20(%rbp), %rdi
callq 0x321a0
movq -0x50(%rbp), %rdi
movw -0x44(%rbp), %dx
movw -0x42(%rbp), %cx
movl $0x1d7, %esi            # imm = 0x1D7
movzwl %dx, %edx
movzwl %cx, %ecx
movzwl %ax, %r8d
callq 0x32430
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x58(%rax), %esi
callq 0x2b450
jmp 0x3082a
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x60(%rax), %esi
callq 0x22560
movq -0x58(%rbp), %rdi
movq %rax, %r8
leaq 0xf708(%rip), %rsi      # 0x3ff1f
movl $0x10d9, %edx           # imm = 0x10D9
leaq 0xfd1f(%rip), %rcx      # 0x40542
movb $0x0, %al
callq 0x18220
jmp 0x30851
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movl (%rax), %r8d
leaq 0xf6e1(%rip), %rsi      # 0x3ff1f
movl $0x10df, %edx           # imm = 0x10DF
leaq 0xfd1c(%rip), %rcx      # 0x40566
movb $0x0, %al
callq 0x18220
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_vm.c
// Function: emit_vmop
static void
emit_vmop(ir_unit_t *iu, ir_instr_call_t *ii)
{
  int vmop = ii->vmop;
  assert(vmop != 0);
  emit_op(iu, vmop);

  if(ii->super.ii_ret.value < -1) {
    for(int i = 0; i < -ii->super.ii_ret.value; i++) {
      const ir_value_t *ret = value_get(iu, ii->super.ii_rets[i].value);
      emit_i16(iu, value_reg(ret));
    }
  } else if(ii->super.ii_ret.value != -1) {
    const ir_value_t *ret = value_get(iu, ii->super.ii_ret.value);
    emit_i16(iu, value_reg(ret));
  }

  for(int i = 0 ; i < ii->argc; i++) {
    const ir_value_t *iv = value_get(iu, ii->argv[i].value.value);
    emit_i16(iu, value_reg(iv));
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x60(%rax), %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x31112
jmp 0x31131
leaq 0xf4ca(%rip), %rdi      # 0x405e3
leaq 0xedff(%rip), %rsi      # 0x3ff1f
movl $0x1148, %edx           # imm = 0x1148
leaq 0xf4c1(%rip), %rcx      # 0x405ed
callq 0x31c0
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x2b410
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x2c(%rax)
jge 0x311a4
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x10(%rbp), %rdx
xorl %ecx, %ecx
subl 0x2c(%rdx), %ecx
cmpl %ecx, %eax
jge 0x311a2
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x18(%rbp), %rcx
movl (%rax,%rcx,8), %esi
callq 0x20ee0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rdi
callq 0x321a0
movq -0x40(%rbp), %rdi
movzwl %ax, %esi
callq 0x2bae0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x3114e
jmp 0x311e1
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x2c(%rax)
je 0x311df
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x2c(%rax), %esi
callq 0x20ee0
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rdi
callq 0x321a0
movq -0x48(%rbp), %rdi
movzwl %ax, %esi
callq 0x2bae0
jmp 0x311e1
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x6c(%rcx), %eax
jge 0x3123e
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
addq $0x70, %rax
movslq -0x2c(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %esi
callq 0x20ee0
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x38(%rbp), %rdi
callq 0x321a0
movq -0x50(%rbp), %rdi
movzwl %ax, %esi
callq 0x2bae0
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x311e8
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_vm.c
// Function: emit_landingpad
static void
emit_landingpad(ir_unit_t *iu, ir_instr_landingpad_t *ii)
{
  if(ii->super.ii_ret.value == -2) {
    const ir_value_t *ret;
    emit_op(iu, VM_LANDINGPAD);
    ret = value_get(iu, ii->super.ii_rets[0].value);
    emit_i16(iu, value_reg(ret));
    ret = value_get(iu, ii->super.ii_rets[1].value);
    emit_i16(iu, value_reg(ret));
  } else {
    parser_error(iu, "Unable to emit landingpad");
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $-0x2, 0x2c(%rax)
jne 0x312e3
movq -0x8(%rbp), %rdi
movl $0x175, %esi            # imm = 0x175
callq 0x2b410
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movl (%rax), %esi
callq 0x20ee0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x321a0
movq -0x28(%rbp), %rdi
movzwl %ax, %esi
callq 0x2bae0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movl 0x8(%rax), %esi
callq 0x20ee0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x321a0
movq -0x20(%rbp), %rdi
movzwl %ax, %esi
callq 0x2bae0
jmp 0x31301
movq -0x8(%rbp), %rdi
leaq 0xec31(%rip), %rsi      # 0x3ff1f
movl $0x11af, %edx           # imm = 0x11AF
leaq 0xf322(%rip), %rcx      # 0x4061c
movb $0x0, %al
callq 0x18220
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_vm.c
// Function: emit_resume
static void
emit_resume(ir_unit_t *iu, ir_instr_resume_t *r)
{
  if(r->num_values != 2) {
    parser_error(iu, "Unable to emit resume with %d args", r->num_values);
  }
  emit_op(iu, VM_RESUME);
  emit_i16(iu, value_reg(value_get(iu, r->values[0].value)));
  emit_i16(iu, value_reg(value_get(iu, r->values[1].value)));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x2, 0x58(%rax)
je 0x31350
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x58(%rax), %r8d
leaq 0xebe2(%rip), %rsi      # 0x3ff1f
movl $0x11bb, %edx           # imm = 0x11BB
leaq 0xf2ed(%rip), %rcx      # 0x40636
movb $0x0, %al
callq 0x18220
movq -0x8(%rbp), %rdi
movl $0x176, %esi            # imm = 0x176
callq 0x2b410
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x5c(%rax), %esi
callq 0x20ee0
movq %rax, %rdi
callq 0x321a0
movq -0x20(%rbp), %rdi
movzwl %ax, %esi
callq 0x2bae0
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x64(%rax), %esi
callq 0x20ee0
movq %rax, %rdi
callq 0x321a0
movq -0x18(%rbp), %rdi
movzwl %ax, %esi
callq 0x2bae0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_vm.c
// Function: emit_stackcopy
static void
emit_stackcopy(ir_unit_t *iu, ir_instr_stackcopy_t *ii)
{
  const ir_value_t *ret = value_get(iu, ii->super.ii_ret.value);
  const ir_value_t *src = value_get(iu, ii->value.value);
  const ir_type_t *ty = type_get(iu, ii->value.type);

  switch(COMBINE2(src->iv_class, legalize_type(ty))) {

  case COMBINE2(IR_VC_GLOBALVAR, IR_TYPE_POINTER):
  case COMBINE2(IR_VC_CONSTANT, IR_TYPE_POINTER):
    emit_op1(iu, VM_STACKCOPYC, value_reg(ret));
    emit_i32(iu, value_get_const32(iu, src));
    emit_i32(iu, ii->size);
    return;

  case COMBINE2(IR_VC_REGFRAME, IR_TYPE_POINTER):
    emit_op2(iu, VM_STACKCOPYR, value_reg(ret), value_reg(src));
    emit_i32(iu, ii->size);
    return;
  default:
    parser_error(iu, "Can't stackcopy from %s class %d",
                 type_str(iu, ty), src->iv_class);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x2c(%rax), %esi
callq 0x20ee0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x58(%rax), %esi
callq 0x20ee0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x5c(%rax), %esi
callq 0x1ee20
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
shll $0x8, %eax
movl %eax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x45d0
movl %eax, %ecx
movl -0x30(%rbp), %eax
orl %ecx, %eax
movl %eax, -0x2c(%rbp)
subl $0x20b, %eax            # imm = 0x20B
je 0x3144f
jmp 0x31434
movl -0x2c(%rbp), %eax
subl $0x30b, %eax            # imm = 0x30B
je 0x3144f
jmp 0x31440
movl -0x2c(%rbp), %eax
subl $0x50b, %eax            # imm = 0x50B
je 0x314a6
jmp 0x314ee
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x321a0
movq -0x40(%rbp), %rdi
movl $0x1db, %esi            # imm = 0x1DB
movzwl %ax, %edx
callq 0x32150
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x261a0
movq -0x38(%rbp), %rdi
movl %eax, %esi
callq 0x2b450
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x60(%rax), %esi
callq 0x2b450
jmp 0x3152b
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rdi
callq 0x321a0
movw %ax, -0x42(%rbp)
movq -0x20(%rbp), %rdi
callq 0x321a0
movq -0x50(%rbp), %rdi
movw -0x42(%rbp), %cx
movl $0x1da, %esi            # imm = 0x1DA
movzwl %cx, %edx
movzwl %ax, %ecx
callq 0x324a0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x60(%rax), %esi
callq 0x2b450
jmp 0x3152b
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x4760
movq -0x58(%rbp), %rdi
movq %rax, %r8
movq -0x20(%rbp), %rax
movl (%rax), %r9d
leaq 0xea07(%rip), %rsi      # 0x3ff1f
movl $0xf42, %edx            # imm = 0xF42
leaq 0xf135(%rip), %rcx      # 0x40659
movb $0x0, %al
callq 0x18220
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_vm.c
// Function: emit_mla
static void
emit_mla(ir_unit_t *iu, ir_instr_ternary_t *ii)
{
  const ir_value_t *ret = value_get(iu, ii->super.ii_ret.value);
  const ir_type_t *ty = type_get(iu, ii->super.ii_ret.type);
  const ir_value_t *a1 = value_get(iu, ii->arg1.value);
  const ir_value_t *a2 = value_get(iu, ii->arg2.value);
  const ir_value_t *a3 = value_get(iu, ii->arg3.value);
  switch(legalize_type(ty)) {

  case IR_TYPE_INT32:
    emit_op4(iu, VM_MLA32, value_reg(ret),
             value_reg(a1), value_reg(a2), value_reg(a3));
    break;
  default:
    parser_error(iu, "Unable to emit mla() for type %s",
                 type_str(iu, ty));
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x2c(%rax), %esi
callq 0x20ee0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x30(%rax), %esi
callq 0x1ee20
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x58(%rax), %esi
callq 0x20ee0
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x60(%rax), %esi
callq 0x20ee0
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x68(%rax), %esi
callq 0x20ee0
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
callq 0x45d0
subl $0x5, %eax
jne 0x32107
jmp 0x320a4
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
callq 0x321a0
movw %ax, -0x3e(%rbp)
movq -0x28(%rbp), %rdi
callq 0x321a0
movw %ax, -0x3c(%rbp)
movq -0x30(%rbp), %rdi
callq 0x321a0
movw %ax, -0x3a(%rbp)
movq -0x38(%rbp), %rdi
callq 0x321a0
movq -0x48(%rbp), %rdi
movw -0x3e(%rbp), %dx
movw -0x3c(%rbp), %cx
movw -0x3a(%rbp), %r8w
movl $0x72, %esi
movzwl %dx, %edx
movzwl %cx, %ecx
movzwl %r8w, %r8d
movzwl %ax, %r9d
callq 0x32e90
jmp 0x3213d
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x4760
movq -0x50(%rbp), %rdi
movq %rax, %r8
leaq 0xddf5(%rip), %rsi      # 0x3ff1f
movl $0x119c, %edx           # imm = 0x119C
leaq 0xe652(%rip), %rcx      # 0x40788
movb $0x0, %al
callq 0x18220
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_vm.c
// Function: emit_i64
static void
emit_i64(ir_unit_t *iu, uint64_t i64)
{
  if(iu->iu_text_ptr + 8 >= iu->iu_text_alloc + iu->iu_text_alloc_memsize)
    parser_error(iu, "Function too big");
  *(uint64_t *)iu->iu_text_ptr = i64;
  iu->iu_text_ptr += 8;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x440(%rax), %rax
addq $0x8, %rax
movq -0x8(%rbp), %rcx
movq 0x438(%rcx), %rcx
movq -0x8(%rbp), %rdx
addq 0x448(%rdx), %rcx
cmpq %rcx, %rax
jb 0x32298
movq -0x8(%rbp), %rdi
leaq 0xdc9a(%rip), %rsi      # 0x3ff1f
movl $0x957, %edx            # imm = 0x957
leaq 0xdcd0(%rip), %rcx      # 0x3ff61
movb $0x0, %al
callq 0x18220
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x440(%rax), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x440(%rax), %rcx
addq $0x8, %rcx
movq %rcx, 0x440(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_value.c
// Function: value_get_const64
static uint64_t __attribute__((unused))
value_get_const64(ir_unit_t *iu, const ir_value_t *iv)
{
  assert(iv->iv_class == IR_VC_CONSTANT);

  ir_type_t *it = type_get(iu, iv->iv_type);
  switch(it->it_code) {
  case IR_TYPE_INT1:
    return !!iv->iv_u32;
  case IR_TYPE_INT8:
  case IR_TYPE_INT16:
  case IR_TYPE_INT32:
  case IR_TYPE_POINTER:
    return iv->iv_u32;
  case IR_TYPE_INTx:
  case IR_TYPE_INT64:
  case IR_TYPE_DOUBLE:
    return iv->iv_u64;
  default:
    parser_error(iu, "Unable to get_constant for type %s",
                 type_str(iu, it));
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x3, (%rax)
jne 0x322eb
jmp 0x3230a
leaq 0xdd99(%rip), %rdi      # 0x4008b
leaq 0xc46b(%rip), %rsi      # 0x3e764
movl $0x207, %edx            # imm = 0x207
leaq 0xdda5(%rip), %rcx      # 0x400aa
callq 0x31c0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x24(%rax), %esi
callq 0x1ee20
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x24(%rbp)
subl $0x2, %eax
je 0x3235c
jmp 0x3232e
movl -0x24(%rbp), %eax
addl $-0x3, %eax
subl $0x3, %eax
jb 0x32378
jmp 0x3233b
movl -0x24(%rbp), %eax
addl $-0x6, %eax
subl $0x2, %eax
jb 0x32385
jmp 0x32348
movl -0x24(%rbp), %eax
subl $0x9, %eax
je 0x32385
jmp 0x32352
movl -0x24(%rbp), %eax
subl $0xb, %eax
je 0x32378
jmp 0x32393
movq -0x18(%rbp), %rax
cmpl $0x0, 0x30(%rax)
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
movq %rax, -0x8(%rbp)
jmp 0x323c9
movq -0x18(%rbp), %rax
movl 0x30(%rax), %eax
movq %rax, -0x8(%rbp)
jmp 0x323c9
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x323c9
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x4760
movq -0x30(%rbp), %rdi
movq %rax, %r8
leaq 0xc3ae(%rip), %rsi      # 0x3e764
movl $0x218, %edx            # imm = 0x218
leaq 0xdd24(%rip), %rcx      # 0x400e6
movb $0x0, %al
callq 0x18220
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_vm.c
// Function: emit_op3
static void
emit_op3(ir_unit_t *iu, vm_op_t op,
         uint16_t a1, uint16_t a2, uint16_t a3)
{
  emit_i16(iu, vm_resolve(op));
  emit_i16(iu, a1);
  emit_i16(iu, a2);
  emit_i16(iu, a3);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %r8w, %ax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movw %dx, -0xe(%rbp)
movw %cx, -0x10(%rbp)
movw %ax, -0x12(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %eax
movzwl %ax, %edi
callq 0x19040
movq -0x20(%rbp), %rdi
movzwl %ax, %esi
callq 0x2bae0
movq -0x8(%rbp), %rdi
movzwl -0xe(%rbp), %esi
callq 0x2bae0
movq -0x8(%rbp), %rdi
movzwl -0x10(%rbp), %esi
callq 0x2bae0
movq -0x8(%rbp), %rdi
movzwl -0x12(%rbp), %esi
callq 0x2bae0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_vm.c
// Function: emit_i8
static void
emit_i8(ir_unit_t *iu, uint8_t i8)
{
  if(iu->iu_text_ptr + 2 >= iu->iu_text_alloc + iu->iu_text_alloc_memsize)
    parser_error(iu, "Function too big");
  *(uint8_t *)iu->iu_text_ptr = i8;
  iu->iu_text_ptr += 2; // We always align to 16 bits
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq 0x440(%rax), %rax
addq $0x2, %rax
movq -0x8(%rbp), %rcx
movq 0x438(%rcx), %rcx
movq -0x8(%rbp), %rdx
addq 0x448(%rdx), %rcx
cmpq %rcx, %rax
jb 0x3255a
movq -0x8(%rbp), %rdi
leaq 0xd9d8(%rip), %rsi      # 0x3ff1f
movl $0x93f, %edx            # imm = 0x93F
leaq 0xda0e(%rip), %rcx      # 0x3ff61
movb $0x0, %al
callq 0x18220
movb -0x9(%rbp), %cl
movq -0x8(%rbp), %rax
movq 0x440(%rax), %rax
movb %cl, (%rax)
movq -0x8(%rbp), %rax
movq 0x440(%rax), %rcx
addq $0x2, %rcx
movq %rcx, 0x440(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_instr.c
// Function: swap_pred
static int
swap_pred(int pred)
{
  switch(pred) {
  default:
    abort();
  case ICMP_EQ: case ICMP_NE:
    return pred;
  case ICMP_SGT: return ICMP_SLT;
    case ICMP_SLT: return ICMP_SGT;
    case ICMP_SGE: return ICMP_SLE;
    case ICMP_SLE: return ICMP_SGE;
    case ICMP_UGT: return ICMP_ULT;
    case ICMP_ULT: return ICMP_UGT;
    case ICMP_UGE: return ICMP_ULE;
    case ICMP_ULE: return ICMP_UGE;
    case FCMP_FALSE: case FCMP_TRUE:
    case FCMP_OEQ: case FCMP_ONE:
    case FCMP_UEQ: case FCMP_UNE:
    case FCMP_ORD: case FCMP_UNO:
      return pred;
    case FCMP_OGT: return FCMP_OLT;
    case FCMP_OLT: return FCMP_OGT;
    case FCMP_OGE: return FCMP_OLE;
    case FCMP_OLE: return FCMP_OGE;
    case FCMP_UGT: return FCMP_ULT;
    case FCMP_ULT: return FCMP_UGT;
    case FCMP_UGE: return FCMP_ULE;
    case FCMP_ULE: return FCMP_UGE;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
movq %rax, -0x10(%rbp)
subq $0x29, %rax
ja 0x32dcc
movq -0x10(%rbp), %rax
leaq 0xae05(%rip), %rcx      # 0x3dbc8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
callq 0x3050
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x32e78
movl $0x28, -0x4(%rbp)
jmp 0x32e78
movl $0x26, -0x4(%rbp)
jmp 0x32e78
movl $0x29, -0x4(%rbp)
jmp 0x32e78
movl $0x27, -0x4(%rbp)
jmp 0x32e78
movl $0x24, -0x4(%rbp)
jmp 0x32e78
movl $0x22, -0x4(%rbp)
jmp 0x32e78
movl $0x25, -0x4(%rbp)
jmp 0x32e78
movl $0x23, -0x4(%rbp)
jmp 0x32e78
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x32e78
movl $0x4, -0x4(%rbp)
jmp 0x32e78
movl $0x2, -0x4(%rbp)
jmp 0x32e78
movl $0x5, -0x4(%rbp)
jmp 0x32e78
movl $0x3, -0x4(%rbp)
jmp 0x32e78
movl $0xc, -0x4(%rbp)
jmp 0x32e78
movl $0xa, -0x4(%rbp)
jmp 0x32e78
movl $0xd, -0x4(%rbp)
jmp 0x32e78
movl $0xb, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cogbee[P]vmir-latest/src/vmir_vm.c
// Function: emit_op4
static void
emit_op4(ir_unit_t *iu, vm_op_t op,
         uint16_t a1, uint16_t a2, uint16_t a3, uint16_t a4)
{
  emit_i16(iu, vm_resolve(op));
  emit_i16(iu, a1);
  emit_i16(iu, a2);
  emit_i16(iu, a3);
  emit_i16(iu, a4);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %r8d, -0x30(%rbp)
movl %ecx, %eax
movl -0x30(%rbp), %ecx
movl %eax, -0x2c(%rbp)
movl %edx, %eax
movl -0x2c(%rbp), %edx
movl %eax, -0x28(%rbp)
movl %esi, %eax
movl -0x28(%rbp), %esi
movl %eax, -0x24(%rbp)
movq %rdi, %r8
movl -0x24(%rbp), %edi
movw %r9w, %ax
movq %r8, -0x8(%rbp)
movl %edi, -0xc(%rbp)
movw %si, -0xe(%rbp)
movw %dx, -0x10(%rbp)
movw %cx, -0x12(%rbp)
movw %ax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %eax
movzwl %ax, %edi
callq 0x19040
movq -0x20(%rbp), %rdi
movzwl %ax, %esi
callq 0x2bae0
movq -0x8(%rbp), %rdi
movzwl -0xe(%rbp), %esi
callq 0x2bae0
movq -0x8(%rbp), %rdi
movzwl -0x10(%rbp), %esi
callq 0x2bae0
movq -0x8(%rbp), %rdi
movzwl -0x12(%rbp), %esi
callq 0x2bae0
movq -0x8(%rbp), %rdi
movzwl -0x14(%rbp), %esi
callq 0x2bae0
addq $0x30, %rsp
popq %rbp
retq
nop