LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/luooofan[P]hblzbd_compiler/src/ir_struct.cpp
// Function: IRBasicBlock::IsByDom(IRBasicBlock*)
bool IRBasicBlock::IsByDom(IRBasicBlock* bb) {
  auto n = this;
  while (nullptr != n) {
    if (bb == n) return true;
    n = n->idom_;
  }
  return false;
}

// Assembly:
cmpq %rsi, %rdi
je 0x1fcfb
testq %rdi, %rdi
je 0x1fcfb
movq 0x250(%rdi), %rdi
jmp 0x1fce8
testq %rdi, %rdi
setne %al
retq
// File: /workspace/github_cpp_makefile_star2_O2/luooofan[P]hblzbd_compiler/src/../include/Pass/pass_manager.h
// Function: void PassManager::AddPass<SimplifyCFG>(bool)
void AddPass(bool emit = false) {
    try {
      Pass* pass = new PassTy(m_);
      pass->SetName(typeid(PassTy).name());
      pass->SetEmit(emit);
      passes_.push_back(pass);
    } catch (...) {
      std::cerr << "ERROR class type:" << typeid(PassTy).name() << " be passed to AddPass();" << std::endl;
      exit(255);
    }
  }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movl %esi, %ebp
movq %rdi, %rbx
pushq $0x38
popq %rdi
callq 0x8250
movq %rax, %r14
movq 0x18(%rbx), %rax
movq %rax, 0x8(%r14)
leaq 0x20(%r14), %rax
movq %rax, 0x10(%r14)
andq $0x0, 0x18(%r14)
xorl %eax, %eax
movb %al, 0x20(%r14)
movb %al, 0x30(%r14)
leaq 0x6017c(%rip), %rax     # 0x80d00
addq $0x10, %rax
movq %rax, (%r14)
movq %r14, 0x8(%rsp)
leaq 0x60181(%rip), %rax     # 0x80d18
movq 0x8(%rax), %rax
xorl %esi, %esi
cmpb $0x2a, (%rax)
sete %sil
addq %rax, %rsi
leaq 0x10(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xa292
movq %r14, %rdi
addq $0x10, %rdi
leaq 0x10(%rsp), %rsi
callq 0x81a0
leaq 0x10(%rsp), %rdi
callq 0x8578
movb %bpl, 0x30(%r14)
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x222bc
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x8578
jmp 0x20bff
jmp 0x20bfc
movq %rax, %rbx
movq %rbx, %rdi
callq 0x8130
movq 0x603da(%rip), %rdi     # 0x80fe8
leaq 0x367d2(%rip), %rsi     # 0x573e7
callq 0x8240
leaq 0x600f7(%rip), %rcx     # 0x80d18
movq 0x8(%rcx), %rcx
xorl %esi, %esi
cmpb $0x2a, (%rcx)
sete %sil
addq %rcx, %rsi
movq %rax, %rdi
callq 0x8240
leaq 0x367b9(%rip), %rsi     # 0x573f9
movq %rax, %rdi
callq 0x8240
movq %rax, %rdi
callq 0x8170
movl $0xff, %edi
callq 0x8300
movq %rax, %rbx
callq 0x8480
movq %rbx, %rdi
callq 0x84d0
movq %rax, %rdi
callq 0xa80e
// File: /workspace/github_cpp_makefile_star2_O2/luooofan[P]hblzbd_compiler/src/../include/Pass/pass_manager.h
// Function: PassManager::Run(bool, std::ostream&)
void Run(bool emit = false, std::ostream& out = std::cout) {
    int i = 1;
    for (auto pass : this->passes_) {
#ifdef DEBUG_PASSES_PROCESS
      std::cout << ">>>>>>>>>>>> Start pass " << pass->GetName() << " <<<<<<<<<<<<" << std::endl;
#endif
      pass->Run();

      if (emit || pass->IsEmit()) {
        out << ">>>>>>>>>>>> After pass " << pass->GetName() << " <<<<<<<<<<<<" << std::endl;
        (*m_)->EmitCode(out);
      }
    }
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movl %esi, 0x4(%rsp)
movq (%rdi), %rbp
movq %rdi, 0x8(%rsp)
movq 0x8(%rdi), %rax
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %r13
cmpq 0x10(%rsp), %rbp
je 0x21eca
movq (%rbp), %r14
movq 0x5f1a9(%rip), %rdi     # 0x80fb0
leaq 0x35599(%rip), %rsi     # 0x573a7
callq 0x8240
movq %rax, %r15
leaq 0x10(%r14), %r12
movq %r13, %rdi
movq %r12, %rsi
callq 0x8390
movq %r15, %rdi
movq %r13, %rsi
callq 0x8230
movq %rax, %rdi
leaq 0x35586(%rip), %rsi     # 0x573c0
callq 0x8240
movq %rax, %rdi
callq 0x8170
movq %r13, %rdi
callq 0x8578
movq (%r14), %rax
movq %r14, %rdi
callq *(%rax)
cmpb $0x0, 0x4(%rsp)
jne 0x21e65
cmpb $0x1, 0x30(%r14)
jne 0x21ec1
movq %rbx, %rdi
leaq 0x3555f(%rip), %rsi     # 0x573ce
callq 0x8240
movq %rax, %r14
movq %r13, %rdi
movq %r12, %rsi
callq 0x8390
movq %r14, %rdi
movq %r13, %rsi
callq 0x8230
movq %rax, %rdi
leaq 0x35529(%rip), %rsi     # 0x573c0
callq 0x8240
movq %rax, %rdi
callq 0x8170
movq %r13, %rdi
callq 0x8578
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x10(%rax)
addq $0x8, %rbp
jmp 0x21df1
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x21edb
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x8578
movq %rbx, %rdi
callq 0x84d0
// File: /workspace/github_cpp_makefile_star2_O2/luooofan[P]hblzbd_compiler/src/ssa.cpp
// Function: Value::KillUse(Value*)
void Value::KillUse(Value *val) {
  for (auto it = use_list_.begin(); it != use_list_.end();) {
    if (val == (*it)->Get()) {
      it = use_list_.erase(it);
    } else {
      ++it;
    }
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rax
addq $0x10, %r14
cmpq %r14, %rax
je 0x2678e
movq 0x10(%rax), %rcx
cmpq %rbx, (%rcx)
je 0x26781
movq (%rax), %rax
jmp 0x2676e
movq %r14, %rdi
movq %rax, %rsi
callq 0x27642
jmp 0x2676e
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/luooofan[P]hblzbd_compiler/src/ssa.cpp
// Function: Value::KillUse(SSAFunction*)
void Value::KillUse(SSAFunction *func) {
  // 删除该值在该函数中的全部使用
  for (auto it = use_list_.begin(); it != use_list_.end();) {
    auto inst = dynamic_cast<SSAInstruction *>((*it)->Get());
    if (nullptr != inst && inst->GetParent()->GetFunction() == func) {
      it = use_list_.erase(it);
    } else {
      ++it;
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %r12
addq $0x10, %r14
leaq 0x59cc2(%rip), %r15     # 0x80480
leaq 0x59c03(%rip), %r13     # 0x803c8
cmpq %r14, %r12
je 0x26808
movq 0x10(%r12), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x267f2
movq %r15, %rsi
movq %r13, %rdx
xorl %ecx, %ecx
callq 0x82c0
testq %rax, %rax
je 0x267f2
movq 0x60(%rax), %rax
cmpq %rbx, (%rax)
je 0x267f8
movq (%r12), %r12
jmp 0x267c5
movq %r14, %rdi
movq %r12, %rsi
callq 0x27642
movq %rax, %r12
jmp 0x267c5
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/luooofan[P]hblzbd_compiler/src/ssa.cpp
// Function: Value::ReplaceAllUseWith(Value*)
void Value::ReplaceAllUseWith(Value *val) {
  auto uses = GetUses();
  for (auto use : uses) {
    use->Set(val);
  }
  MyAssert(!IsUsed());
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
addq $0x10, %rbx
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x27650
movq %r15, %r12
movq (%r12), %r12
cmpq %r15, %r12
je 0x26850
movq 0x10(%r12), %rdi
movq %r14, %rsi
callq 0x2768a
jmp 0x26838
cmpq %rbx, (%rbx)
jne 0x26869
movq %rsp, %rdi
callq 0x27af8
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x5a778(%rip), %rdi     # 0x80fe8
leaq 0x2f871(%rip), %rsi     # 0x560e8
callq 0x8240
leaq 0x32bbe(%rip), %rsi     # 0x59441
movq %rax, %rdi
callq 0x8240
leaq 0x30a8e(%rip), %rsi     # 0x57320
movq %rax, %rdi
callq 0x8240
pushq $0x24
popq %rsi
movq %rax, %rdi
callq 0x84b0
movq %rax, %rdi
callq 0x8170
movl $0xff, %edi
callq 0x8300
jmp 0x268b9
movq %rax, %rbx
movq %rsp, %rdi
callq 0x27af8
movq %rbx, %rdi
callq 0x84d0
// File: /workspace/github_cpp_makefile_star2_O2/luooofan[P]hblzbd_compiler/src/ssa.cpp
// Function: BinaryOperator::ComputeConstInt(int, int)
int BinaryOperator::ComputeConstInt(int lhs, int rhs) {
  switch (op_) {
    case ADD:
      return lhs + rhs;
    case SUB:
      return lhs - rhs;
    case MUL:
      return lhs * rhs;
    case DIV:
      return lhs / rhs;
    case MOD:
      return lhs % rhs;
    default:
      MyAssert(0);
      break;
  }
  return 0;
}

// Assembly:
movl 0x68(%rdi), %eax
cmpq $0x4, %rax
ja 0x26b5f
movl %edx, %ecx
leaq 0x327bc(%rip), %rdx     # 0x592f0
movslq (%rdx,%rax,4), %rax
addq %rdx, %rax
jmpq *%rax
addl %esi, %ecx
jmp 0x26b5c
movl %esi, %eax
cltd
idivl %ecx
movl %edx, %ecx
jmp 0x26b5c
imull %esi, %ecx
jmp 0x26b5c
movl %esi, %eax
cltd
idivl %ecx
movl %eax, %ecx
jmp 0x26b5c
subl %ecx, %esi
movl %esi, %ecx
movl %ecx, %eax
retq
pushq %rax
movq 0x5a481(%rip), %rdi     # 0x80fe8
leaq 0x2f57a(%rip), %rsi     # 0x560e8
callq 0x8240
leaq 0x328c7(%rip), %rsi     # 0x59441
movq %rax, %rdi
callq 0x8240
leaq 0x30797(%rip), %rsi     # 0x57320
movq %rax, %rdi
callq 0x8240
pushq $0x61
popq %rsi
movq %rax, %rdi
callq 0x84b0
movq %rax, %rdi
callq 0x8170
movl $0xff, %edi
callq 0x8300
// File: /workspace/github_cpp_makefile_star2_O2/luooofan[P]hblzbd_compiler/src/ssa.cpp
// Function: UnaryOperator::ComputeConstInt(int)
int UnaryOperator::ComputeConstInt(int lhs) {
  switch (op_) {
    case NEG:
      return -lhs;
    case NOT:
      return !lhs;
    default:
      MyAssert(0);
      break;
  }
  return 0;
}

// Assembly:
movl 0x68(%rdi), %eax
cmpl $0x1, %eax
je 0x26bbe
testl %eax, %eax
jne 0x26bca
negl %esi
jmp 0x26bc7
xorl %eax, %eax
testl %esi, %esi
sete %al
movl %eax, %esi
movl %esi, %eax
retq
pushq %rax
movq 0x5a416(%rip), %rdi     # 0x80fe8
leaq 0x2f50f(%rip), %rsi     # 0x560e8
callq 0x8240
leaq 0x3285c(%rip), %rsi     # 0x59441
movq %rax, %rdi
callq 0x8240
leaq 0x3072c(%rip), %rsi     # 0x57320
movq %rax, %rdi
callq 0x8240
pushq $0x6e
popq %rsi
movq %rax, %rdi
callq 0x84b0
movq %rax, %rdi
callq 0x8170
movl $0xff, %edi
callq 0x8300
nop
// File: /workspace/github_cpp_makefile_star2_O2/luooofan[P]hblzbd_compiler/src/ssa.cpp
// Function: BranchInst::ComputeConstInt(int, int)
bool BranchInst::ComputeConstInt(int lhs, int rhs) {
  switch (cond_) {
    case EQ:
      return lhs == rhs;
    case NE:
      return lhs != rhs;
    case GT:
      return lhs > rhs;
    case GE:
      return lhs >= rhs;
    case LT:
      return lhs < rhs;
    case LE:
      return lhs <= rhs;
    default:
      MyAssert(0);
      return false;
  }
}

// Assembly:
movl 0x68(%rdi), %eax
decl %eax
cmpl $0x5, %eax
ja 0x26c58
leaq 0x326d9(%rip), %rcx     # 0x59304
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cmpl %edx, %esi
sete %al
retq
cmpl %edx, %esi
setl %al
retq
cmpl %edx, %esi
setg %al
retq
cmpl %edx, %esi
setge %al
retq
cmpl %edx, %esi
setne %al
retq
cmpl %edx, %esi
setle %al
retq
pushq %rax
movq 0x5a388(%rip), %rdi     # 0x80fe8
leaq 0x2f481(%rip), %rsi     # 0x560e8
callq 0x8240
leaq 0x327ce(%rip), %rsi     # 0x59441
movq %rax, %rdi
callq 0x8240
leaq 0x3069e(%rip), %rsi     # 0x57320
movq %rax, %rdi
callq 0x8240
movq %rax, %rdi
movl $0x83, %esi
callq 0x84b0
movq %rax, %rdi
callq 0x8170
movl $0xff, %edi
callq 0x8300
nop
// File: /workspace/github_cpp_makefile_star2_O2/luooofan[P]hblzbd_compiler/src/ssa.cpp
// Function: BinaryOperator::Print(std::ostream&)
void BinaryOperator::Print(std::ostream &outfile) {
  std::string op = "";
  switch (op_) {
    case ADD:
      op = "add";
      break;
    case SUB:
      op = "sub";
      break;
    case MUL:
      op = "mul";
      break;
    case DIV:
      op = "div";
      break;
    case MOD:
      op = "mod";
      break;
    default:
      break;
  }
  Value::Print(outfile);
  outfile << std::setw(INDENT) << "=" + op;
  User::Print(outfile);
  outfile << std::endl;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x2f089(%rip), %rsi     # 0x56149
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0xa292
movl 0x68(%r14), %eax
cmpq $0x5, %rax
jae 0x270f1
leaq 0x32320(%rip), %rcx     # 0x59400
movslq (%rcx,%rax,4), %rsi
addq %rcx, %rsi
leaq 0x28(%rsp), %rdi
callq 0x8530
movq %r14, %rdi
movq %rbx, %rsi
callq 0x26caa
movq (%rbx), %rax
movq -0x18(%rax), %rax
movq $0xc, 0x10(%rbx,%rax)
leaq 0x30e81(%rip), %rsi     # 0x57f94
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x1ae0c
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x8230
leaq 0x8(%rsp), %rdi
callq 0x8578
movq %r14, %rdi
movq %rbx, %rsi
callq 0x26e12
movq %rbx, %rdi
callq 0x8170
leaq 0x28(%rsp), %rdi
callq 0x8578
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x8578
jmp 0x27172
jmp 0x2716f
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x8578
movq %rbx, %rdi
callq 0x84d0
// File: /workspace/github_cpp_makefile_star2_O2/luooofan[P]hblzbd_compiler/src/ssa.cpp
// Function: UnaryOperator::Print(std::ostream&)
void UnaryOperator::Print(std::ostream &outfile) {
  std::string op = "";
  switch (op_) {
    case NEG:
      op = "neg";
      break;
    case NOT:
      op = "not";
      break;
    default:
      break;
  }
  Value::Print(outfile);
  outfile << std::setw(INDENT) << "=" + op;
  User::Print(outfile);
  outfile << std::endl;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x2efb1(%rip), %rsi     # 0x56149
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0xa292
movl 0x68(%r14), %eax
cmpl $0x1, %eax
je 0x271bd
testl %eax, %eax
jne 0x271ce
leaq 0x3002d(%rip), %rsi     # 0x571e8
jmp 0x271c4
leaq 0x30028(%rip), %rsi     # 0x571ec
leaq 0x28(%rsp), %rdi
callq 0x8530
movq %r14, %rdi
movq %rbx, %rsi
callq 0x26caa
movq (%rbx), %rax
movq -0x18(%rax), %rax
movq $0xc, 0x10(%rbx,%rax)
leaq 0x30da4(%rip), %rsi     # 0x57f94
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x1ae0c
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x8230
leaq 0x8(%rsp), %rdi
callq 0x8578
movq %r14, %rdi
movq %rbx, %rsi
callq 0x26e12
movq %rbx, %rdi
callq 0x8170
leaq 0x28(%rsp), %rdi
callq 0x8578
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x8578
jmp 0x2724f
jmp 0x2724c
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x8578
movq %rbx, %rdi
callq 0x84d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/luooofan[P]hblzbd_compiler/src/ssa.cpp
// Function: BranchInst::Print(std::ostream&)
void BranchInst::Print(std::ostream &outfile) {
  std::string cond = "b";
  switch (cond_) {
    case AL:
      cond += "";
      break;
    case EQ:
      cond += "eq";
      break;
    case NE:
      cond += "ne";
      break;
    case GT:
      cond += "gt";
      break;
    case GE:
      cond += "ge";
      break;
    case LT:
      cond += "lt";
      break;
    case LE:
      cond += "le";
      break;
    default:
      break;
  }
  outfile << std::setw(INDENT) << cond;
  User::Print(outfile);
  outfile << std::endl;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x325b9(%rip), %rsi     # 0x5982f
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xa292
movl 0x68(%r14), %eax
cmpq $0x7, %rax
jae 0x272a7
leaq 0x3217e(%rip), %rcx     # 0x59414
movslq (%rcx,%rax,4), %rsi
addq %rcx, %rsi
leaq 0x8(%rsp), %rdi
callq 0x8520
movq (%rbx), %rax
movq -0x18(%rax), %rax
movq $0xc, 0x10(%rbx,%rax)
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x8230
movq %r14, %rdi
movq %rbx, %rsi
callq 0x26e12
movq %rbx, %rdi
callq 0x8170
leaq 0x8(%rsp), %rdi
callq 0x8578
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x8578
movq %rbx, %rdi
callq 0x84d0
// File: /workspace/github_cpp_makefile_star2_O2/luooofan[P]hblzbd_compiler/src/ssa.cpp
// Function: CallInst::Print(std::ostream&)
void CallInst::Print(std::ostream &outfile) {
  std::string prefix = "";
  if (!GetType()->IsVoid()) {
    Value::Print(outfile);
    prefix = "=";
  }
  prefix += "call";
  outfile << std::setw(INDENT) << prefix;
  User::Print(outfile);
  outfile << std::endl;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x2ee37(%rip), %rsi     # 0x56149
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xa292
movq 0x8(%r14), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
testb %al, %al
jne 0x2734b
movq %r14, %rdi
movq %rbx, %rsi
callq 0x26caa
leaq 0x30c53(%rip), %rsi     # 0x57f94
leaq 0x8(%rsp), %rdi
callq 0x8530
leaq 0x2fecf(%rip), %rsi     # 0x57221
leaq 0x8(%rsp), %rdi
callq 0x8520
movq (%rbx), %rax
movq -0x18(%rax), %rax
movq $0xc, 0x10(%rbx,%rax)
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x8230
movq %r14, %rdi
movq %rbx, %rsi
callq 0x26e12
movq %rbx, %rdi
callq 0x8170
leaq 0x8(%rsp), %rdi
callq 0x8578
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x8578
movq %rbx, %rdi
callq 0x84d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/luooofan[P]hblzbd_compiler/src/ssa.cpp
// Function: AllocaInst::Print(std::ostream&)
void AllocaInst::Print(std::ostream &outfile) {
  outfile << std::setw(INDENT) << "alloca";
  // outfile << (dynamic_cast<ArrayType *>(GetType()))->num_elements_;
  User::Print(outfile);
  outfile << std::endl;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rax
movq -0x18(%rax), %rax
movq $0xc, 0x10(%rsi,%rax)
leaq 0x2fe11(%rip), %rsi     # 0x5722a
movq %rbx, %rdi
callq 0x8240
movq %r14, %rdi
movq %rbx, %rsi
callq 0x26e12
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x8170
nop
// File: /workspace/github_cpp_makefile_star2_O2/luooofan[P]hblzbd_compiler/src/ssa.cpp
// Function: LoadInst::Print(std::ostream&)
void LoadInst::Print(std::ostream &outfile) {
  Value::Print(outfile);
  outfile << std::setw(INDENT) << "=load";
  User::Print(outfile);
  outfile << std::endl;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x26caa
movq (%rbx), %rax
movq -0x18(%rax), %rax
movq $0xc, 0x10(%rbx,%rax)
leaq 0x3200e(%rip), %rsi     # 0x59470
movq %rbx, %rdi
callq 0x8240
movq %r14, %rdi
movq %rbx, %rsi
callq 0x26e12
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x8170
// File: /workspace/github_cpp_makefile_star2_O2/luooofan[P]hblzbd_compiler/src/ssa.cpp
// Function: MovInst::Print(std::ostream&)
void MovInst::Print(std::ostream &outfile) {
  Value::Print(outfile);
  outfile << std::setw(INDENT) << "=mov";
  User::Print(outfile);
  outfile << std::endl;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x26caa
movq (%rbx), %rax
movq -0x18(%rax), %rax
movq $0xc, 0x10(%rbx,%rax)
leaq 0x31f8e(%rip), %rsi     # 0x5947c
movq %rbx, %rdi
callq 0x8240
movq %r14, %rdi
movq %rbx, %rsi
callq 0x26e12
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x8170
// File: /workspace/github_cpp_makefile_star2_O2/luooofan[P]hblzbd_compiler/src/ssa.cpp
// Function: PhiInst::Print(std::ostream&)
void PhiInst::Print(std::ostream &outfile) {
  Value::Print(outfile);
  outfile << std::setw(INDENT) << "=phi";
  User::Print(outfile);
  outfile << std::endl;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x26caa
movq (%rbx), %rax
movq -0x18(%rax), %rax
movq $0xc, 0x10(%rbx,%rax)
leaq 0x31f4b(%rip), %rsi     # 0x59481
movq %rbx, %rdi
callq 0x8240
movq %r14, %rdi
movq %rbx, %rsi
callq 0x26e12
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x8170
// File: /workspace/github_cpp_makefile_star2_O2/luooofan[P]hblzbd_compiler/src/ssa.cpp
// Function: Value::~Value()
Value::~Value() {
  auto uses = GetUses();  // necessary. can't use reference
  for (auto use : uses) {
    use->Set(nullptr);  // necessary. when destruct a use instance, must ensure that its value_ is a valid pointer.
  }
  // 并没有删除使用它的那个user的operand 只是让operand的use中的value变为nullptr了
  MyAssert(!IsUsed());
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
leaq 0x58e83(%rip), %rax     # 0x803f0
movq %rax, (%rdi)
leaq 0x10(%rdi), %rbx
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x27650
movq %r15, %r12
movq (%r12), %r12
cmpq %r15, %r12
je 0x2759c
movq 0x10(%r12), %rdi
xorl %esi, %esi
callq 0x2768a
jmp 0x27585
cmpq %rbx, (%rbx)
jne 0x275c9
movq %rsp, %rdi
callq 0x27af8
addq $0x28, %r14
movq %r14, %rdi
callq 0x8578
movq %rbx, %rdi
callq 0x27af8
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x59a18(%rip), %rdi     # 0x80fe8
leaq 0x2eb11(%rip), %rsi     # 0x560e8
callq 0x8240
leaq 0x31e5e(%rip), %rsi     # 0x59441
movq %rax, %rdi
callq 0x8240
leaq 0x2fd2e(%rip), %rsi     # 0x57320
movq %rax, %rdi
callq 0x8240
pushq $0x2c
popq %rsi
movq %rax, %rdi
callq 0x84b0
movq %rax, %rdi
callq 0x8170
movl $0xff, %edi
callq 0x8300
jmp 0x27619
movq %rax, %rdi
callq 0xa80e
nop
// File: /workspace/github_cpp_makefile_star2_O2/luooofan[P]hblzbd_compiler/src/../include/ssa.h
// Function: Use::operator=(Use&&)
Use& operator=(Use&& u) {
    user_ = u.GetUser();
    Set(u.Get());
    u.Set(nullptr);
    return *this;
  }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %rax
movq %rax, 0x8(%rdi)
movq (%rsi), %rsi
callq 0x2768a
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2768a
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/luooofan[P]hblzbd_compiler/src/ssa_struct.cpp
// Function: SSAFunction::RemoveBasicBlock(SSABasicBlock*)
void SSAFunction::RemoveBasicBlock(SSABasicBlock* bb) {
  bb_list_.remove(bb);
  // TODO: manage memory
  for (auto pred : bb->GetPredBB()) {
    pred->RemoveSuccBB(bb);
  }
  for (auto succ : bb->GetSuccBB()) {
    succ->RemovePredBB(bb);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsp, %rbx
movq %rsi, (%rbx)
addq $0x30, %rdi
movq %rbx, %rsi
callq 0x28960
movq (%rbx), %rbx
addq $0x40, %rbx
movq %rbx, %r14
movq (%r14), %r14
cmpq %rbx, %r14
je 0x28043
movq 0x10(%r14), %rdi
movq (%rsp), %rsi
callq 0x289be
jmp 0x2802c
movq (%rsp), %rbx
addq $0x58, %rbx
movq %rbx, %r14
movq (%r14), %r14
cmpq %rbx, %r14
je 0x28065
movq 0x10(%r14), %rdi
movq (%rsp), %rsi
callq 0x289d4
jmp 0x2804e
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/luooofan[P]hblzbd_compiler/src/ssa_struct.cpp
// Function: SSAFunction::MaintainCallFunc()
void SSAFunction::MaintainCallFunc() {
  call_func_list_.clear();
  for (auto bb : bb_list_) {
    for (auto inst : bb->GetInstList()) {
      if (auto call_inst = dynamic_cast<CallInst*>(inst)) {
        auto func_val = dynamic_cast<FunctionValue*>(call_inst->GetOperand(0));
        MyAssert(nullptr != func_val);
        call_func_list_.insert(func_val->GetFunction());
      }
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r13
leaq 0x48(%rdi), %r14
movq %r14, %rdi
callq 0x28b9a
addq $0x30, %r13
leaq 0x58332(%rip), %r15     # 0x803c8
leaq 0x58623(%rip), %r12     # 0x806c0
movq %r13, 0x8(%rsp)
movq (%r13), %r13
cmpq 0x8(%rsp), %r13
je 0x28120
movq 0x10(%r13), %rbx
addq $0x28, %rbx
movq %rbx, %rbp
movq (%rbp), %rbp
cmpq %rbx, %rbp
je 0x280a2
movq 0x10(%rbp), %rdi
testq %rdi, %rdi
je 0x280b8
movq %r15, %rsi
movq %r12, %rdx
xorl %ecx, %ecx
callq 0x82c0
testq %rax, %rax
je 0x280b8
movq %rax, %rdi
xorl %esi, %esi
callq 0x269a6
testq %rax, %rax
je 0x2812f
movq %rax, %rdi
leaq 0x5838b(%rip), %rsi     # 0x80480
leaq 0x583dc(%rip), %rdx     # 0x804d8
xorl %ecx, %ecx
callq 0x82c0
testq %rax, %rax
je 0x2812f
movq 0x60(%rax), %rax
movq %rax, 0x10(%rsp)
movq %r14, %rdi
leaq 0x10(%rsp), %rsi
callq 0x2937e
jmp 0x280b8
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x58eb2(%rip), %rdi     # 0x80fe8
leaq 0x2dfab(%rip), %rsi     # 0x560e8
callq 0x8240
leaq 0x31343(%rip), %rsi     # 0x5948c
movq %rax, %rdi
callq 0x8240
leaq 0x2f1c8(%rip), %rsi     # 0x57320
movq %rax, %rdi
callq 0x8240
pushq $0x38
popq %rsi
movq %rax, %rdi
callq 0x84b0
movq %rax, %rdi
callq 0x8170
movl $0xff, %edi
callq 0x8300
nop
// File: /workspace/github_cpp_makefile_star2_O2/luooofan[P]hblzbd_compiler/src/ssa_struct.cpp
// Function: SSAFunction::~SSAFunction()
SSAFunction::~SSAFunction() {
  // m_ = nullptr;
  // delete value_; // FIXME: should be delete and remove all use
  for (auto bb : bb_list_) delete bb;
  // bb_list_.clear();
  // call_func_list_.clear();
  // used_glob_var_list_.clear();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x30(%rdi), %r14
movq %r14, %r12
movq (%r12), %r12
cmpq %r14, %r12
je 0x283d6
movq 0x10(%r12), %r15
testq %r15, %r15
je 0x283c7
movq %r15, %rdi
callq 0x28532
movl $0xd0, %esi
movq %r15, %rdi
callq 0x8260
jmp 0x283ac
leaq 0x80(%rbx), %rdi
callq 0x28ad6
leaq 0x48(%rbx), %rdi
callq 0x28b7e
movq %r14, %rdi
callq 0x28c26
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x8578
// File: /workspace/github_cpp_makefile_star2_O2/luooofan[P]hblzbd_compiler/src/ssa_struct.cpp
// Function: SSABasicBlock::GetNextBB()
SSABasicBlock* SSABasicBlock::GetNextBB() {
  // maybe return nullptr
  auto& bb_list = func_->GetBBList();
  auto it = ++std::find(bb_list.begin(), bb_list.end(), this);
  if (it == bb_list.end())
    return nullptr;
  else
    return *it;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq (%rdi), %rbx
movq 0x30(%rbx), %rax
addq $0x30, %rbx
leaq 0x8(%rsp), %rdx
movq %rdi, (%rdx)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x29ae6
movq (%rax), %rax
cmpq %rbx, %rax
je 0x28437
movq 0x10(%rax), %rax
jmp 0x28439
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/luooofan[P]hblzbd_compiler/src/ssa_struct.cpp
// Function: SSABasicBlock::GetDomSet()
std::unordered_set<SSABasicBlock*> SSABasicBlock::GetDomSet() {
  // all ancestor in dom tree, including itself
  std::unordered_set<SSABasicBlock*> res;
  auto temp = this;
  while (nullptr != temp) {
    res.insert(temp);
    temp = temp->GetIDom();
  }
  return res;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x30(%rdi), %rax
movq %rax, (%rdi)
movq $0x1, 0x8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movl $0x3f800000, 0x20(%rdi) # imm = 0x3F800000
movups %xmm0, 0x28(%rdi)
movq %rsp, %r14
movq %rsi, (%rsp)
testq %rsi, %rsi
je 0x28513
movq %rbx, %rdi
movq %r14, %rsi
callq 0x28e4c
movq (%rsp), %rax
movq 0x70(%rax), %rsi
jmp 0x284f5
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x28c50
movq %r14, %rdi
callq 0x84d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/luooofan[P]hblzbd_compiler/src/ssa_struct.cpp
// Function: SSABasicBlock::~SSABasicBlock()
SSABasicBlock::~SSABasicBlock() {
  // func_ = nullptr;
  // delete value_; // FIXME: should be delete and remove all use
  for (auto inst : inst_list_) {
    delete inst;
    // std::cout << "ok\n";
  }
  // inst_list_.clear();
  // pred_.clear();
  // succ_.clear();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x28(%rdi), %r14
movq %r14, %r15
movq (%r15), %r15
cmpq %r14, %r15
je 0x2855a
movq 0x10(%r15), %rdi
testq %rdi, %rdi
je 0x28541
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x28541
leaq 0x90(%rbx), %rdi
callq 0x28c50
leaq 0x78(%rbx), %rdi
callq 0x28d22
leaq 0x58(%rbx), %rdi
callq 0x28c26
leaq 0x40(%rbx), %rdi
callq 0x28c26
movq %r14, %rdi
callq 0x28cf8
addq $0x8, %rbx
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x8578
// File: /workspace/github_cpp_makefile_star2_O2/luooofan[P]hblzbd_compiler/src/ssa_struct.cpp
// Function: SSAModule::EmitCode(std::ostream&)
void SSAModule::EmitCode(std::ostream& out) {
  for (auto glob : glob_var_list_) {
    glob->Print(out);
  }
  out << std::endl;
  // for (auto func : builtin_func_list_) {
  //   func->EmitCode(out);
  //   out << std::endl;
  // }
  for (auto func : func_list_) {
    func->EmitCode(out);
    out << std::endl;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x28(%rdi), %r15
movq %r15, %r12
movq (%r12), %r12
cmpq %r15, %r12
je 0x285c8
movq 0x10(%r12), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x10(%rax)
jmp 0x285af
movq %rbx, %rdi
callq 0x8170
addq $0x40, %r14
movq %r14, %r15
movq (%r15), %r15
cmpq %r14, %r15
je 0x285f5
movq 0x10(%r15), %rdi
movq %rbx, %rsi
callq 0x28602
movq %rbx, %rdi
callq 0x8170
jmp 0x285d7
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/luooofan[P]hblzbd_compiler/src/ssa_struct.cpp
// Function: SSABasicBlock::EmitCode(std::ostream&)
void SSABasicBlock::EmitCode(std::ostream& out) {
  out << label_ << ":" << std::endl;
  out << "; BB Begin:" << std::endl;
  for (auto inst : inst_list_) {
    inst->Print(out);
  }
  out << "; BB End." << std::endl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rdi), %rsi
movq %rbx, %rdi
callq 0x8230
leaq 0x2eb02(%rip), %rsi     # 0x57320
movq %rax, %rdi
callq 0x8240
movq %rax, %rdi
callq 0x8170
leaq 0x30cc7(%rip), %rsi     # 0x594fc
movq %rbx, %rdi
callq 0x8240
movq %rax, %rdi
callq 0x8170
addq $0x28, %r14
movq %r14, %r15
movq (%r15), %r15
cmpq %r14, %r15
je 0x28863
movq 0x10(%r15), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x10(%rax)
jmp 0x2884c
leaq 0x30c9e(%rip), %rsi     # 0x59508
movq %rbx, %rdi
callq 0x8240
movq %rax, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x8170
nop
// File: /workspace/github_cpp_makefile_star2_O2/luooofan[P]hblzbd_compiler/src/Pass/allocate_register.cpp
// Function: RegAlloc::ValidAdjacentSet(int, std::unordered_map<int, std::unordered_set<int, std::hash<int>, std::equal_to<int>, std::allocator<int>>, std::hash<int>, std::equal_to<int>, std::allocator<std::pair<int const, std::unordered_set<int, std::hash<int>, std::equal_to<int>, std::allocator<int>>>>>&, std::vector<int, std::allocator<int>>&, std::unordered_set<int, std::hash<int>, std::equal_to<int>, std::allocator<int>>&)
RegAlloc::WorkList RegAlloc::ValidAdjacentSet(RegId reg, AdjList &adj_list, std::vector<RegId> &select_stack,
                                              WorkList &coalesced_nodes) {
  WorkList valid_adjacent = adj_list[reg];
  // outfile << valid_adjacent.size() << std::endl;
  for (auto iter = valid_adjacent.begin(); iter != valid_adjacent.end();) {
    // outfile << *iter << std::endl;
    // NOTE: erase
    if (std::find(select_stack.begin(), select_stack.end(), *iter) == select_stack.end() &&
        coalesced_nodes.find(*iter) == coalesced_nodes.end()) {
      ++iter;
    } else {
      iter = valid_adjacent.erase(iter);
    }
    // dbg_print_worklist(valid_adjacent, outfile);
  }
  return valid_adjacent;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %r9, %r14
movq %r8, %r15
movq %rdi, %rbx
leaq 0xc(%rsp), %rsi
movl %edx, (%rsi)
movq %rcx, %rdi
callq 0x2de58
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2bda8
movq 0x10(%rbx), %r12
testq %r12, %r12
je 0x29cc9
movq (%r15), %rdi
movq 0x8(%r15), %rsi
leaq 0x8(%r12), %r13
movq %r13, %rdx
callq 0x2e1ca
cmpq 0x8(%r15), %rax
jne 0x29cb3
movq %r14, %rdi
movq %r13, %rsi
callq 0x2e252
testq %rax, %rax
je 0x29cc3
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2e270
movq %rax, %r12
jmp 0x29c84
movq (%r12), %r12
jmp 0x29c84
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x29cde
jmp 0x29cde
movq %rax, %r14
movq %rbx, %rdi
callq 0x2bffe
movq %r14, %rdi
callq 0x84d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/luooofan[P]hblzbd_compiler/src/Pass/arm_liveness_analysis.cpp
// Function: ArmLivenessAnalysis::Run()
void ArmLivenessAnalysis::Run() {
  auto m = dynamic_cast<ArmModule *>(*(this->m_));
  MyAssert(nullptr != m);
  for (auto func : m->func_list_) {
    this->Run4Func(func);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x8(%rdi), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x2f101
leaq 0x5057d(%rip), %rsi     # 0x7f648
leaq 0x5055e(%rip), %rdx     # 0x7f630
xorl %ecx, %ecx
callq 0x82c0
testq %rax, %rax
je 0x2f101
movq 0x28(%rax), %rbx
movq 0x30(%rax), %r14
cmpq %r14, %rbx
je 0x2f0f9
movq (%rbx), %rdi
callq 0x2ee58
addq $0x8, %rbx
jmp 0x2f0e6
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x51ee0(%rip), %rdi     # 0x80fe8
leaq 0x26fd9(%rip), %rsi     # 0x560e8
callq 0x8240
leaq 0x2a43c(%rip), %rsi     # 0x59557
movq %rax, %rdi
callq 0x8240
leaq 0x281f6(%rip), %rsi     # 0x57320
movq %rax, %rdi
callq 0x8240
movq %rax, %rdi
movl $0xd5, %esi
callq 0x84b0
movq %rax, %rdi
callq 0x8170
movl $0xff, %edi
callq 0x8300
nop
// File: /workspace/github_cpp_makefile_star2_O2/luooofan[P]hblzbd_compiler/src/Pass/arm_offset_fixup.cpp
// Function: SPOffsetFixup::Run()
void SPOffsetFixup::Run() {
  auto m = dynamic_cast<ArmModule *>(*(this->m_));
  MyAssert(nullptr != m);
  for (auto func : m->func_list_) {
    Fixup4Func(func);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x8(%rdi), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x2f925
leaq 0x4fd59(%rip), %rsi     # 0x7f648
leaq 0x4fd3a(%rip), %rdx     # 0x7f630
xorl %ecx, %ecx
callq 0x82c0
testq %rax, %rax
je 0x2f925
movq 0x28(%rax), %rbx
movq 0x30(%rax), %r14
cmpq %r14, %rbx
je 0x2f91d
movq (%rbx), %rsi
callq 0x2f974
addq $0x8, %rbx
jmp 0x2f90a
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x516bc(%rip), %rdi     # 0x80fe8
leaq 0x267b5(%rip), %rsi     # 0x560e8
callq 0x8240
leaq 0x29c5b(%rip), %rsi     # 0x5959a
movq %rax, %rdi
callq 0x8240
leaq 0x279d2(%rip), %rsi     # 0x57320
movq %rax, %rdi
callq 0x8240
pushq $0xd
popq %rsi
movq %rax, %rdi
callq 0x84b0
movq %rax, %rdi
callq 0x8170
movl $0xff, %edi
callq 0x8300
nop
// File: /workspace/github_cpp_makefile_star2_O2/luooofan[P]hblzbd_compiler/src/Pass/cond_br_to_insts.cpp
// Function: CondBrToInsts::Run()
void CondBrToInsts::Run() {
  kCount = 0;
  auto m = dynamic_cast<ArmModule*>(*(this->m_));
  MyAssert(nullptr != m);
  for (auto func : m->func_list_) {
    Run4Func(func);
  }
#ifdef OUTPUT_CONDBRTOINSTS_EFFECT
  std::cout << "CondBrToInsts Pass works on: " << kCount << " ArmBBs" << std::endl;
#endif
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
andl $0x0, 0x510f5(%rip)     # 0x816a4
movq 0x8(%rdi), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x305f8
leaq 0x4f086(%rip), %rsi     # 0x7f648
leaq 0x4f067(%rip), %rdx     # 0x7f630
xorl %ecx, %ecx
callq 0x82c0
testq %rax, %rax
je 0x305f8
movq 0x28(%rax), %rbx
movq 0x30(%rax), %r14
cmpq %r14, %rbx
je 0x305f0
movq (%rbx), %rsi
callq 0x30646
addq $0x8, %rbx
jmp 0x305dd
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x509e9(%rip), %rdi     # 0x80fe8
leaq 0x25ae2(%rip), %rsi     # 0x560e8
callq 0x8240
leaq 0x28fb6(%rip), %rsi     # 0x595c8
movq %rax, %rdi
callq 0x8240
leaq 0x26cff(%rip), %rsi     # 0x57320
movq %rax, %rdi
callq 0x8240
pushq $0x13
popq %rsi
movq %rax, %rdi
callq 0x84b0
movq %rax, %rdi
callq 0x8170
movl $0xff, %edi
callq 0x8300
// File: /workspace/github_cpp_makefile_star2_O2/luooofan[P]hblzbd_compiler/src/Pass/convert_ssa.cpp
// Function: ConvertSSA::Run()
void ConvertSSA::Run() {
  auto m = dynamic_cast<IRModule*>(*(this->m_));
  MyAssert(nullptr != m);
  for (auto f : m->func_list_) {
    InsertPhiIR(f);
    // f->EmitCode(std::cout);
    this->count_.clear();
    this->stack_.clear();
    Rename(f->bb_list_.front());
  }
  // m->EmitCode();
  auto ssam = this->ConstructSSA(m);
  *(this->m_) = static_cast<Module*>(ssam);
  delete m;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x3195f
leaq 0x4dd73(%rip), %rsi     # 0x7f648
leaq 0x4e794(%rip), %rdx     # 0x80070
xorl %ecx, %ecx
callq 0x82c0
testq %rax, %rax
je 0x3195f
movq 0x28(%rax), %rbp
movq %rax, (%rsp)
movq 0x30(%rax), %r14
leaq 0x38(%rbx), %r15
leaq 0x70(%rbx), %r12
cmpq %r14, %rbp
je 0x31932
movq (%rbp), %r13
movq %r13, %rsi
callq 0x319ae
movq %r15, %rdi
callq 0x36748
movq %r12, %rdi
callq 0x36ccc
movq 0x30(%r13), %rax
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x31cd6
addq $0x8, %rbp
jmp 0x318fc
movq %rbx, %rdi
movq (%rsp), %r14
movq %r14, %rsi
callq 0x3236a
movq 0x8(%rbx), %rcx
movq %rax, (%rcx)
movq (%r14), %rax
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *0x8(%rax)
movq 0x4f682(%rip), %rdi     # 0x80fe8
leaq 0x2477b(%rip), %rsi     # 0x560e8
callq 0x8240
leaq 0x27d8f(%rip), %rsi     # 0x59708
movq %rax, %rdi
callq 0x8240
leaq 0x25998(%rip), %rsi     # 0x57320
movq %rax, %rdi
callq 0x8240
pushq $0x10
popq %rsi
movq %rax, %rdi
callq 0x84b0
movq %rax, %rdi
callq 0x8170
movl $0xff, %edi
callq 0x8300
nop
// File: /workspace/github_cpp_makefile_star2_O2/luooofan[P]hblzbd_compiler/src/Pass/convert_ssa.cpp
// Function: ConvertSSA::FindValueFromCompName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
Value* ConvertSSA::FindValueFromCompName(const std::string& comp_name, bool is_global) {
  if (is_global) {
    auto it = glob_map.find(comp_name);
    if (it != glob_map.end()) return (*it).second;
  } else {
    auto it = work_map.find(comp_name);
    if (it != work_map.end()) return (*it).second;
  }
  return nullptr;
}

// Assembly:
pushq %rax
testl %edx, %edx
je 0x326aa
addq $0xe0, %rdi
jmp 0x326b1
addq $0xa8, %rdi
callq 0x36d60
testq %rax, %rax
je 0x326c1
movq 0x28(%rax), %rax
jmp 0x326c3
xorl %eax, %eax
popq %rcx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/luooofan[P]hblzbd_compiler/src/Pass/convert_ssa.cpp
// Function: ConvertSSA::ProcessResValue(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, ir::Opn*, Value*, SSABasicBlock*)
void ConvertSSA::ProcessResValue(const std::string& comp_name, Opn* opn, Value* val, SSABasicBlock* ssabb) {
  // 如果是全局量就加一条store语句 否则记录映射即可
  MyAssert(opn->type_ == Opn::Type::Var);
  if (0 == opn->scope_id_) {  // 全局变量需要store
    // maintain used_glob_var
    ssabb->GetFunction()->AddUsedGlobVar(dynamic_cast<GlobalVariable*>(val));

    new StoreInst(val, glob_map[comp_name], ssabb);
  } else {
    work_map[comp_name] = val;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
cmpl $0x0, (%rdx)
jne 0x32768
movq %rcx, %rbx
movq %rsi, %r15
movq %rdi, %r12
cmpl $0x0, 0x28(%rdx)
je 0x326fe
addq $0xa8, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x36e30
movq %rbx, (%rax)
jmp 0x3275e
movq %r8, %r14
movq (%r8), %r13
testq %rbx, %rbx
je 0x32726
leaq 0x4dd70(%rip), %rsi     # 0x80480
leaq 0x4dd79(%rip), %rdx     # 0x80490
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x82c0
movq %rax, %rsi
jmp 0x32728
xorl %esi, %esi
movq %r13, %rdi
callq 0x2824e
pushq $0x68
popq %rdi
callq 0x8250
movq %rax, %r13
addq $0xe0, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x36e30
movq (%rax), %rdx
movq %r13, %rdi
movq %rbx, %rsi
movq %r14, %rcx
callq 0x34b1c
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x4e879(%rip), %rdi     # 0x80fe8
leaq 0x23972(%rip), %rsi     # 0x560e8
callq 0x8240
leaq 0x26f86(%rip), %rsi     # 0x59708
movq %rax, %rdi
callq 0x8240
leaq 0x24b8f(%rip), %rsi     # 0x57320
movq %rax, %rdi
callq 0x8240
pushq $0x2f
popq %rsi
movq %rax, %rdi
callq 0x84b0
movq %rax, %rdi
callq 0x8170
movl $0xff, %edi
callq 0x8300
movq %rax, %rbx
pushq $0x68
popq %rsi
movq %r13, %rdi
callq 0x8260
movq %rbx, %rdi
callq 0x84d0
// File: /workspace/github_cpp_makefile_star2_O2/luooofan[P]hblzbd_compiler/src/Pass/convert_ssa.cpp
// Function: ConvertSSA::ProcessGlobalVariable(IRModule*, SSAModule*)
void ConvertSSA::ProcessGlobalVariable(IRModule* irm, SSAModule* ssam) {
#ifdef DEBUG_CONSTRUCT_SSA_PROCESS
  std::cout << "Process All Global Variables Start:" << std::endl;
#endif

  for (auto& [symbol, symbol_item] : irm->global_scope_.symbol_table_) {
    // new glob. record size: int-4 array-4*n. as a i32 pointer.
    auto glob_var = new GlobalVariable(symbol, symbol_item.is_array_ ? symbol_item.width_[0] : 4);
    if (symbol_item.is_const_) {  // NOTE 此时一定是常量数组 原符号表项中的initval失效
      // glob_var->val_.swap(symbol_item.initval_);
      glob_var->val_ = symbol_item.initval_;
    }
    ssam->AddGlobalVariable(glob_var);
    glob_map[symbol] = glob_var;
  }

#ifdef DEBUG_CONSTRUCT_SSA_PROCESS
  std::cout << "Process All Global Variables Finish." << std::endl;
#endif
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movq 0x40(%rsi), %rbp
addq $0x10, %rbp
addq $0xe0, %r14
pushq $0x4
popq %r15
movq (%rbp), %rbp
testq %rbp, %rbp
je 0x32b77
pushq $0x68
popq %rdi
callq 0x8250
movq %rax, %r12
cmpb $0x1, 0x28(%rbp)
movl %r15d, %edx
jne 0x32b37
movq 0x48(%rbp), %rax
movl (%rax), %edx
leaq 0x8(%rbp), %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0x34d4e
cmpb $0x1, 0x29(%rbp)
jne 0x32b5c
leaq 0x60(%rbp), %rsi
movq %r12, %rdi
addq $0x48, %rdi
callq 0x1a80a
movq %rbx, %rdi
movq %r12, %rsi
callq 0x27f24
movq %r14, %rdi
movq %r13, %rsi
callq 0x36e30
movq %r12, (%rax)
jmp 0x32b14
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
pushq $0x68
popq %rsi
movq %r12, %rdi
callq 0x8260
movq %rbx, %rdi
callq 0x84d0
// File: /workspace/github_cpp_makefile_star2_O2/luooofan[P]hblzbd_compiler/src/Pass/convert_ssa.cpp
// Function: ConvertSSA::FillPhiInst(IRFunction*, SSAFunction*, std::unordered_map<IRBasicBlock*, SSABasicBlock*, std::hash<IRBasicBlock*>, std::equal_to<IRBasicBlock*>, std::allocator<std::pair<IRBasicBlock* const, SSABasicBlock*>>>&)
void ConvertSSA::FillPhiInst(IRFunction* irfunc, SSAFunction* ssafunc,
                             std::unordered_map<IRBasicBlock*, SSABasicBlock*>& bb_map) {
  // 遍历每个irbb 如果bb开头有phi结点 就填充对应的ssabb中的phi结点
  for (auto bb : irfunc->bb_list_) {
    auto ssabb = bb_map[bb];
    int i = 0;
    for (auto ssa_inst : ssabb->GetInstList()) {
      if (auto phi_inst = dynamic_cast<PhiInst*>(ssa_inst)) {
        auto ir = *(bb->ir_list_[i]);
        for (int i = 0; i < ir.phi_args_.size(); ++i) {
          auto arg_val = ResolveOpn2Value(&ir.phi_args_[i], ssabb);
          phi_inst->AddParam(arg_val, bb_map[bb->pred_[i]]->GetValue());
        }
        ++i;
      } else {
        break;
      }
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp            # imm = 0x128
movq %rcx, 0x10(%rsp)
movq %rdi, 0x40(%rsp)
movq 0x30(%rsi), %rax
movq 0x38(%rsi), %rcx
movq %rcx, 0x18(%rsp)
leaq 0x48(%rsp), %rbx
cmpq 0x18(%rsp), %rax
je 0x349e9
movq %rax, 0x20(%rsp)
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x3763c
movq (%rax), %r15
leaq 0x28(%r15), %rax
xorl %r14d, %r14d
movq %rax, 0x28(%rsp)
movq %rax, %r13
movq (%r13), %r13
cmpq 0x28(%rsp), %r13
je 0x349db
movq 0x10(%r13), %rdi
testq %rdi, %rdi
je 0x349db
leaq 0x4bab3(%rip), %rsi     # 0x803c8
leaq 0x4bf24(%rip), %rdx     # 0x80840
xorl %ecx, %ecx
callq 0x82c0
testq %rax, %rax
je 0x349db
movq %rax, %r12
movq %r13, 0x30(%rsp)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %r14, 0x38(%rsp)
movq (%rax,%r14,8), %rsi
movq %rbx, %rdi
callq 0x34faa
xorl %ebp, %ebp
xorl %ebx, %ebx
xorl %r14d, %r14d
movq 0x110(%rsp), %rsi
movq 0x118(%rsp), %rax
subq %rsi, %rax
sarq $0x6, %rax
cmpq %r14, %rax
jbe 0x349bc
addq %rbx, %rsi
movq 0x40(%rsp), %rdi
movq %r15, %rdx
callq 0x327cc
movq %rax, %r13
movq 0x8(%rsp), %rax
movq 0x28(%rax), %rsi
addq %rbp, %rsi
movq 0x10(%rsp), %rdi
callq 0x3763c
movq (%rax), %rax
movq 0xc8(%rax), %rdx
movq %r12, %rdi
movq %r13, %rsi
callq 0x35b14
incq %r14
addq $0x40, %rbx
addq $0x8, %rbp
jmp 0x34955
leaq 0x48(%rsp), %rbx
movq %rbx, %rdi
callq 0x1fd04
movq 0x38(%rsp), %r14
incq %r14
movq 0x30(%rsp), %r13
jmp 0x348f2
movq 0x20(%rsp), %rax
addq $0x8, %rax
jmp 0x348b9
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x1fd04
movq %rbx, %rdi
callq 0x84d0
// File: /workspace/github_cpp_makefile_star2_O2/luooofan[P]hblzbd_compiler/src/Pass/dead_code_eliminate.cpp
// Function: DeadCodeEliminate::Run()
void DeadCodeEliminate::Run() {
  auto m = dynamic_cast<SSAModule*>(*(this->m_));
  MyAssert(nullptr != m);
  DeleteDeadFunc(m);
  FindNoSideEffectFunc(m, no_side_effect_funcs);
  for (auto func : m->GetFuncList()) {
    DeleteDeadInst(func);
    func->MaintainCallFunc();  // 有可能删除call语句
    DeleteDeadStore(func);
  }
  DeleteDeadFunc(m);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x3971d
leaq 0x45f9d(%rip), %rsi     # 0x7f648
leaq 0x4724e(%rip), %rdx     # 0x80900
xorl %ecx, %ecx
callq 0x82c0
testq %rax, %rax
je 0x3971d
movq %rax, %r14
movq %rax, %rsi
callq 0x3976c
leaq 0x38(%rbx), %rsi
movq %r14, %rdi
callq 0x398be
movq %r14, %r12
addq $0x40, %r12
movq %r12, %r13
movq (%r13), %r13
cmpq %r12, %r13
je 0x3970c
movq 0x10(%r13), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x39ace
movq %r15, %rdi
callq 0x2806e
movq %rbx, %rdi
movq %r15, %rsi
callq 0x39c58
jmp 0x396df
movq %r14, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x3976c
movq 0x478c4(%rip), %rdi     # 0x80fe8
leaq 0x1c9bd(%rip), %rsi     # 0x560e8
callq 0x8240
leaq 0x20002(%rip), %rsi     # 0x59739
movq %rax, %rdi
callq 0x8240
leaq 0x1dbda(%rip), %rsi     # 0x57320
movq %rax, %rdi
callq 0x8240
pushq $0x10
popq %rsi
movq %rax, %rdi
callq 0x84b0
movq %rax, %rdi
callq 0x8170
movl $0xff, %edi
callq 0x8300
nop
// File: /workspace/github_cpp_makefile_star2_O2/luooofan[P]hblzbd_compiler/src/Pass/dead_code_eliminate.cpp
// Function: DeadCodeEliminate::DeleteDeadFunc(SSAModule*)
void DeadCodeEliminate::DeleteDeadFunc(SSAModule* m) {
#ifdef DEBUG_DEAD_CODE_ELIMINATE_PROCESS
  std::cout << "Try To Remove Function: " << std::endl;
#endif
  std::unordered_set<SSAFunction*> worklist;
  for (auto func : m->GetFuncList()) {
    if ("main" == func->GetFuncName()) continue;
    worklist.insert(func);
  }
  while (!worklist.empty()) {
    auto func = *worklist.begin();
    worklist.erase(func);
    if (!func->IsCalled()) {
      // 应该把该函数调用的函数加入工作表
      for (auto call_func : func->GetCallFuncList()) {
        if ("main" == call_func->GetFuncName()) continue;
        worklist.insert(call_func);
      }
      // 说明该函数没被调用过 是dead function可以被删除 应该维护的信息全交由Remove函数完成
#ifdef DEBUG_DEAD_CODE_ELIMINATE_PROCESS
      std::cout << "  Remove Function: " << func->GetFuncName() << std::endl;
#endif
      func->Remove();
      delete func;
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rsi, %rbx
leaq 0x48(%rsp), %rax
movq %rax, -0x30(%rax)
movq $0x1, -0x28(%rax)
xorps %xmm0, %xmm0
movups %xmm0, -0x20(%rax)
movl $0x3f800000, -0x10(%rax) # imm = 0x3F800000
movups %xmm0, -0x8(%rax)
addq $0x40, %rbx
leaq 0x1d316(%rip), %r14     # 0x56ac0
leaq 0x18(%rsp), %r15
leaq 0x8(%rsp), %r12
movq %rbx, %r13
movq (%r13), %r13
cmpq %rbx, %r13
je 0x397e2
movq 0x10(%r13), %rsi
movq %rsi, 0x8(%rsp)
movq %r14, %rdi
callq 0x1ae8c
testb %al, %al
jne 0x397b7
movq %r15, %rdi
movq %r12, %rsi
callq 0x296c4
jmp 0x397b7
leaq 0x18(%rsp), %rbx
leaq 0x8(%rsp), %r14
leaq 0x1d2cd(%rip), %r15     # 0x56ac0
leaq 0x10(%rsp), %r12
cmpq $0x0, 0x30(%rsp)
je 0x3988d
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3a34a
movq 0x8(%rsp), %rdi
callq 0x282b4
testb %al, %al
jne 0x397f8
movq 0x8(%rsp), %r13
addq $0x58, %r13
movq (%r13), %r13
testq %r13, %r13
je 0x3985f
movq 0x8(%r13), %rsi
movq %rsi, 0x10(%rsp)
movq %r15, %rdi
callq 0x1ae8c
testb %al, %al
jne 0x39834
movq %rbx, %rdi
movq %r12, %rsi
callq 0x296c4
jmp 0x39834
movq 0x8(%rsp), %rdi
callq 0x282c4
movq 0x8(%rsp), %r13
testq %r13, %r13
je 0x3987b
movq %r13, %rdi
callq 0x2839a
movl $0xb8, %esi
movq %r13, %rdi
callq 0x8260
jmp 0x397f8
leaq 0x18(%rsp), %rdi
callq 0x28b7e
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x398a9
jmp 0x398a9
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x28b7e
movq %rbx, %rdi
callq 0x84d0