LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/acliusBackHome[P]kamaya/dist/ParseTree.cpp
// Function: ParseTree::make_direct_declarator_node(std::vector<unsigned long, std::allocator<unsigned long>> const&, ParseExpression const*)
size_t ParseTree::make_direct_declarator_node(const vector<size_t> &array_size, const ParseExpression *expression) {
    size_t new_one = new_node(N_DIRECT_DEC);
    nodes[new_one].set_array_size(array_size);
    if (!array_size.empty()) {
        if (expression) {
            nodes[new_one].set_expression(*expression);
        } else {
            nodes[new_one].set_expression(ParseExpression::get_expression(0));
        }
    }
    return new_one;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, %r12
movl $0x7, %esi
callq 0x17c64
movq %rax, %rbx
movq %rax, %r15
shlq $0x5, %r15
movq (%r12), %rdi
addq %r15, %rdi
movq %r13, %rsi
callq 0x1d61a
movq (%r13), %rax
cmpq 0x8(%r13), %rax
je 0x18650
addq (%r12), %r15
testq %r14, %r14
jne 0x18645
xorl %edi, %edi
callq 0x2b006
movq %rax, %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0x1d44a
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/acliusBackHome[P]kamaya/dist/ParseTree.cpp
// Function: ParseTree::make_assign_expression_node(ParseExpression const&, ParseExpression const&)
size_t ParseTree::make_assign_expression_node(
        const ParseExpression &l_expr, const ParseExpression &r_expr) {
    const ParseExpression &assign_expr = ParseExpression::get_assign_expression(l_expr, r_expr);
    size_t new_one = new_node(N_EXPRESSION);
    nodes[new_one].set_expression(assign_expr);
    return new_one;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x2c70e
movq %rax, %r14
movq %rbx, %rdi
movl $0xf, %esi
callq 0x17c64
movq %rax, %r15
movq %rax, %rdi
shlq $0x5, %rdi
addq (%rbx), %rdi
movq %r14, %rsi
callq 0x1d44a
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/acliusBackHome[P]kamaya/dist/ParseNode.cpp
// Function: ParseNode::get_true_list() const
const vector<size_t> &ParseNode::get_true_list() const {
    // 需求特殊性: 如果没有则先set为空, 再返回之
    if (!(keys & K_TRUE_LIST)) {
        ((ParseNode *) this)->set_true_list(vector<size_t>());
    }
    return get_field<vector<size_t>>(K_TRUE_LIST);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
testb $-0x80, 0x9(%rdi)
jne 0x1d01f
xorps %xmm0, %xmm0
leaq -0x20(%rbp), %rdx
movaps %xmm0, (%rdx)
movq $0x0, 0x10(%rdx)
movq %rbx, %rdi
movl $0x8000, %esi           # imm = 0x8000
xorl %ecx, %ecx
callq 0x1f8b4
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x1d01f
callq 0x42b0
movq %rbx, %rdi
movl $0x8000, %esi           # imm = 0x8000
callq 0x226c2
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x1d044
callq 0x42b0
movq %rbx, %rdi
callq 0x4560
// File: /workspace/github_cpp_makefile_star2_O3/acliusBackHome[P]kamaya/dist/ParseNode.cpp
// Function: ParseNode::get_false_list() const
const vector<size_t> &ParseNode::get_false_list() const {
    // 需求特殊性: 如果没有则先set为空, 再返回之
    if (!(keys & K_FALSE_LIST)) {
        ((ParseNode *) this)->set_false_list(vector<size_t>());
    }
    return get_field<vector<size_t>>(K_FALSE_LIST);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
testb $0x1, 0xa(%rdi)
jne 0x1d08d
xorps %xmm0, %xmm0
leaq -0x20(%rbp), %rdx
movaps %xmm0, (%rdx)
movq $0x0, 0x10(%rdx)
movq %rbx, %rdi
movl $0x10000, %esi          # imm = 0x10000
xorl %ecx, %ecx
callq 0x1f8b4
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x1d08d
callq 0x42b0
movq %rbx, %rdi
movl $0x10000, %esi          # imm = 0x10000
callq 0x226c2
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x1d0b2
callq 0x42b0
movq %rbx, %rdi
callq 0x4560
// File: /workspace/github_cpp_makefile_star2_O3/acliusBackHome[P]kamaya/dist/ParseNode.cpp
// Function: ParseNode::get_next_list() const
const vector<size_t> &ParseNode::get_next_list() const {
    // 需求特殊性: 如果没有则先set为空, 再返回之
    if (!(keys & K_NEXT_LIST)) {
        ((ParseNode *) this)->set_next_list(vector<size_t>());
    }
    return get_field<vector<size_t> >(K_NEXT_LIST);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
testb $0x8, 0xa(%rdi)
jne 0x1d123
xorps %xmm0, %xmm0
leaq -0x20(%rbp), %rdx
movaps %xmm0, (%rdx)
movq $0x0, 0x10(%rdx)
movq %rbx, %rdi
movl $0x80000, %esi          # imm = 0x80000
xorl %ecx, %ecx
callq 0x1f8b4
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x1d123
callq 0x42b0
movq %rbx, %rdi
movl $0x80000, %esi          # imm = 0x80000
callq 0x226c2
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x1d148
callq 0x42b0
movq %rbx, %rdi
callq 0x4560
// File: /workspace/github_cpp_makefile_star2_O3/acliusBackHome[P]kamaya/dist/ParseNode.cpp
// Function: ParseNode::add_expression_list(ParseExpression const&)
void ParseNode::add_expression_list(const ParseExpression &expr) {
    if (has_key(K_EXPRESSION_LIST)) {
        auto &list = (vector<size_t> &) get_expression_list();
        list.emplace_back(expr.get_id());
    } else {
        vector<size_t> list;
        list.emplace_back(expr.get_id());
        set_field<vector<size_t> >(K_EXPRESSION_LIST, list);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
testb $-0x80, 0xa(%rdi)
jne 0x1d691
xorps %xmm0, %xmm0
movaps %xmm0, -0x30(%rbp)
movq $0x0, -0x20(%rbp)
movq %r14, %rdi
callq 0x2c6c6
leaq -0x38(%rbp), %rdx
movq %rax, (%rdx)
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
callq 0x19328
leaq -0x30(%rbp), %rdx
movq %rbx, %rdi
movl $0x800000, %esi         # imm = 0x800000
xorl %ecx, %ecx
callq 0x1f8b4
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x1d6d0
callq 0x42b0
jmp 0x1d6d0
movq %rbx, %rdi
movl $0x800000, %esi         # imm = 0x800000
callq 0x226c2
movq %rax, %rbx
movq %r14, %rdi
callq 0x2c6c6
movq %rax, -0x30(%rbp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x1d6c4
movq %rax, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x1d6d0
leaq -0x30(%rbp), %rdx
movq %rbx, %rdi
callq 0x19328
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x1d6db
movq %rax, %rbx
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x1d6ec
callq 0x42b0
movq %rbx, %rdi
callq 0x4560
// File: /workspace/github_cpp_makefile_star2_O3/acliusBackHome[P]kamaya/dist/ParseNode.cpp
// Function: ParseNode::add_array_size(unsigned long)
void ParseNode::add_array_size(size_t array_size) {
    if (has_key(K_ARRAY_SIZE)) {
        auto &list = (vector<size_t> &) get_array_size();
        list.emplace_back(array_size);
    } else {
        vector<size_t> list;
        list.emplace_back(array_size);
        set_field<vector<size_t> >(K_ARRAY_SIZE, list);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq %rsi, -0x18(%rbp)
testb $-0x80, 0x8(%rdi)
jne 0x1d74c
xorps %xmm0, %xmm0
leaq -0x30(%rbp), %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
leaq -0x18(%rbp), %rdx
xorl %esi, %esi
callq 0x26040
leaq -0x30(%rbp), %rdx
movq %rbx, %rdi
movl $0x80, %esi
xorl %ecx, %ecx
callq 0x1f8b4
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x1d77f
callq 0x42b0
jmp 0x1d77f
movq %rsi, %r14
movq %rbx, %rdi
movl $0x80, %esi
callq 0x226c2
movq 0x8(%rax), %rsi
cmpq 0x10(%rax), %rsi
je 0x1d773
movq %r14, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rax)
jmp 0x1d77f
leaq -0x18(%rbp), %rdx
movq %rax, %rdi
callq 0x26040
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x1d799
callq 0x42b0
movq %rbx, %rdi
callq 0x4560
nop
// File: /workspace/github_cpp_makefile_star2_O3/acliusBackHome[P]kamaya/dist/ParseNode.cpp
// Function: ParseNode::add_init_declarator(std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, ParseExpression, unsigned long, std::vector<unsigned long, std::allocator<unsigned long>>, unsigned long> const&)
void ParseNode::add_init_declarator(const InitDeclarator &init_declarator) {
    if (has_key(K_INIT_DECLARATORS)) {
        auto &list = (vector<InitDeclarator> &) get_init_declarators();
        list.emplace_back(init_declarator);
    } else {
        vector<InitDeclarator> list;
        list.emplace_back(init_declarator);
        set_field<vector<InitDeclarator> >(K_INIT_DECLARATORS, list);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
testb $0x1, 0x9(%rdi)
jne 0x1d7f8
xorps %xmm0, %xmm0
leaq -0x30(%rbp), %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq %r14, %rsi
callq 0x20112
leaq -0x30(%rbp), %rdx
movq %rbx, %rdi
movl $0x100, %esi            # imm = 0x100
xorl %ecx, %ecx
callq 0x2014e
leaq -0x30(%rbp), %rdi
callq 0x13bf2
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
movl $0x100, %esi            # imm = 0x100
callq 0x2325a
movq %rax, %rdi
movq %r14, %rsi
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x20112
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x13bf2
movq %rbx, %rdi
callq 0x4560
// File: /workspace/github_cpp_makefile_star2_O3/acliusBackHome[P]kamaya/dist/ParseType.cpp
// Function: ParseType::assign(ParseType&, ParseType const&)
void ParseType::assign(ParseType &type, const ParseType &from_type) {
    delete type.fields;
    if (from_type.fields) {
        type.fields = new map<string, size_t>(*from_type.fields);
    } else {
        type.fields = nullptr;
    }
    type.lower_type = from_type.lower_type;
    type.specifier = from_type.specifier;
    type.base_type = from_type.base_type;
    type.type_size = from_type.type_size;
    type.pointer_level = from_type.pointer_level;
    type.array_size = from_type.array_size;
    type.type_id = from_type.type_id;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rdi), %r15
testq %r15, %r15
je 0x26ec2
movq %r15, %rdi
callq 0x13f28
movq %r15, %rdi
callq 0x42b0
movq 0x10(%r14), %r12
testq %r12, %r12
je 0x26eed
movl $0x30, %edi
callq 0x42e0
movq %rax, %r15
movq %rax, %rdi
movq %r12, %rsi
callq 0x28f62
jmp 0x26ef0
xorl %r15d, %r15d
movq %r15, 0x10(%rbx)
movq 0x8(%r14), %rax
movq %rax, 0x8(%rbx)
movl 0x4(%r14), %eax
movl %eax, 0x4(%rbx)
movl (%r14), %eax
movl %eax, (%rbx)
movq 0x20(%r14), %rax
movq %rax, 0x20(%rbx)
movq 0x28(%r14), %rax
movq %rax, 0x28(%rbx)
movq 0x30(%r14), %rax
movq %rax, 0x30(%rbx)
movq 0x18(%r14), %rax
movq %rax, 0x18(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r15, %rdi
callq 0x42b0
movq %rbx, %rdi
callq 0x4560
// File: /workspace/github_cpp_makefile_star2_O3/acliusBackHome[P]kamaya/dist/ParseType.cpp
// Function: ParseType::get_pointer(ParseType const&, unsigned long)
ParseType ParseType::get_pointer(const ParseType &type, size_t ptr_level) {
    if (ptr_level == 0) {
        printf("ParseType::get_pointer(const ParseType &type, size_t ptr_level): 警告: 获取类型%s的0级指针\n",
               type.get_info().c_str());
        return type;
    }
    if (type.pointer_level == 0) {
        return ParseType(T_UNKNOWN, get_type_id(type), nullptr, sizeof(void *), ptr_level, 0);
    } else {
        auto res = ParseType(type);
        res.type_id = (size_t) -1;
        res.pointer_level += ptr_level;
        return res;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
testq %rdx, %rdx
je 0x27362
movq %rdx, %r15
cmpq $0x0, 0x28(%r14)
je 0x273b5
leaq 0x8(%rbx), %rax
movl $0x0, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x26ea0
movq $-0x1, 0x18(%rbx)
addq %r15, 0x28(%rbx)
jmp 0x273e4
leaq -0x38(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x273f2
movq (%r15), %rsi
leaq 0x1eb5e(%rip), %rdi     # 0x45ed9
xorl %eax, %eax
callq 0x4070
movq (%r15), %rdi
leaq -0x28(%rbp), %rax
cmpq %rax, %rdi
je 0x27393
callq 0x42b0
movl $0x0, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
movups %xmm0, 0x18(%rbx)
movups %xmm0, 0x28(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x26ea0
jmp 0x273e4
movq %r14, %rdi
callq 0x27870
xorl %ecx, %ecx
movl %ecx, (%rbx)
movq %rax, 0x8(%rbx)
movq %rcx, 0x10(%rbx)
movl %ecx, 0x4(%rbx)
movq $0x8, 0x20(%rbx)
movq %r15, 0x28(%rbx)
movq %rcx, 0x30(%rbx)
movq $-0x1, 0x18(%rbx)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/acliusBackHome[P]kamaya/dist/ParseType.cpp
// Function: ParseType::get_type_id(ParseType const&)
size_t ParseType::get_type_id(const ParseType &type) {
    if (id2type.empty()) {
        // 没有经过初始化, 进行初始化
        init();
    }
    if (type.type_id == (size_t) -1) {
        auto iter = type2id.find(type);
        if (iter == type2id.end()) {
            ((ParseType &) type).type_id = id2type.size();
            type2id[type] = type.type_id;
            id2type.emplace_back(type);
            id2info.emplace_back(type.get_info());
            return type.type_id;
        }
        return ((ParseType &) type).type_id = iter->second;
    }
    return type.type_id;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x34a71(%rip), %rax     # 0x5c2f8
cmpq 0x34a72(%rip), %rax     # 0x5c300
jne 0x27895
callq 0x27f46
movq 0x18(%rbx), %rax
cmpq $-0x1, %rax
jne 0x27944
leaq 0x34a1e(%rip), %rdi     # 0x5c2c8
movq %rbx, %rsi
callq 0x29d6c
leaq 0x34a17(%rip), %rcx     # 0x5c2d0
cmpq %rcx, %rax
je 0x278c8
movq 0x58(%rax), %rax
movq %rax, 0x18(%rbx)
jmp 0x27944
leaq 0x34a29(%rip), %r14     # 0x5c2f8
movq 0x34a2a(%rip), %rax     # 0x5c300
subq 0x34a1b(%rip), %rax     # 0x5c2f8
sarq $0x3, %rax
movabsq $0x6db6db6db6db6db7, %r15 # imm = 0x6DB6DB6DB6DB6DB7
imulq %rax, %r15
movq %r15, 0x18(%rbx)
leaq 0x349ce(%rip), %rdi     # 0x5c2c8
movq %rbx, %rsi
callq 0x28cec
movq %r15, (%rax)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x28d82
leaq -0x38(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x273f2
leaq 0x349ea(%rip), %rdi     # 0x5c310
movq %r14, %rsi
callq 0x15466
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x27940
callq 0x42b0
movq 0x18(%rbx), %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x27964
callq 0x42b0
movq %rbx, %rdi
callq 0x4560
// File: /workspace/github_cpp_makefile_star2_O3/acliusBackHome[P]kamaya/dist/ParseType.cpp
// Function: ParseType::get_type(unsigned long)
const ParseType &ParseType::get_type(size_t type_id) {
    if (id2type.empty()) {
        // 没有经过初始化, 进行初始化
        init();
    }
    if (type_id >= id2type.size()) {
        printf("ParseType &ParseType::get_type(size_t type_id): 警告: 试图获取不存在的类型, id:%zu\n", type_id);
        return id2type[T_UNKNOWN];
    }
    return id2type[type_id];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x3497c(%rip), %rax     # 0x5c2f8
movq 0x3497d(%rip), %rcx     # 0x5c300
cmpq %rcx, %rax
jne 0x2799b
callq 0x27f46
movq 0x3496c(%rip), %rcx     # 0x5c300
movq 0x3495d(%rip), %rax     # 0x5c2f8
subq %rax, %rcx
sarq $0x3, %rcx
movabsq $0x6db6db6db6db6db7, %rdx # imm = 0x6DB6DB6DB6DB6DB7
imulq %rcx, %rdx
cmpq %rbx, %rdx
jbe 0x279be
imulq $0x38, %rbx, %rcx
addq %rcx, %rax
jmp 0x279d6
leaq 0x1e57a(%rip), %rdi     # 0x45f3f
movq %rbx, %rsi
xorl %eax, %eax
callq 0x4070
movq 0x34922(%rip), %rax     # 0x5c2f8
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/acliusBackHome[P]kamaya/dist/ParseType.cpp
// Function: ParseType::ParseType(BaseType, unsigned long, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned long, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, unsigned long>>>*, unsigned long, unsigned long, unsigned long, int)
ParseType::ParseType(BaseType bt, size_t low_t, map<string, size_t> *fs, size_t ts, size_t ptr_lv, size_t arr_size, int spe) {
    base_type = bt;
    lower_type = low_t;
    fields = fs;
    specifier = spe;
    type_size = ts;
    pointer_level = ptr_lv;
    array_size = arr_size;
    type_id = (size_t) -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x10(%rbp), %rax
movl 0x18(%rbp), %r10d
movl %esi, (%rdi)
movq %rdx, 0x8(%rdi)
movq %rcx, 0x10(%rdi)
movl %r10d, 0x4(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
movq %rax, 0x30(%rdi)
movq $-0x1, 0x18(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/acliusBackHome[P]kamaya/dist/ParseType.cpp
// Function: ParseType::field(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
ParseType ParseType::field(const string &key) const {
    if (fields) {
        auto iter = fields->find(key);
        if (iter == fields->end()) {
            return ParseType();
        }
        return id2type[iter->second];
    }
    return ParseType();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rsi), %rdi
testq %rdi, %rdi
je 0x285b2
movq %rsi, %r14
movq %rdx, %rsi
callq 0x19ea6
movq 0x10(%r14), %rcx
addq $0x8, %rcx
cmpq %rcx, %rax
je 0x285b2
imulq $0x38, 0x40(%rax), %rsi
addq 0x33d65(%rip), %rsi     # 0x5c2f8
movl $0x0, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
movups %xmm0, 0x18(%rbx)
movups %xmm0, 0x28(%rbx)
movq %rbx, %rdi
callq 0x26ea0
jmp 0x285cf
movl $0x0, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rbx)
movups %xmm0, 0x8(%rbx)
movups %xmm0, 0x28(%rbx)
movq $-0x1, 0x18(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/acliusBackHome[P]kamaya/dist/ParseType.cpp
// Function: ParseType::get_specifier() const
size_t ParseType::get_specifier() const {
    if (base_type == T_UNKNOWN) {
        printf("ParseType::get_specifier(): 警告: 试图获取非基础类型Type-%zu的标识符\n", get_id());
        return 0;
    }
    return lower_type;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, (%rdi)
je 0x285ec
movq 0x8(%rbx), %rbx
jmp 0x28615
movq 0x18(%rbx), %rsi
cmpq $-0x1, %rsi
jne 0x28605
movq %rbx, %rdi
callq 0x27870
movq %rax, %rsi
movq %rax, 0x18(%rbx)
leaq 0x1d99c(%rip), %rdi     # 0x45fa8
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x4070
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/acliusBackHome[P]kamaya/dist/ParseType.cpp
// Function: ParseType::cmp_wider_type(unsigned long, unsigned long)
bool ParseType::cmp_wider_type(size_t t1_id, size_t t2_id) {
    if (t1_id <= T_BASE && t2_id <= T_BASE) {
        return t1_id >= t2_id;
    } else {
        const ParseType &t1 = ParseType::get_type(t1_id),
                &t2 = ParseType::get_type(t2_id);
        if (t1.base_type == t2.base_type && t1.base_type != T_UNKNOWN) {
            // 是基础类型的特殊声明 long unsigned等
            return t1.specifier >= t2.specifier;
        } else {
            return t1_id >= t2_id;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0xa, %rdi
setae %al
cmpq $0xa, %rsi
setae %cl
orb %al, %cl
jne 0x28b64
cmpq %rbx, %r14
setae %al
jmp 0x28b8c
movq %r14, %rdi
callq 0x2796c
movq %rax, %r15
movq %rbx, %rdi
callq 0x2796c
movl (%r15), %ecx
testl %ecx, %ecx
je 0x28b5c
cmpl (%rax), %ecx
jne 0x28b5c
movl 0x4(%r15), %ecx
cmpl 0x4(%rax), %ecx
setge %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/acliusBackHome[P]kamaya/dist/ParseExpression.cpp
// Function: ParseExpression::update(ParseExpression const&)
void ParseExpression::update(const ParseExpression &expr) {
    if (id2expr.empty()) {
        init();
    }
    auto it = expr2id.find(expr);
    if (it == expr2id.end()) {
        expr2id[expr] = id2expr.size();
        ((ParseExpression &) expr).expr_id = id2expr.size();
        id2expr.emplace_back(expr);
        id2address.emplace_back(0);
        expr_call_back(id2expr[id2expr.size() - 1]);
    } else {
        ((ParseExpression &) expr).expr_id = it->second;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x314a7(%rip), %rax     # 0x5c3c0
cmpq 0x314a8(%rip), %rax     # 0x5c3c8
jne 0x2af27
callq 0x2b974
leaq 0x31462(%rip), %rdi     # 0x5c390
movq %rbx, %rsi
callq 0x2e02a
leaq 0x3145b(%rip), %rcx     # 0x5c398
cmpq %rcx, %rax
je 0x2af4f
movq 0x50(%rax), %rax
movq %rax, 0x10(%rbx)
jmp 0x2aff8
movq 0x31472(%rip), %r15     # 0x5c3c8
subq 0x31463(%rip), %r15     # 0x5c3c0
leaq 0x3145c(%rip), %r14     # 0x5c3c0
sarq $0x4, %r15
movabsq $-0x5555555555555555, %r12 # imm = 0xAAAAAAAAAAAAAAAB
imulq %r12, %r15
leaq 0x31413(%rip), %rdi     # 0x5c390
movq %rbx, %rsi
callq 0x2d886
movq %r15, (%rax)
movq 0x31439(%rip), %rax     # 0x5c3c8
subq 0x3142a(%rip), %rax     # 0x5c3c0
sarq $0x4, %rax
imulq %r12, %rax
movq %rax, 0x10(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2d91c
movl $0x0, -0x24(%rbp)
movq 0x31425(%rip), %rsi     # 0x5c3e0
cmpq 0x31426(%rip), %rsi     # 0x5c3e8
je 0x2afd8
movq $0x0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x3140a(%rip)     # 0x5c3e0
jmp 0x2afe8
leaq 0x313f9(%rip), %rdi     # 0x5c3d8
leaq -0x24(%rbp), %rdx
callq 0x2dc60
movq 0x313d9(%rip), %rdi     # 0x5c3c8
addq $-0x30, %rdi
callq 0x5b35
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/acliusBackHome[P]kamaya/dist/ParseExpression.cpp
// Function: ParseExpression::get_expression(unsigned long)
const ParseExpression &ParseExpression::get_expression(size_t expr_id) {
    if (id2expr.empty()) {
        init();
    }
    if (expr_id >= id2expr.size()) {
        printf("ParseExpression::expression(size_t expr_id): 警告:试图获取未定义的表达式ID:%zu\n",
               expr_id);
        return id2expr[0];
    }
    return id2expr[expr_id];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x313aa(%rip), %rax     # 0x5c3c0
movq 0x313ab(%rip), %rcx     # 0x5c3c8
cmpq %rcx, %rax
jne 0x2b035
callq 0x2b974
movq 0x3139a(%rip), %rcx     # 0x5c3c8
movq 0x3138b(%rip), %rax     # 0x5c3c0
subq %rax, %rcx
sarq $0x4, %rcx
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rdx
cmpq %rbx, %rdx
jbe 0x2b05c
leaq (%rbx,%rbx,2), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
jmp 0x2b074
leaq 0x1b2df(%rip), %rdi     # 0x46342
movq %rbx, %rsi
xorl %eax, %eax
callq 0x4070
movq 0x3134c(%rip), %rax     # 0x5c3c0
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/acliusBackHome[P]kamaya/dist/ParseExpression.cpp
// Function: ParseExpression::is_const() const
bool ParseExpression::is_const() const {
    if (expr_type == E_CONST) {
        return true;
    }
    if (const_value == (size_t) -1) {
        return false;
    }
    if (!const_value) {
        ((ParseExpression *) this)->calculate_const();
    }
    return const_value != (size_t) -1;
}

// Assembly:
movb $0x1, %al
cmpl $0x3, 0x28(%rdi)
je 0x2b331
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rax
cmpq $-0x1, %rax
je 0x2b329
testq %rax, %rax
jne 0x2b320
movq %rbx, %rdi
callq 0x33a80
movq 0x18(%rbx), %rax
cmpq $-0x1, %rax
setne %al
jmp 0x2b32b
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/acliusBackHome[P]kamaya/dist/ParseExpression.cpp
// Function: ParseExpression::ParseExpression(ParseConstant const&)
ParseExpression::ParseExpression(const ParseConstant &constant) {
    expr_type = E_CONST;
    child[0] = (size_t)
            new ParseConstant(constant);
    const_value = child[0];
    ret_type_id = ParseType(constant).get_id();
    update(*this);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl $0x3, 0x28(%rdi)
movl $0x10, %edi
callq 0x42e0
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x2ee02
movq %r15, (%rbx)
movq %r15, 0x18(%rbx)
leaq -0x50(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x270d8
movq %r15, %rdi
callq 0x270b4
movq %rax, 0x20(%rbx)
leaq -0x50(%rbp), %rdi
callq 0x27ca8
movq %rbx, %rdi
callq 0x2af00
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x27ca8
jmp 0x2b6e1
movq %rax, %rbx
movq %r15, %rdi
callq 0x42b0
movq %rbx, %rdi
callq 0x4560
nop
// File: /workspace/github_cpp_makefile_star2_O3/acliusBackHome[P]kamaya/dist/ParseExpression.cpp
// Function: ParseExpression::assign(ParseExpression&, ParseExpression const&)
void ParseExpression::assign(ParseExpression &expr, const ParseExpression &from_expr) {
    expr.expr_id = from_expr.expr_id;
    expr.ret_type_id = from_expr.ret_type_id;
    if (from_expr.is_const()) {
        expr.const_value = (size_t)
                new ParseConstant(*(ParseConstant *) from_expr.const_value);
    } else {
        expr.const_value = (size_t) -1;
    }
    switch (expr.expr_type = from_expr.expr_type) {
        case E_UNDEFINED:
            break;
        case E_ADD:
        case E_SUB:
        case E_MUL:
        case E_DIV:
        case E_MOD:
        case E_POW:
        case E_LOGIC_OR:
        case E_LOGIC_AND:
        case E_G:
        case E_GE:
        case E_EQUAL:
        case E_NE:
        case E_L:
        case E_LE:
        case E_GET_ITEM:
            expr.child[0] = from_expr.child[0];
            expr.child[1] = from_expr.child[1];
            break;
        case E_ADR:
        case E_PTR:
        case E_NEG:
        case E_POS:
        case E_BIT_NOT:
        case E_NOT:
            expr.child[0] = from_expr.child[0];
            break;
        case E_VAR:
            expr.child[0] = (size_t)
                    new ParseVariable(*(ParseVariable *) from_expr.child[0]);
            break;
        case E_CONST:
            expr.child[0] = (size_t)
                    new ParseConstant(*(ParseConstant *) from_expr.child[0]);
            break;
        case E_ASSIGN:
            expr.child[0] = from_expr.child[0];
            expr.child[1] = from_expr.child[1];
            break;
        case E_FUN:
            expr.child[0] = (size_t) new DecFuncPtrList(*(DecFuncPtrList *)from_expr.child[0]);
            break;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movq 0x10(%rsi), %rax
movq %rax, 0x10(%rdi)
movq 0x20(%rsi), %rax
movq %rax, 0x20(%rdi)
movq %rsi, %rdi
callq 0x2b2f4
movq $-0x1, %r14
testb %al, %al
je 0x2b740
movl $0x10, %edi
callq 0x42e0
movq %rax, %r14
movq 0x18(%r15), %rsi
movq %rax, %rdi
callq 0x2ee02
movq %r14, 0x18(%rbx)
movl 0x28(%r15), %eax
movl %eax, 0x28(%rbx)
decl %eax
cmpl $0x18, %eax
ja 0x2b7c9
leaq 0x1aa3f(%rip), %rcx     # 0x46198
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%r15), %rax
movq %rax, (%rbx)
movq 0x8(%r15), %rax
movq %rax, 0x8(%rbx)
jmp 0x2b7c9
movq (%r15), %rax
movq %rax, (%rbx)
jmp 0x2b7c9
movl $0x10, %edi
callq 0x42e0
movq %rax, %r14
movq (%r15), %rsi
movq %rax, %rdi
callq 0x2ee02
jmp 0x2b7c6
movl $0x68, %edi
callq 0x42e0
movq %rax, %r14
movq (%r15), %rsi
movq %rax, %rdi
callq 0x2e874
jmp 0x2b7c6
movl $0x18, %edi
callq 0x42e0
movq %rax, %r14
movq (%r15), %rsi
movq %rax, %rdi
callq 0x2d71e
movq %r14, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2b7da
jmp 0x2b7da
jmp 0x2b7da
movq %rax, %rbx
movq %r14, %rdi
callq 0x42b0
movq %rbx, %rdi
callq 0x4560
nop
// File: /workspace/github_cpp_makefile_star2_O3/acliusBackHome[P]kamaya/dist/ParseExpression.cpp
// Function: ParseExpression::ParseExpression(ParseVariable const&)
ParseExpression::ParseExpression(const ParseVariable &variable) {
    const_value = 0;
    ret_type_id = variable.get_type().get_id();
    expr_type = E_VAR;
    child[0] = (size_t)
            new ParseVariable(variable);
    update(*this);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movq $0x0, 0x18(%rdi)
movq %rsi, %rdi
callq 0x2e726
movq %rax, %rdi
callq 0x270b4
movq %rax, 0x20(%rbx)
movl $0x1, 0x28(%rbx)
movl $0x68, %edi
callq 0x42e0
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0x2e874
movq %r14, (%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2af00
movq %rax, %rbx
movq %r14, %rdi
callq 0x42b0
movq %rbx, %rdi
callq 0x4560
nop
// File: /workspace/github_cpp_makefile_star2_O3/acliusBackHome[P]kamaya/dist/ParseExpression.cpp
// Function: ParseExpression::ParseExpression(std::vector<ParseFunction const*, std::allocator<ParseFunction const*>> const&)
ParseExpression::ParseExpression(const DecFuncPtrList &func_list) {
    if (func_list.empty()) {
        string info = "ParseExpression(const vector<const ParseFunction *> &func_list)";
        throw ParseException(EX_INVALID_FUNC_EXPRESSION, info);
    }
    const_value = 0;
    ret_type_id = (func_list[0])->get_ret_type().get_id();
    expr_type = E_FUN;
    child[0] = (size_t) new DecFuncPtrList(func_list);
    update(*this);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq (%rsi), %rax
cmpq 0x8(%rsi), %rax
je 0x2b8df
movq %rsi, %r14
movq %rdi, %rbx
movq $0x0, 0x18(%rdi)
movq (%rax), %rsi
leaq -0x50(%rbp), %r15
movq %r15, %rdi
callq 0x2e8ca
movq %r15, %rdi
callq 0x270b4
movq %rax, 0x20(%rbx)
leaq -0x50(%rbp), %rdi
callq 0x27ca8
movl $0x2, 0x28(%rbx)
movl $0x18, %edi
callq 0x42e0
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x2d71e
movq %r15, (%rbx)
movq %rbx, %rdi
callq 0x2af00
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq -0x40(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x1aa14(%rip), %rsi     # 0x46302
leaq 0x1aa4c(%rip), %rdx     # 0x46341
leaq -0x50(%rbp), %rdi
callq 0xf868
movl $0x28, %edi
callq 0x4190
movq %rax, %r14
leaq -0x50(%rbp), %rdx
movq %rax, %rdi
movl $0x15, %esi
callq 0x333ee
leaq 0x2f44d(%rip), %rsi     # 0x5ad70
leaq -0x1d38a(%rip), %rdx    # 0xe5a0
movq %r14, %rdi
callq 0x4540
movq %rax, %rbx
jmp 0x2b942
movq %rax, %rbx
movq %r14, %rdi
callq 0x4250
movq -0x50(%rbp), %rdi
cmpq %r15, %rdi
jne 0x2b958
jmp 0x2b96b
movq %rax, %rbx
jmp 0x2b96b
movq %rax, %rbx
movq %r15, %rdi
callq 0x42b0
jmp 0x2b96b
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x27ca8
movq %rbx, %rdi
callq 0x4560
nop
// File: /workspace/github_cpp_makefile_star2_O3/acliusBackHome[P]kamaya/dist/ParseExpression.cpp
// Function: ParseExpression::~ParseExpression()
ParseExpression::~ParseExpression() {
    if (is_const()) {
        delete (ParseConstant *) const_value;
    }
    switch (expr_type) {
        case E_FUN:
            delete (DecFuncPtrList *) child[0];
            break;
        case E_VAR:
            delete (ParseVariable *) child[0];
            break;
        case E_CONST:
            if (child[0] != const_value) {
                delete (ParseConstant *) child[0];
            }
            break;
        case E_UNDEFINED:
        case E_ADD:
        case E_SUB:
        case E_MUL:
        case E_DIV:
        case E_MOD:
        case E_POW:
        case E_NOT:
        case E_LOGIC_OR:
        case E_LOGIC_AND:
        case E_G:
        case E_GE:
        case E_EQUAL:
        case E_NE:
        case E_L:
        case E_LE:
        case E_ASSIGN:
        case E_GET_ITEM:
        case E_ADR:
        case E_PTR:
        case E_NEG:
        case E_POS:
        case E_BIT_NOT:
            return;

    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
callq 0x2b2f4
testb %al, %al
je 0x2bbcc
movq 0x18(%r14), %rbx
testq %rbx, %rbx
je 0x2bbc4
movq %rbx, %rdi
callq 0x2f204
movq %rbx, %rdi
callq 0x42b0
movl 0x28(%r14), %eax
cmpl $0x1, %eax
je 0x2bc04
cmpl $0x3, %eax
je 0x2bbf6
cmpl $0x2, %eax
jne 0x2bbff
movq (%r14), %rbx
testq %rbx, %rbx
je 0x2bc38
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x2bc38
callq 0x42b0
jmp 0x2bc38
movq (%r14), %rbx
cmpq 0x18(%r14), %rbx
jne 0x2bc2b
popq %rbx
popq %r14
popq %rbp
retq
movq (%r14), %rbx
testq %rbx, %rbx
je 0x2bc38
movq 0x38(%rbx), %rdi
movq %rbx, %rax
addq $0x48, %rax
cmpq %rax, %rdi
je 0x2bc21
callq 0x42b0
movq %rbx, %rdi
callq 0x27ca8
jmp 0x2bc38
testq %rbx, %rbx
je 0x2bc38
movq %rbx, %rdi
callq 0x2f204
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x42b0
movq %rax, %rdi
callq 0xe776
// File: /workspace/github_cpp_makefile_star2_O3/acliusBackHome[P]kamaya/dist/ParseExpression.cpp
// Function: ParseExpression::operator=(ParseVariable const&)
ParseExpression &ParseExpression::operator=(const ParseVariable &variable) {
    if (id2expr.empty()) {
        init();
    }
    expr_type = E_VAR;
    child[0] = (size_t)
            new ParseVariable(variable);
    update(*this);
    return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x3075d(%rip), %rax     # 0x5c3c0
cmpq 0x3075e(%rip), %rax     # 0x5c3c8
jne 0x2bc71
callq 0x2b974
movl $0x1, 0x28(%rbx)
movl $0x68, %edi
callq 0x42e0
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x2e874
movq %r15, (%rbx)
movq %rbx, %rdi
callq 0x2af00
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r15, %rdi
callq 0x42b0
movq %rbx, %rdi
callq 0x4560
// File: /workspace/github_cpp_makefile_star2_O3/acliusBackHome[P]kamaya/dist/ParseExpression.cpp
// Function: ParseExpression::get_id() const
size_t ParseExpression::get_expr_id(const ParseExpression &expr) {
    if (expr.expr_id) {
        return expr.expr_id;
    }
    update(expr);
    return expr.expr_id;
}

// Assembly:
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x2c6d0
retq
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x2af00
movq 0x10(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/acliusBackHome[P]kamaya/dist/ParseExpression.cpp
// Function: ParseExpression::get_const() const
const ParseConstant &ParseExpression::get_const() const {
    ((ParseExpression *) this)->calculate_const();
    if (is_const()) {
        return *(ParseConstant *) const_value;
    }
    string info = "ParseExpression::get_const() expr_id=";
    info += to_string(expr_id);
    throw ParseException(EX_EXPRESSION_NOT_CONST, info);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
callq 0x33a80
movq %rbx, %rdi
callq 0x2b2f4
testb %al, %al
je 0x2cbdc
movq 0x18(%rbx), %rax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq -0x48(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x1998d(%rip), %rsi     # 0x46578
leaq 0x199ab(%rip), %rdx     # 0x4659d
leaq -0x58(%rbp), %rdi
callq 0xf868
movq 0x10(%rbx), %rsi
leaq -0x38(%rbp), %rdi
callq 0xe50f
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
leaq -0x58(%rbp), %rdi
callq 0x4110
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2cc2b
callq 0x42b0
movl $0x28, %edi
callq 0x4190
movq %rax, %r14
leaq -0x58(%rbp), %rdx
movq %rax, %rdi
movl $0xb, %esi
callq 0x333ee
leaq 0x2e120(%rip), %rsi     # 0x5ad70
leaq -0x1e6b7(%rip), %rdx    # 0xe5a0
movq %r14, %rdi
callq 0x4540
jmp 0x2cc85
movq %rax, %rbx
movq %r14, %rdi
callq 0x4250
jmp 0x2cc88
movq %rax, %rbx
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2cc88
callq 0x42b0
jmp 0x2cc88
movq %rax, %rbx
movq -0x58(%rbp), %rdi
cmpq %r15, %rdi
je 0x2cc96
callq 0x42b0
movq %rbx, %rdi
callq 0x4560
// File: /workspace/github_cpp_makefile_star2_O3/acliusBackHome[P]kamaya/dist/ParseExpression.cpp
// Function: ParseExpression::get_variable() const
const ParseVariable &ParseExpression::get_variable() const {
    if (is_variable()) {
        return *(ParseVariable *) child[0];
    }
    string info = "ParseExpression::get_variable() expr_id=";
    info += to_string(expr_id);
    throw ParseException(EX_EXPRESSION_NOT_VARIABLE, info);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
cmpl $0x1, 0x28(%rdi)
jne 0x2ccc2
movq (%rbx), %rax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq -0x48(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x198cd(%rip), %rsi     # 0x4659e
leaq 0x198ee(%rip), %rdx     # 0x465c6
leaq -0x58(%rbp), %rdi
callq 0xf868
movq 0x10(%rbx), %rsi
leaq -0x38(%rbp), %rdi
callq 0xe50f
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
leaq -0x58(%rbp), %rdi
callq 0x4110
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2cd11
callq 0x42b0
movl $0x28, %edi
callq 0x4190
movq %rax, %r14
leaq -0x58(%rbp), %rdx
movq %rax, %rdi
movl $0xc, %esi
callq 0x333ee
leaq 0x2e03a(%rip), %rsi     # 0x5ad70
leaq -0x1e79d(%rip), %rdx    # 0xe5a0
movq %r14, %rdi
callq 0x4540
jmp 0x2cd6b
movq %rax, %rbx
movq %r14, %rdi
callq 0x4250
jmp 0x2cd6e
movq %rax, %rbx
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2cd6e
callq 0x42b0
jmp 0x2cd6e
movq %rax, %rbx
movq -0x58(%rbp), %rdi
cmpq %r15, %rdi
je 0x2cd7c
callq 0x42b0
movq %rbx, %rdi
callq 0x4560
// File: /workspace/github_cpp_makefile_star2_O3/acliusBackHome[P]kamaya/dist/ParseExpression.cpp
// Function: ParseExpression::get_functions() const
const DecFuncPtrList &ParseExpression::get_functions() const {
    if (is_function()) {
        return *(DecFuncPtrList *) child[0];
    }
    string info = "ParseExpression::get_functions() expr_id=";
    info += to_string(expr_id);
    throw ParseException(EX_EXPRESSION_NOT_FUNCTION, info);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
cmpl $0x2, 0x28(%rdi)
jne 0x2cdb6
movq (%rbx), %rax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq -0x48(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x19802(%rip), %rsi     # 0x465c7
leaq 0x19824(%rip), %rdx     # 0x465f0
leaq -0x58(%rbp), %rdi
callq 0xf868
movq 0x10(%rbx), %rsi
leaq -0x38(%rbp), %rdi
callq 0xe50f
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
leaq -0x58(%rbp), %rdi
callq 0x4110
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2ce05
callq 0x42b0
movl $0x28, %edi
callq 0x4190
movq %rax, %r14
leaq -0x58(%rbp), %rdx
movq %rax, %rdi
movl $0xd, %esi
callq 0x333ee
leaq 0x2df46(%rip), %rsi     # 0x5ad70
leaq -0x1e891(%rip), %rdx    # 0xe5a0
movq %r14, %rdi
callq 0x4540
jmp 0x2ce5f
movq %rax, %rbx
movq %r14, %rdi
callq 0x4250
jmp 0x2ce62
movq %rax, %rbx
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2ce62
callq 0x42b0
jmp 0x2ce62
movq %rax, %rbx
movq -0x58(%rbp), %rdi
cmpq %r15, %rdi
je 0x2ce70
callq 0x42b0
movq %rbx, %rdi
callq 0x4560
// File: /workspace/github_cpp_makefile_star2_O3/acliusBackHome[P]kamaya/dist/ParseDeclaration.cpp
// Function: ParseVariable::operator<(ParseVariable const&) const
bool ParseVariable::operator<(const ParseVariable &other) const {
    if (type < other.type) {
        return true;
    } else if (other.type < type) {
        return false;
    }
    if (scope_id < other.scope_id) {
        return true;
    } else if (other.scope_id < scope_id) {
        return false;
    }
    if (address < other.address) {
        return true;
    } else if (other.address < address) {
        return false;
    }
    if (symbol.length() < other.symbol.length()) {
        return true;
    } else if (other.symbol.length() < symbol.length()) {
        return false;
    }
    for (size_t i = 0; i < symbol.length(); ++i) {
        if (symbol[i] < other.symbol[i]) {
            return true;
        } else if (other.symbol[i] < symbol[i]) {
            return false;
        }
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
callq 0x28244
movb $0x1, %bl
testb %al, %al
jne 0x2e7b7
movq %r14, %rdi
movq %r15, %rsi
callq 0x28244
testb %al, %al
je 0x2e7aa
xorl %ebx, %ebx
jmp 0x2e7b7
movq 0x60(%r15), %rax
movq 0x60(%r14), %rcx
cmpq %rcx, %rax
jae 0x2e7c7
andb $0x1, %bl
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
ja 0x2e7a6
movq 0x58(%r15), %rax
movq 0x58(%r14), %rcx
cmpq %rcx, %rax
jb 0x2e7b7
ja 0x2e7a6
movq 0x40(%r15), %rax
movq 0x40(%r14), %rcx
cmpq %rcx, %rax
jb 0x2e7b7
leaq -0x1(%rax), %rdx
cmpq %rcx, %rdx
jae 0x2e7a6
movq 0x38(%r15), %rcx
movq 0x38(%r14), %rdx
movb (%rcx), %sil
movb (%rdx), %r8b
cmpb %r8b, %sil
jl 0x2e7b7
movb $0x1, %bl
movl $0x1, %edi
cmpb %sil, %r8b
jl 0x2e829
cmpq %rax, %rdi
setb %bl
je 0x2e82d
movb (%rcx,%rdi), %sil
movb (%rdx,%rdi), %r8b
incq %rdi
cmpb %r8b, %sil
jge 0x2e808
movb $0x1, %al
jmp 0x2e82d
xorl %eax, %eax
jmp 0x2e82d
andb %al, %bl
jmp 0x2e7b7
nop
// File: /workspace/github_cpp_makefile_star2_O3/acliusBackHome[P]kamaya/dist/ParseDeclaration.cpp
// Function: ParseVariable::operator=(ParseVariable const&)
ParseVariable &ParseVariable::operator=(const ParseVariable &other) {
    type = other.type;
    address = other.address;
    symbol = other.symbol;
    scope_id = other.scope_id;
    return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x27c6c
movq 0x58(%rbx), %rax
movq %rax, 0x58(%r14)
leaq 0x38(%rbx), %rsi
leaq 0x38(%r14), %rdi
callq 0x41b0
movq 0x60(%rbx), %rax
movq %rax, 0x60(%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/acliusBackHome[P]kamaya/dist/ParseDeclaration.cpp
// Function: ParseConstant::assign(ParseConstant&, ParseConstant const&)
void ParseConstant::assign(ParseConstant &constant, const ParseConstant &from_constant) {
    constant.type = from_constant.type;
    switch (constant.type) {
        case C_STRING:
            constant.value = (size_t) new string(*(string *) from_constant.value);
            break;
        case C_SIGNED:
            constant.value = (size_t) new long long(*(long long *) from_constant.value);
            break;
        case C_UNSIGNED:
            constant.value = (size_t) new unsigned long long(*(unsigned long long *) from_constant.value);
            break;
        case C_FLOAT:
            constant.value = (size_t) new long double(*(long double *) from_constant.value);
            break;
        case C_BOOL:
            constant.value = (size_t) new bool(*(bool *) from_constant.value);
            break;
        case C_UNDEFINED:
            constant.value = 0;
            break;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl (%rsi), %eax
movl %eax, (%rdi)
cmpq $0x5, %rax
ja 0x2eeb6
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x178a3(%rip), %rcx     # 0x466d4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x8, %edi
callq 0x42e0
movq %rax, %r14
movq 0x8(%r15), %rax
movq (%rax), %rax
movq %rax, (%r14)
jmp 0x2eeb2
movl $0x1, %edi
callq 0x42e0
movq %rax, %r14
movq 0x8(%r15), %rax
movb (%rax), %al
movb %al, (%r14)
jmp 0x2eeb2
movl $0x20, %edi
callq 0x42e0
movq %rax, %r14
movq 0x8(%r15), %rax
leaq 0x10(%r14), %rcx
movq %rcx, (%r14)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %r14, %rdi
callq 0xf7ca
jmp 0x2eeb2
movl $0x10, %edi
callq 0x42e0
movq %rax, %r14
movq 0x8(%r15), %rax
fldt (%rax)
fstpt (%r14)
jmp 0x2eeb2
xorl %r14d, %r14d
movq %r14, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x42b0
movq %rbx, %rdi
callq 0x4560
// File: /workspace/github_cpp_makefile_star2_O3/acliusBackHome[P]kamaya/dist/ParseDeclaration.cpp
// Function: ParseConstant::get_signed() const
long long ParseConstant::get_signed() const {
    switch (type) {
        case C_SIGNED:
            return *(long long *) value;
        case C_UNSIGNED:
            return *(unsigned long long *) value;
        case C_FLOAT:
            return (long long) *(long double *) value;
        case C_BOOL:
            return (long long) *(bool *) value;
        case C_STRING:
        case C_UNDEFINED:
            break;
    }
    printf("ParseConstant::get_signed(): 警告 : 试图获取非法常量值\n");
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl (%rdi), %eax
decl %eax
cmpl $0x3, %eax
ja 0x2f038
leaq 0x176f4(%rip), %rcx     # 0x466ec
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rdi), %rax
movq (%rax), %rax
jmp 0x2f046
movq 0x8(%rdi), %rax
fldt (%rax)
fnstcw -0x2(%rbp)
movzwl -0x2(%rbp), %eax
orl $0xc00, %eax            # imm = 0xC00
movw %ax, -0x4(%rbp)
fldcw -0x4(%rbp)
fistpll -0x10(%rbp)
fldcw -0x2(%rbp)
movq -0x10(%rbp), %rax
jmp 0x2f046
movq 0x8(%rdi), %rax
movzbl (%rax), %eax
jmp 0x2f046
leaq 0x17dd1(%rip), %rdi     # 0x46e10
callq 0x4480
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/acliusBackHome[P]kamaya/dist/ParseDeclaration.cpp
// Function: ParseConstant::get_unsigned() const
unsigned long long ParseConstant::get_unsigned() const {
    switch (type) {
        case C_SIGNED:
            return (unsigned long long) *(long long *) value;
        case C_UNSIGNED:
            return *(unsigned long long *) value;
        case C_FLOAT:
            return (unsigned long long) *(long double *) value;
        case C_BOOL:
            return (unsigned long long) *(bool *) value;
        case C_STRING:
        case C_UNDEFINED:
            break;
    }
    printf("ParseConstant::get_unsigned(): 警告 : 试图获取非法常量值\n");
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl (%rdi), %eax
decl %eax
cmpl $0x3, %eax
ja 0x2f0be
leaq 0x17698(%rip), %rcx     # 0x466fc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rdi), %rax
movq (%rax), %rax
jmp 0x2f0cc
movq 0x8(%rdi), %rax
fldt (%rax)
flds 0x17746(%rip)           # 0x467c8
xorl %eax, %eax
fucomi %st(1), %st
setbe %al
fldz
fcmovbe %st(1), %st
fstp %st(1)
fsubrp %st, %st(1)
fnstcw -0x2(%rbp)
movzwl -0x2(%rbp), %ecx
orl $0xc00, %ecx            # imm = 0xC00
movw %cx, -0x4(%rbp)
fldcw -0x4(%rbp)
fistpll -0x10(%rbp)
fldcw -0x2(%rbp)
shlq $0x3f, %rax
xorq -0x10(%rbp), %rax
jmp 0x2f0cc
movq 0x8(%rdi), %rax
movzbl (%rax), %eax
jmp 0x2f0cc
leaq 0x17d8d(%rip), %rdi     # 0x46e52
callq 0x4480
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/acliusBackHome[P]kamaya/dist/ParseDeclaration.cpp
// Function: ParseConstant::get_float() const
long double ParseConstant::get_float() const {
    switch (type) {
        case C_SIGNED:
            return *(long long *) value;
        case C_UNSIGNED:
            return *(unsigned long long *) value;
        case C_FLOAT:
            return *(long double *) value;
        case C_BOOL:
            return (long double) *(bool *) value;
        case C_STRING:
        case C_UNDEFINED:
            break;
    }
    printf("ParseConstant::get_float(): 警告 : 试图获取非法常量值\n");
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl (%rdi), %eax
decl %eax
cmpl $0x3, %eax
ja 0x2f13d
leaq 0x17622(%rip), %rcx     # 0x4670c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rdi), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
fildll -0x10(%rbp)
jmp 0x2f14b
movq 0x8(%rdi), %rax
fldt (%rax)
jmp 0x2f14b
movq 0x8(%rdi), %rax
movsbl (%rax), %eax
movw %ax, -0x2(%rbp)
filds -0x2(%rbp)
jmp 0x2f14b
movq 0x8(%rdi), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
xorl %ecx, %ecx
testq %rax, %rax
sets %cl
fildll -0x18(%rbp)
leaq 0x17698(%rip), %rax     # 0x467d0
fadds (%rax,%rcx,4)
jmp 0x2f14b
leaq 0x17d52(%rip), %rdi     # 0x46e96
callq 0x4480
fldz
addq $0x20, %rsp
popq %rbp
retq
nop