From 09743a3fc02e621daaddd60569a6595af1341590 Mon Sep 17 00:00:00 2001 From: "yu.dongliang" <18588496441@163.com> Date: Sun, 14 May 2023 17:24:15 +0800 Subject: [PATCH] support arm32: 'hanoi.c' and 'hello.c' of 'scf/examples' test ok --- elf/scf_dwarf_info.c | 15 + elf/scf_dwarf_line.c | 2 + elf/scf_elf.c | 2 + elf/scf_elf_arm32.c | 463 +++++++ elf/scf_elf_arm32.h | 20 + elf/scf_elf_arm32_so.c | 894 +++++++++++++ elf/scf_elf_link.c | 94 +- elf/scf_elf_native.h | 3 + elf/scf_elf_native32.c | 1098 ++++++++++++++++ elf/scf_elf_native32.h | 154 +++ lib/arm32/_start.o | Bin 0 -> 684 bytes lib/arm32/_start.s | 8 + lib/arm32/lib/ld-linux-armhf.so.3 | Bin 0 -> 110012 bytes lib/arm32/libc.so.6 | Bin 0 -> 971712 bytes native/risc/scf_arm32.c | 1954 +++++++++++++++++++++++++++++ native/risc/scf_arm64.c | 19 +- native/risc/scf_naja.c | 33 +- native/risc/scf_risc.c | 34 +- native/risc/scf_risc.h | 2 +- native/risc/scf_risc_bb_color.c | 2 - native/risc/scf_risc_graph.c | 30 +- native/risc/scf_risc_inst.c | 147 ++- native/risc/scf_risc_rcg.c | 34 +- native/risc/scf_risc_reg.c | 28 +- native/risc/scf_risc_reg.h | 154 +-- native/risc/scf_risc_reg_arm32.c | 937 ++++++++++++++ native/risc/scf_risc_reg_arm64.c | 122 +- native/risc/scf_risc_util.h | 4 +- native/scf_native.h | 124 +- parse/Makefile | 5 + parse/main.c | 14 + parse/scf_parse2.c | 37 +- vm/Makefile | 3 + 33 files changed, 6048 insertions(+), 388 deletions(-) create mode 100644 elf/scf_elf_arm32.c create mode 100644 elf/scf_elf_arm32.h create mode 100644 elf/scf_elf_arm32_so.c create mode 100644 elf/scf_elf_native32.c create mode 100644 elf/scf_elf_native32.h create mode 100644 lib/arm32/_start.o create mode 100644 lib/arm32/_start.s create mode 100755 lib/arm32/lib/ld-linux-armhf.so.3 create mode 100755 lib/arm32/libc.so.6 create mode 100644 native/risc/scf_arm32.c create mode 100644 native/risc/scf_risc_reg_arm32.c diff --git a/elf/scf_dwarf_info.c b/elf/scf_dwarf_info.c index 818f878..b270d16 100644 --- a/elf/scf_dwarf_info.c +++ b/elf/scf_dwarf_info.c @@ -330,6 +330,21 @@ static int _add_rela_common(scf_dwarf_debug_t* debug, const char* sym, uint64_t return -EINVAL; break; }; + + } else if (!strcmp(debug->arch, "arm32")) { + + switch (type) { + + case R_X86_64_32: + case R_X86_64_64: + rela->type = R_ARM_ABS32; + break; + + default: + scf_loge("\n"); + return -EINVAL; + break; + }; } return 0; diff --git a/elf/scf_dwarf_line.c b/elf/scf_dwarf_line.c index ac44410..0bd4fb3 100644 --- a/elf/scf_dwarf_line.c +++ b/elf/scf_dwarf_line.c @@ -683,6 +683,8 @@ int scf_dwarf_line_encode(scf_dwarf_debug_t* debug, scf_dwarf_line_machine_t* lm if (!strcmp(debug->arch, "arm64") || !strcmp(debug->arch, "naja")) rela->type = R_AARCH64_ABS64; + else if (!strcmp(debug->arch, "arm32")) + rela->type = R_ARM_ABS32; DWARF_DEBUG_LINE_FILL (lm->address); } diff --git a/elf/scf_elf.c b/elf/scf_elf.c index 60a4ef4..1764f53 100644 --- a/elf/scf_elf.c +++ b/elf/scf_elf.c @@ -2,12 +2,14 @@ extern scf_elf_ops_t elf_ops_x64; extern scf_elf_ops_t elf_ops_arm64; +extern scf_elf_ops_t elf_ops_arm32; extern scf_elf_ops_t elf_ops_naja; scf_elf_ops_t* elf_ops_array[] = { &elf_ops_x64, &elf_ops_arm64, + &elf_ops_arm32, &elf_ops_naja, NULL, diff --git a/elf/scf_elf_arm32.c b/elf/scf_elf_arm32.c new file mode 100644 index 0000000..cdedc55 --- /dev/null +++ b/elf/scf_elf_arm32.c @@ -0,0 +1,463 @@ +#include"scf_elf_arm32.h" +#include"scf_elf_link.h" + +static int _arm32_elf_write_rel(scf_elf_context_t* elf) +{ + return elf32_write_rel(elf, EM_ARM); +} + +static int _arm32_elf_link_cs(elf_native_t* arm32, elf_section_t* s, elf_section_t* rs, uint64_t cs_base) +{ + elf_sym_t* sym; + Elf32_Rela* rela; + + assert(rs->data_len % sizeof(Elf32_Rela) == 0); + + int i; + for (i = 0; i < rs->data_len; i += sizeof(Elf32_Rela)) { + + rela = (Elf32_Rela* )(rs->data + i); + sym = NULL; + + int sym_idx = ELF32_R_SYM(rela->r_info); + + scf_loge("i: %d, sym_idx '%d'\n", i, sym_idx); + + assert(sym_idx >= 1); + assert(sym_idx - 1 < arm32->symbols->size); + + sym = arm32->symbols->data[sym_idx - 1]; + if (sym->dyn_flag) { + scf_loge("sym '%s' in dynamic so\n", sym->name->data); + continue; + } + + int j = elf32_find_sym(&sym, rela, arm32->symbols); + if (j < 0) + return -1; + + int32_t offset = sym->sym.st_value - (cs_base + rela->r_offset) + rela->r_addend; + + rela->r_info = ELF32_R_INFO(j, ELF32_R_TYPE(rela->r_info)); + + switch (ELF32_R_TYPE(rela->r_info)) { + + case R_ARM_CALL: + + offset -= 8; // 'pc' is 'current + 8'. + assert(0 == (offset & 0x3)); + + scf_loge("sym: %s, offset: %#x, %#x\n", sym->name->data, offset, rela->r_offset); + offset >>= 2; + + if (offset > 0x7fffff || offset < -0x7fffff) { + scf_loge("\n"); + return -EINVAL; + } + + scf_loge("sym: %s, offset: %#x, %#x\n", sym->name->data, offset, rela->r_offset); + + *(uint32_t*)(s->data + rela->r_offset) &= 0xff000000; + *(uint32_t*)(s->data + rela->r_offset) |= 0x00ffffff & offset; + break; + + case R_ARM_REL32: + scf_loge("sym: %s, offset: %#x, %#x, st_value: %#x, cs: %#lx\n", sym->name->data, offset, rela->r_offset, + sym->sym.st_value, cs_base + rela->r_offset); + + *(uint32_t*)(s->data + rela->r_offset) += offset; + break; + default: + scf_loge("ELF32_R_TYPE(rela->r_info): %d\n", ELF32_R_TYPE(rela->r_info)); + return -EINVAL; + break; + }; + } + + return 0; +} + +static int _arm32_elf_link_ds(elf_native_t* arm32, elf_section_t* s, elf_section_t* rs) +{ + elf_sym_t* sym; + Elf32_Rela* rela; + + assert(rs->data_len % sizeof(Elf32_Rela) == 0); + + int i; + for (i = 0; i < rs->data_len; i += sizeof(Elf32_Rela)) { + + rela = (Elf32_Rela* )(rs->data + i); + sym = NULL; + + int j = elf32_find_sym(&sym, rela, arm32->symbols); + if (j < 0) + return -1; + + assert(ELF32_R_TYPE(rela->r_info) == R_ARM_ABS32); + + uint64_t offset = sym->sym.st_value + rela->r_addend; + + rela->r_info = ELF32_R_INFO(j, ELF32_R_TYPE(rela->r_info)); + + switch (ELF32_R_TYPE(rela->r_info)) { + + case R_ARM_ABS32: + memcpy(s->data + rela->r_offset, &offset, 4); + break; + default: + scf_loge("\n"); + return -EINVAL; + break; + }; + } + + return 0; +} + +static int _arm32_elf_link_debug(elf_native_t* arm32, elf_section_t* s, elf_section_t* rs) +{ + elf_sym_t* sym; + elf_sym_t* sym2; + Elf32_Rela* rela; + + assert(rs->data_len % sizeof(Elf32_Rela) == 0); + + int i; + for (i = 0; i < rs->data_len; i += sizeof(Elf32_Rela)) { + + rela = (Elf32_Rela* )(rs->data + i); + sym = NULL; + + int j = elf32_find_sym(&sym, rela, arm32->symbols); + if (j < 0) + return -1; + + uint64_t offset = sym->sym.st_value + rela->r_addend; + + if (!strncmp(sym->name->data, ".debug_", 7)) { + + int k = ELF32_R_SYM(rela->r_info); + + sym2 = arm32->symbols->data[k - 1]; + + offset = sym2->sym.st_value + rela->r_addend; + rela->r_addend = offset; + + } else if (!strcmp(sym->name->data, ".text")) { + + int k = ELF32_R_SYM(rela->r_info); + + sym2 = arm32->symbols->data[k - 1]; + + offset = sym2->sym.st_value; + rela->r_addend = sym2->sym.st_value - sym->sym.st_value; + } + + rela->r_info = ELF32_R_INFO(j, ELF32_R_TYPE(rela->r_info)); + + switch (ELF32_R_TYPE(rela->r_info)) { + + case R_ARM_ABS32: + memcpy(s->data + rela->r_offset, &offset, 4); + break; + default: + scf_loge("\n"); + return -EINVAL; + break; + }; + } + + return 0; +} + +static int _arm32_elf_link_sections(elf_native_t* arm32, uint32_t cs_index, uint32_t ds_index) +{ + elf_section_t* s; + elf_section_t* rs; + + int i; + for (i = 0; i < arm32->sections->size; i++) { + rs = arm32->sections->data[i]; + + if (SHT_RELA != rs->sh.sh_type) + continue; + + assert(rs->sh.sh_info < arm32->sections->size); + + if (cs_index == rs->sh.sh_info + || ds_index == rs->sh.sh_info) + continue; + + if (!strcmp(rs->name->data, ".rela.plt")) + continue; + + s = arm32->sections->data[rs->sh.sh_info - 1]; + + scf_loge("s: %s, rs: %s, rs->sh.sh_info: %u\n", s->name->data, rs->name->data, rs->sh.sh_info); + + assert(!strcmp(s->name->data, rs->name->data + 5)); + + if (_arm32_elf_link_debug(arm32, s, rs) < 0) { + scf_loge("\n"); + return -1; + } + } + + return 0; +} + +static int _arm32_elf_write_exec(scf_elf_context_t* elf) +{ + elf_native_t* arm32 = elf->priv; + int nb_phdrs = 3; + + if (arm32->dynsyms && arm32->dynsyms->size) { + __arm32_elf_add_dyn(arm32); + nb_phdrs = 6; + } + + int nb_sections = 1 + arm32->sections->size + 1 + 1 + 1; + uint64_t shstrtab_offset = 1; + uint64_t strtab_offset = 1; + uint64_t dynstr_offset = 1; + Elf32_Off phdr_offset = sizeof(arm32->eh) + sizeof(Elf32_Shdr) * nb_sections; + Elf32_Off section_offset = phdr_offset + sizeof(Elf32_Phdr) * nb_phdrs; + + elf_section_t* s; + elf_section_t* cs = NULL; + elf_section_t* ros = NULL; + elf_section_t* ds = NULL; + elf_section_t* crela = NULL; + elf_section_t* drela = NULL; + elf_sym_t* sym; + + int i; + for (i = 0; i < arm32->sections->size; i++) { + s = arm32->sections->data[i]; + + scf_logw("i: %d, section: %s\n", i, s->name->data); + + if (!strcmp(".text", s->name->data)) { + + assert(s->data_len > 0); + assert(!cs); + cs = s; + + } else if (!strcmp(".rodata", s->name->data)) { + + assert(s->data_len >= 0); + assert(!ros); + ros = s; + + } else if (!strcmp(".data", s->name->data)) { + + assert(s->data_len >= 0); + assert(!ds); + ds = s; + + } else if (!strcmp(".rela.text", s->name->data)) { + + assert(!crela); + crela = s; + scf_loge("i: %d, section: %s\n", i, s->name->data); + + } else if (!strcmp(".rela.data", s->name->data)) { + + assert(!drela); + drela = s; + } + + s->offset = section_offset; + section_offset += s->data_len; + } + assert(crela); + + uint64_t cs_align = (cs ->offset + cs ->data_len + 0x200000 - 1) >> 21 << 21; + uint64_t ro_align = (ros->offset + ros->data_len + 0x200000 - 1) >> 21 << 21; + + uint64_t rx_base = 0x400000; + uint64_t r_base = 0x400000 + cs_align; + uint64_t rw_base = 0x400000 + cs_align + ro_align; + + uint64_t cs_base = cs->offset + rx_base; + uint64_t ro_base = ros->offset + r_base; + uint64_t ds_base = ds->offset + rw_base; + uint64_t _start = 0; + + for (i = 0; i < arm32->symbols->size; i++) { + sym = arm32->symbols->data[i]; + + uint32_t shndx = sym->sym.st_shndx; + + if (shndx == cs->index) + sym->sym.st_value += cs_base; + + else if (shndx == ros->index) + sym->sym.st_value += ro_base; + + else if (shndx == ds->index) + sym->sym.st_value += ds_base; + + scf_logd("sym: %s, %#lx, st_shndx: %d\n", sym->name->data, sym->sym.st_value, sym->sym.st_shndx); + } + + int ret = _arm32_elf_link_cs(arm32, cs, crela, cs_base); + if (ret < 0) { + scf_loge("ret: %d\n", ret); + return ret; + } + + if (drela) { + ret = _arm32_elf_link_ds(arm32, ds, drela); + if (ret < 0) + return ret; + } + + ret = _arm32_elf_link_sections(arm32, cs->index, ds->index); + if (ret < 0) + return ret; + + elf32_process_syms(arm32, cs->index); + + cs ->sh.sh_addr = cs_base; + ds ->sh.sh_addr = ds_base; + ros->sh.sh_addr = ro_base; + + if (6 == nb_phdrs) + __arm32_elf_post_dyn(arm32, rx_base, rw_base, cs); + + for (i = 0; i < arm32->symbols->size; i++) { + sym = arm32->symbols->data[i]; + + if (!strcmp(sym->name->data, "_start")) { + + if (0 != _start) { + scf_loge("\n"); + return -EINVAL; + } + + _start = sym->sym.st_value; + break; + } + } + + // write elf header + elf_header(&arm32->eh, ET_EXEC, EM_ARM, _start, phdr_offset, nb_phdrs, nb_sections, nb_sections - 1); + fwrite(&arm32->eh, sizeof(arm32->eh), 1, elf->fp); + + // write null section header + fwrite(&arm32->sh_null, sizeof(arm32->sh_null), 1, elf->fp); + + // write user's section header + section_offset = phdr_offset + sizeof(Elf32_Phdr) * nb_phdrs; + + for (i = 0; i < arm32->sections->size; i++) { + s = arm32->sections->data[i]; + + if (SHT_RELA == s->sh.sh_type && 0 == s->sh.sh_link) + s->sh.sh_link = nb_sections - 3; + + section_header(&s->sh, shstrtab_offset, s->sh.sh_addr, + section_offset, s->data_len, + s->sh.sh_link, s->sh.sh_info, s->sh.sh_entsize); + + if (SHT_STRTAB != s->sh.sh_type) + s->sh.sh_addralign = 4; + + section_offset += s->data_len; + shstrtab_offset += s->name->len + 1; + + fwrite(&s->sh, sizeof(s->sh), 1, elf->fp); + } + + // set user's symbols' name + int nb_local_syms = 1; + + for (i = 0; i < arm32->symbols->size; i++) { + sym = arm32->symbols->data[i]; + + if (sym->name) { + sym->sym.st_name = strtab_offset; + strtab_offset += sym->name->len + 1; + } else + sym->sym.st_name = 0; + + if (STB_LOCAL == ELF32_ST_BIND(sym->sym.st_info)) + nb_local_syms++; + } + + // write symtab section header + section_header(&arm32->sh_symtab, shstrtab_offset, 0, + section_offset, (arm32->symbols->size + 1) * sizeof(Elf32_Sym), + nb_sections - 2, nb_local_syms, sizeof(Elf32_Sym)); + + fwrite(&arm32->sh_symtab, sizeof(arm32->sh_symtab), 1, elf->fp); + + section_offset += (arm32->symbols->size + 1) * sizeof(Elf32_Sym); + shstrtab_offset += strlen(".symtab") + 1; + + // write strtab section header + section_header(&arm32->sh_strtab, shstrtab_offset, 0, + section_offset, strtab_offset, + 0, 0, 0); + fwrite(&arm32->sh_strtab, sizeof(arm32->sh_strtab), 1, elf->fp); + section_offset += strtab_offset; + shstrtab_offset += strlen(".strtab") + 1; + + // write shstrtab section header + uint64_t shstrtab_len = shstrtab_offset + strlen(".shstrtab") + 1; + section_header(&arm32->sh_shstrtab, shstrtab_offset, 0, + section_offset, shstrtab_len, 0, 0, 0); + fwrite(&arm32->sh_shstrtab, sizeof(arm32->sh_shstrtab), 1, elf->fp); + +#if 1 + if (6 == nb_phdrs) { + __arm32_elf_write_phdr(elf, rx_base, phdr_offset, nb_phdrs); + + __arm32_elf_write_interp(elf, rx_base, arm32->interp->offset, arm32->interp->data_len); + } + + __arm32_elf_write_text (elf, rx_base, 0, cs->offset + cs->data_len); + __arm32_elf_write_rodata(elf, r_base, ros->offset, ros->data_len); + + if (6 == nb_phdrs) { + __arm32_elf_write_data(elf, rw_base, arm32->dynamic->offset, + arm32->dynamic->data_len + arm32->got_plt->data_len + ds->data_len); + + __arm32_elf_write_dynamic(elf, rw_base, arm32->dynamic->offset, arm32->dynamic->data_len); + } else { + __arm32_elf_write_data(elf, rw_base, ds->offset, ds->data_len); + } +#endif + + elf32_write_sections(elf); + elf32_write_symtab (elf); + elf32_write_strtab (elf); + elf32_write_shstrtab(elf); + return 0; +} + +scf_elf_ops_t elf_ops_arm32 = +{ + .machine = "arm32", + + .open = elf32_open, + .close = elf32_close, + + .add_sym = elf32_add_sym, + .add_section = elf32_add_section, + + .add_rela_section = elf32_add_rela_section, + + .add_dyn_need = elf32_add_dyn_need, + .add_dyn_rela = elf32_add_dyn_rela, + + .read_syms = elf32_read_syms, + .read_relas = elf32_read_relas, + .read_section = elf32_read_section, + + .write_rel = _arm32_elf_write_rel, + .write_exec = _arm32_elf_write_exec, +}; + diff --git a/elf/scf_elf_arm32.h b/elf/scf_elf_arm32.h new file mode 100644 index 0000000..bc606f3 --- /dev/null +++ b/elf/scf_elf_arm32.h @@ -0,0 +1,20 @@ +#ifndef SCF_ELF_ARM32_H +#define SCF_ELF_ARM32_H + +#include"scf_elf.h" +#include"scf_elf_native32.h" +#include"scf_vector.h" +#include"scf_string.h" + +int __arm32_elf_add_dyn (elf_native_t* arm32); +int __arm32_elf_post_dyn(elf_native_t* arm32, uint64_t rx_base, uint64_t rw_base, elf_section_t* cs); + +int __arm32_elf_write_phdr (scf_elf_context_t* elf, uint64_t rx_base, uint64_t offset, uint32_t nb_phdrs); +int __arm32_elf_write_interp (scf_elf_context_t* elf, uint64_t rx_base, uint64_t offset, uint64_t len); +int __arm32_elf_write_text (scf_elf_context_t* elf, uint64_t rx_base, uint64_t offset, uint64_t len); +int __arm32_elf_write_rodata (scf_elf_context_t* elf, uint64_t r_base, uint64_t offset, uint64_t len); +int __arm32_elf_write_data (scf_elf_context_t* elf, uint64_t rw_base, uint64_t offset, uint64_t len); +int __arm32_elf_write_dynamic(scf_elf_context_t* elf, uint64_t rw_base, uint64_t offset, uint64_t len); + +#endif + diff --git a/elf/scf_elf_arm32_so.c b/elf/scf_elf_arm32_so.c new file mode 100644 index 0000000..60f078b --- /dev/null +++ b/elf/scf_elf_arm32_so.c @@ -0,0 +1,894 @@ +#include"scf_elf_arm32.h" +#include"scf_elf_link.h" + +static uint32_t arm32_plt_lazy[5] = { + 0xe52de004, // push {lr} + 0xe59fe004, // ldr lr, [pc, #4] + 0xe08fe00e, // add lr, pc, lr + 0xe5bef008, // ldr pc, [lr, #8]! + + 0x00000000, // +}; + +static uint32_t arm32_plt[3] = { + 0xe28fc600, // add r12, pc, #0, 12 + 0xe28cca00, // add r12, r12, #16, 20 + 0xe5bcf000, // ldr pc, [r12, #0]! +}; + + +static uint32_t _arm32_elf_hash(const uint8_t* p) +{ + uint32_t k = 0; + uint32_t u = 0; + + while (*p) { + k = (k << 4) + *p++; + u = k & 0xf0000000; + + if (u) + k ^= u >> 24; + k &= ~u; + } + return k; +} + +static int _arm32_elf_add_interp(elf_native_t* arm32, elf_section_t** ps) +{ + elf_section_t* s; + + s = calloc(1, sizeof(elf_section_t)); + if (!s) + return -ENOMEM; + + s->name = scf_string_cstr(".interp"); + if (!s->name) { + free(s); + return -ENOMEM; + } + + char* interp = "/lib/ld-linux-armhf.so.3"; + size_t len = strlen(interp); + size_t align = (len + 1 + 7) & ~0x7; + + s->data = calloc(1, align); + if (!s->data) { + scf_string_free(s->name); + free(s); + return -ENOMEM; + } + memcpy(s->data, interp, len); + s->data_len = align; + + s->index = 1; + + s->sh.sh_type = SHT_PROGBITS; + s->sh.sh_flags = SHF_ALLOC; + s->sh.sh_addralign = 1; + + int ret = scf_vector_add(arm32->sections, s); + if (ret < 0) { + scf_string_free(s->name); + free(s->data); + free(s); + return -ENOMEM; + } + + *ps = s; + return 0; +} + +static int _arm32_elf_add_gnu_version(elf_native_t* arm32, elf_section_t** ps) +{ + elf_section_t* s; + + s = calloc(1, sizeof(elf_section_t)); + if (!s) + return -ENOMEM; + + s->name = scf_string_cstr(".gnu.version"); + if (!s->name) { + free(s); + return -ENOMEM; + } + + s->data = calloc(arm32->dynsyms->size, sizeof(Elf32_Versym)); + if (!s->data) { + scf_string_free(s->name); + free(s); + return -ENOMEM; + } + s->data_len = arm32->dynsyms->size * sizeof(Elf32_Versym); + + s->index = 1; + + s->sh.sh_type = SHT_GNU_versym; + s->sh.sh_flags = SHF_ALLOC; + s->sh.sh_addralign = 4; + + int ret = scf_vector_add(arm32->sections, s); + if (ret < 0) { + scf_string_free(s->name); + free(s->data); + free(s); + return -ENOMEM; + } + + *ps = s; + return 0; +} + +static int _arm32_elf_add_gnu_version_r(elf_native_t* arm32, elf_section_t** ps) +{ + elf_section_t* s; + + s = calloc(1, sizeof(elf_section_t)); + if (!s) + return -ENOMEM; + + s->name = scf_string_cstr(".gnu.version_r"); + if (!s->name) { + free(s); + return -ENOMEM; + } + + s->data = calloc(1, sizeof(Elf32_Verneed) + sizeof(Elf32_Vernaux)); + if (!s->data) { + scf_string_free(s->name); + free(s); + return -ENOMEM; + } + s->data_len = sizeof(Elf32_Verneed) + sizeof(Elf32_Vernaux); + + s->index = 1; + + s->sh.sh_type = SHT_GNU_verneed; + s->sh.sh_flags = SHF_ALLOC; + s->sh.sh_addralign = 4; + + int ret = scf_vector_add(arm32->sections, s); + if (ret < 0) { + scf_string_free(s->name); + free(s->data); + free(s); + return -ENOMEM; + } + + *ps = s; + return 0; +} + +static int _arm32_elf_add_dynsym(elf_native_t* arm32, elf_section_t** ps) +{ + elf_section_t* s; + + s = calloc(1, sizeof(elf_section_t)); + if (!s) + return -ENOMEM; + + s->name = scf_string_cstr(".dynsym"); + if (!s->name) { + free(s); + return -ENOMEM; + } + + s->data = calloc(arm32->dynsyms->size + 1, sizeof(Elf32_Sym)); + if (!s->data) { + scf_string_free(s->name); + free(s); + return -ENOMEM; + } + s->data_len = (arm32->dynsyms->size + 1) * sizeof(Elf32_Sym); + + s->index = 1; + + s->sh.sh_type = SHT_DYNSYM; + s->sh.sh_flags = SHF_ALLOC; + s->sh.sh_info = 1; + s->sh.sh_addralign = 4; + s->sh.sh_entsize = sizeof(Elf32_Sym); + + int ret = scf_vector_add(arm32->sections, s); + if (ret < 0) { + scf_string_free(s->name); + free(s->data); + free(s); + return -ENOMEM; + } + + *ps = s; + return 0; +} + +static int _arm32_elf_add_dynstr(elf_native_t* arm32, elf_section_t** ps) +{ + elf_section_t* s; + + s = calloc(1, sizeof(elf_section_t)); + if (!s) + return -ENOMEM; + + s->name = scf_string_cstr(".dynstr"); + if (!s->name) { + free(s); + return -ENOMEM; + } + + s->index = 1; + + s->sh.sh_type = SHT_STRTAB; + s->sh.sh_flags = SHF_ALLOC; + s->sh.sh_addralign = 1; + + int ret = scf_vector_add(arm32->sections, s); + if (ret < 0) { + scf_string_free(s->name); + free(s->data); + free(s); + return -ENOMEM; + } + + *ps = s; + return 0; +} + +static int _arm32_elf_add_dynamic(elf_native_t* arm32, elf_section_t** ps) +{ + elf_section_t* s; + + s = calloc(1, sizeof(elf_section_t)); + if (!s) + return -ENOMEM; + + s->name = scf_string_cstr(".dynamic"); + if (!s->name) { + free(s); + return -ENOMEM; + } + + int nb_tags = arm32->dyn_needs->size + 11 + 1; + + s->data = calloc(nb_tags, sizeof(Elf32_Dyn)); + if (!s->data) { + scf_string_free(s->name); + free(s); + return -ENOMEM; + } + s->data_len = nb_tags * sizeof(Elf32_Dyn); + + scf_logw("nb_tags: %d\n", nb_tags); + + s->index = 1; + + s->sh.sh_type = SHT_PROGBITS; + s->sh.sh_flags = SHF_ALLOC | SHF_WRITE; + s->sh.sh_addralign = 4; + s->sh.sh_entsize = sizeof(Elf32_Dyn); + + int ret = scf_vector_add(arm32->sections, s); + if (ret < 0) { + scf_string_free(s->name); + free(s->data); + free(s); + return -ENOMEM; + } + + *ps = s; + return 0; +} + +static int _arm32_elf_add_got_plt(elf_native_t* arm32, elf_section_t** ps) +{ + elf_section_t* s; + + s = calloc(1, sizeof(elf_section_t)); + if (!s) + return -ENOMEM; + + s->name = scf_string_cstr(".got.plt"); + if (!s->name) { + free(s); + return -ENOMEM; + } + + s->data = calloc(arm32->dynsyms->size + 4, sizeof(uint32_t)); + if (!s->data) { + scf_string_free(s->name); + free(s); + return -ENOMEM; + } + s->data_len = (arm32->dynsyms->size + 4) * sizeof(uint32_t); + + s->index = 1; + + s->sh.sh_type = SHT_PROGBITS; + s->sh.sh_flags = SHF_ALLOC | SHF_WRITE; + s->sh.sh_addralign = 4; + + int ret = scf_vector_add(arm32->sections, s); + if (ret < 0) { + scf_string_free(s->name); + free(s->data); + free(s); + return -ENOMEM; + } + + *ps = s; + return 0; +} + +static int _arm32_elf_add_rela_plt(elf_native_t* arm32, elf_section_t** ps) +{ + elf_section_t* s; + + s = calloc(1, sizeof(elf_section_t)); + if (!s) + return -ENOMEM; + + s->name = scf_string_cstr(".rela.plt"); + if (!s->name) { + free(s); + return -ENOMEM; + } + + s->data = calloc(arm32->dynsyms->size, sizeof(Elf32_Rela)); + if (!s->data) { + scf_string_free(s->name); + free(s); + return -ENOMEM; + } + s->data_len = arm32->dynsyms->size * sizeof(Elf32_Rela); + + s->index = 1; + + s->sh.sh_type = SHT_RELA; + s->sh.sh_flags = SHF_ALLOC | SHF_INFO_LINK; + s->sh.sh_addralign = 4; + s->sh.sh_entsize = sizeof(Elf32_Rela); + + int ret = scf_vector_add(arm32->sections, s); + if (ret < 0) { + scf_string_free(s->name); + free(s->data); + free(s); + return -ENOMEM; + } + + *ps = s; + return 0; +} + +static int _arm32_elf_add_plt(elf_native_t* arm32, elf_section_t** ps) +{ + elf_section_t* s; + + s = calloc(1, sizeof(elf_section_t)); + if (!s) + return -ENOMEM; + + s->name = scf_string_cstr(".plt"); + if (!s->name) { + free(s); + return -ENOMEM; + } + + s->data = malloc(sizeof(arm32_plt_lazy) + sizeof(arm32_plt) * arm32->dynsyms->size); + if (!s->data) { + scf_string_free(s->name); + free(s); + return -ENOMEM; + } + + memcpy(s->data, arm32_plt_lazy, sizeof(arm32_plt_lazy)); + s->data_len = sizeof(arm32_plt_lazy); + + int i; + for (i = 0; i < arm32->dynsyms->size; i++) { + + memcpy(s->data + s->data_len, arm32_plt, sizeof(arm32_plt)); + + s->data_len += sizeof(arm32_plt); + } + + s->index = 1; + + s->sh.sh_type = SHT_PROGBITS; + s->sh.sh_flags = SHF_ALLOC; + s->sh.sh_addralign = 1; + + int ret = scf_vector_add(arm32->sections, s); + if (ret < 0) { + scf_string_free(s->name); + free(s->data); + free(s); + return -ENOMEM; + } + + *ps = s; + return 0; +} + +static int _section_cmp(const void* v0, const void* v1) +{ + const elf_section_t* s0 = *(const elf_section_t**)v0; + const elf_section_t* s1 = *(const elf_section_t**)v1; + + if (s0->index < s1->index) + return -1; + else if (s0->index > s1->index) + return 1; + return 0; +} + +int __arm32_elf_add_dyn (elf_native_t* arm32) +{ + elf_section_t* s; + elf_sym_t* sym; + Elf32_Rela* rela; + + int i; + for (i = arm32->symbols->size - 1; i >= 0; i--) { + sym = arm32->symbols->data[i]; + + uint16_t shndx = sym->sym.st_shndx; + + if (STT_SECTION == ELF32_ST_TYPE(sym->sym.st_info)) { + if (shndx > 0) { + assert(shndx - 1 < arm32->sections->size); + sym->section = arm32->sections->data[shndx - 1]; + } + } else if (0 != shndx) { + if (shndx - 1 < arm32->sections->size) + sym->section = arm32->sections->data[shndx - 1]; + } + } + + char* sh_names[] = { + ".interp", + ".dynsym", + ".dynstr", +// ".gnu.version_r", + ".rela.plt", + ".plt", + + ".text", + ".rodata", + + ".dynamic", + ".got.plt", + ".data", + }; + + for (i = 0; i < arm32->sections->size; i++) { + s = arm32->sections->data[i]; + + s->index = arm32->sections->size + 1 + sizeof(sh_names) / sizeof(sh_names[0]); + + scf_logw("s: %s, link: %d, info: %d\n", s->name->data, s->sh.sh_link, s->sh.sh_info); + + if (s->sh.sh_link > 0) { + assert(s->sh.sh_link - 1 < arm32->sections->size); + + s->link = arm32->sections->data[s->sh.sh_link - 1]; + } + + if (s->sh.sh_info > 0) { + assert(s->sh.sh_info - 1 < arm32->sections->size); + + s->info = arm32->sections->data[s->sh.sh_info - 1]; + } + } + + _arm32_elf_add_interp(arm32, &arm32->interp); + _arm32_elf_add_dynsym(arm32, &arm32->dynsym); + _arm32_elf_add_dynstr(arm32, &arm32->dynstr); + +// _arm32_elf_add_gnu_version_r(arm32, &arm32->gnu_version_r); + + _arm32_elf_add_rela_plt(arm32, &arm32->rela_plt); + _arm32_elf_add_plt(arm32, &arm32->plt); + + _arm32_elf_add_dynamic(arm32, &arm32->dynamic); + _arm32_elf_add_got_plt(arm32, &arm32->got_plt); + + scf_string_t* str = scf_string_alloc(); + + char c = '\0'; + scf_string_cat_cstr_len(str, &c, 1); + + Elf32_Sym* syms = (Elf32_Sym* )arm32->dynsym->data; + Elf32_Sym sym0 = {0}; + + sym0.st_info = ELF32_ST_INFO(STB_LOCAL, STT_NOTYPE); + memcpy(&syms[0], &sym0, sizeof(Elf32_Sym)); + + for (i = 0; i < arm32->dynsyms->size; i++) { + elf_sym_t* xsym = arm32->dynsyms->data[i]; + + memcpy(&syms[i + 1], &xsym->sym, sizeof(Elf32_Sym)); + + syms[i + 1].st_name = str->len; + + scf_loge("i: %d, st_value: %#x\n", i, syms[i + 1].st_value); + + scf_string_cat_cstr_len(str, xsym->name->data, xsym->name->len + 1); + } + +#if 0 + Elf32_Verneed* verneeds = (Elf32_Verneed*) arm32->gnu_version_r->data; + Elf32_Vernaux* vernauxs = (Elf32_Vernaux*)(arm32->gnu_version_r->data +sizeof(Elf32_Verneed)); + + verneeds[0].vn_version = VER_NEED_CURRENT; + verneeds[0].vn_file = str->len; + verneeds[0].vn_cnt = 1; + verneeds[0].vn_aux = sizeof(Elf32_Verneed); + verneeds[0].vn_next = 0; + + scf_string_cat_cstr_len(str, "libc.so.6", strlen("libc.so.6") + 1); + + vernauxs[0].vna_hash = _arm32_elf_hash("GLIBC_2.4"); + vernauxs[0].vna_flags = 0; + vernauxs[0].vna_other = 2; + vernauxs[0].vna_name = str->len; + vernauxs[0].vna_next = 0; + + scf_string_cat_cstr_len(str, "GLIBC_2.4", strlen("GLIBC_2.4") + 1); +#endif + + Elf32_Dyn* dyns = (Elf32_Dyn*)arm32->dynamic->data; + + size_t prefix = strlen("../lib/arm32/"); + + for (i = 0; i < arm32->dyn_needs->size; i++) { + scf_string_t* needed = arm32->dyn_needs->data[i]; + + dyns[i].d_tag = DT_NEEDED; + dyns[i].d_un.d_val = str->len; + + scf_logw("i: %d, %s, %s\n", i, needed->data, needed->data + prefix); + + scf_string_cat_cstr_len(str, needed->data + prefix, needed->len - prefix + 1); + } + + dyns[i].d_tag = DT_STRTAB; + dyns[i + 1].d_tag = DT_SYMTAB; + dyns[i + 2].d_tag = DT_STRSZ; + dyns[i + 3].d_tag = DT_SYMENT; + dyns[i + 4].d_tag = DT_PLTGOT; + dyns[i + 5].d_tag = DT_PLTRELSZ; + dyns[i + 6].d_tag = DT_PLTREL; + dyns[i + 7].d_tag = DT_JMPREL; +// dyns[i + 8].d_tag = DT_VERNEED; +// dyns[i + 9].d_tag = DT_VERNEEDNUM; +// dyns[i +10].d_tag = DT_VERSYM; + dyns[i +8].d_tag = DT_NULL; + + dyns[i].d_un.d_ptr = (uintptr_t)arm32->dynstr; + dyns[i + 1].d_un.d_ptr = (uintptr_t)arm32->dynsym; + dyns[i + 2].d_un.d_val = str->len; + dyns[i + 3].d_un.d_val = sizeof(Elf32_Sym); + dyns[i + 4].d_un.d_ptr = (uintptr_t)arm32->got_plt; + dyns[i + 5].d_un.d_ptr = sizeof(Elf32_Rela); + dyns[i + 6].d_un.d_ptr = DT_RELA; + dyns[i + 7].d_un.d_ptr = (uintptr_t)arm32->rela_plt; +// dyns[i + 8].d_un.d_ptr = (uintptr_t)arm32->gnu_version_r; +// dyns[i + 9].d_un.d_ptr = 1; +// dyns[i +10].d_un.d_ptr = (uintptr_t)arm32->gnu_version; + dyns[i +8].d_un.d_ptr = 0; + + + int fill = 8 - (str->len & 0x7); + if (fill > 0) + scf_string_fill_zero(str, fill); + + arm32->dynstr->data = str->data; + arm32->dynstr->data_len = str->len; + + str->data = NULL; + str->len = 0; + str->capacity = 0; + scf_string_free(str); + str = NULL; + + arm32->rela_plt->link = arm32->dynsym; + arm32->rela_plt->info = arm32->got_plt; + arm32->dynsym ->link = arm32->dynstr; +#if 0 + arm32->gnu_version_r->link = arm32->dynstr; + arm32->gnu_version_r->info = arm32->interp; +#endif + + for (i = 0; i < arm32->sections->size; i++) { + s = arm32->sections->data[i]; + + int j; + for (j = 0; j < sizeof(sh_names) / sizeof(sh_names[0]); j++) { + if (!strcmp(s->name->data, sh_names[j])) + break; + } + + if (j < sizeof(sh_names) / sizeof(sh_names[0])) + s->index = j + 1; + + scf_logd("i: %d, s: %s, index: %d\n", i, s->name->data, s->index); + } + + qsort(arm32->sections->data, arm32->sections->size, sizeof(void*), _section_cmp); + + int j = sizeof(sh_names) / sizeof(sh_names[0]); + + for (i = j; i < arm32->sections->size; i++) { + s = arm32->sections->data[i]; + + s->index = i + 1; + } + + for (i = 0; i < arm32->sections->size; i++) { + s = arm32->sections->data[i]; + + scf_loge("i: %d, s: %s, index: %d\n", i, s->name->data, s->index); + + if (s->link) { + scf_logd("link: %s, index: %d\n", s->link->name->data, s->link->index); + s->sh.sh_link = s->link->index; + } + + if (s->info) { + scf_logd("info: %s, index: %d\n", s->info->name->data, s->info->index); + s->sh.sh_info = s->info->index; + } + + if (s == arm32->dynstr) + dyns[arm32->dyn_needs->size].d_un.d_ptr = i; + + else if (arm32->dynsym == s) + dyns[arm32->dyn_needs->size + 1].d_un.d_ptr = i; + + else if (arm32->got_plt == s) + dyns[arm32->dyn_needs->size + 4].d_un.d_ptr = i; + + else if (arm32->rela_plt == s) + dyns[arm32->dyn_needs->size + 7].d_un.d_ptr = i; + } + + for (i = 0; i < arm32->symbols->size; i++) { + sym = arm32->symbols->data[i]; + + if (sym->section) { + scf_logw("sym: %s, index: %d->%d\n", sym->name->data, sym->sym.st_shndx, sym->section->index); + sym->sym.st_shndx = sym->section->index; + } + } + + return 0; +} + +int __arm32_elf_post_dyn(elf_native_t* arm32, uint64_t rx_base, uint64_t rw_base, elf_section_t* cs) +{ + uint64_t cs_base = rx_base + cs->offset; + +// arm32->gnu_version_r->sh.sh_addr = rx_base + arm32->gnu_version_r->offset; + + arm32->rela_plt->sh.sh_addr = rx_base + arm32->rela_plt->offset; + arm32->dynamic->sh.sh_addr = rw_base + arm32->dynamic->offset; + arm32->got_plt->sh.sh_addr = rw_base + arm32->got_plt->offset; + arm32->interp->sh.sh_addr = rx_base + arm32->interp->offset; + arm32->plt->sh.sh_addr = rx_base + arm32->plt->offset; + + scf_loge("rw_base: %#lx, offset: %#lx\n", rw_base, arm32->got_plt->offset); + scf_loge("got_addr: %#x\n", arm32->got_plt->sh.sh_addr); + + Elf32_Rela* r; + Elf32_Rela* rela_plt = (Elf32_Rela*)arm32->rela_plt->data; + Elf32_Dyn* dtags = (Elf32_Dyn* )arm32->dynamic->data; + Elf32_Sym* dynsym = (Elf32_Sym* )arm32->dynsym->data; + uint32_t* got_plt = (uint32_t* )arm32->got_plt->data; + uint32_t* plt = (uint32_t* )arm32->plt->data; + + uint64_t got_addr = arm32->got_plt->sh.sh_addr; + uint64_t plt_addr = arm32->plt->sh.sh_addr; + int32_t offset = got_addr - plt_addr; + + got_plt[0] = arm32->dynamic->sh.sh_addr; + got_plt[1] = 0; + got_plt[2] = 0; + got_plt[3] = arm32->plt->sh.sh_addr; + got_plt += 4; + got_addr +=16; + + scf_loge("got_addr: %#lx, plt_addr: %#lx, offset: %d, %#x\n", got_addr, plt_addr, offset, offset); + + plt[4] = offset - 16; + + plt_addr += sizeof(arm32_plt_lazy); + plt += sizeof(arm32_plt_lazy) / sizeof(arm32_plt_lazy[0]); + + int i; + for (i = 0; i < arm32->dynsyms->size; i++) { + rela_plt[i].r_offset = got_addr; + rela_plt[i].r_addend = 0; + rela_plt[i].r_info = ELF32_R_INFO(i + 1, R_ARM_JUMP_SLOT); + + *got_plt = arm32->plt->sh.sh_addr; + + offset = got_addr - plt_addr - 8; // 'pc = current + 8' + + scf_loge("i: %d, got_addr: %#lx, plt_addr: %#lx, offset: %d, %#x\n", i, got_addr, plt_addr, offset, offset); + + scf_logw("got_plt[%d]: %#x\n", i, *got_plt); + + if (offset > 0xfffffff) { + scf_loge("\n"); + return -EINVAL; + } + + plt[0] |= (offset >> 20) & 0xff; + plt[1] |= (offset >> 12) & 0xff; + plt[2] |= offset & 0xfff; + + plt += sizeof(arm32_plt) / sizeof(arm32_plt[0]); + plt_addr += sizeof(arm32_plt); + got_addr += 4; + got_plt++; + } + + for (i = 0; i < arm32->dyn_relas->size; i++) { + r = arm32->dyn_relas->data[i]; + + int sym_idx = ELF32_R_SYM(r->r_info); + assert(sym_idx > 0); + + assert(ELF32_R_TYPE(r->r_info) == R_ARM_CALL); + + uint64_t plt_addr = arm32->plt->sh.sh_addr + sizeof(arm32_plt_lazy) + (sym_idx - 1) * sizeof(arm32_plt); + + int32_t offset = plt_addr - (cs_base + r->r_offset) + r->r_addend - 8; // 'pc' is 'current + 8' + + assert(0 == (offset & 0x3)); + + offset >>= 2; + + if (offset > 0x7fffff || offset < -0x7fffff) { + scf_loge("\n"); + return -EINVAL; + } + + offset &= 0xffffff; + offset |= (0xeb << 24); + + *(uint32_t*)(cs->data + r->r_offset) = offset; + } + + for (i = arm32->dyn_needs->size; i < arm32->dynamic->data_len / sizeof(Elf32_Dyn); i++) { + + elf_section_t* s; + + switch (dtags[i].d_tag) { + + case DT_SYMTAB: + case DT_STRTAB: + case DT_JMPREL: + s = arm32->sections->data[dtags[i].d_un.d_ptr]; + + dtags[i].d_un.d_ptr = s->offset + rx_base; + s->sh.sh_addr = s->offset + rx_base; + break; + + case DT_PLTGOT: + s = arm32->sections->data[dtags[i].d_un.d_ptr]; + + dtags[i].d_un.d_ptr = s->offset + rw_base; + s->sh.sh_addr = s->offset + rw_base; + break; + default: + break; + }; + } + + return 0; +} + +int __arm32_elf_write_phdr(scf_elf_context_t* elf, uint64_t rx_base, uint64_t offset, uint32_t nb_phdrs) +{ + // write program header + + Elf32_Phdr ph_phdr = {0}; + + ph_phdr.p_type = PT_PHDR; + ph_phdr.p_flags = PF_R; + ph_phdr.p_offset = offset; + ph_phdr.p_vaddr = rx_base + offset; + ph_phdr.p_paddr = ph_phdr.p_vaddr; + ph_phdr.p_filesz = sizeof(Elf32_Phdr) * nb_phdrs; + ph_phdr.p_memsz = ph_phdr.p_filesz; + ph_phdr.p_align = 0x8; + + fwrite(&ph_phdr, sizeof(ph_phdr), 1, elf->fp); + return 0; +} + +int __arm32_elf_write_interp(scf_elf_context_t* elf, uint64_t rx_base, uint64_t offset, uint64_t len) +{ + Elf32_Phdr ph_interp = {0}; + + ph_interp.p_type = PT_INTERP; + ph_interp.p_flags = PF_R; + ph_interp.p_offset = offset; + ph_interp.p_vaddr = rx_base + offset; + ph_interp.p_paddr = ph_interp.p_vaddr; + ph_interp.p_filesz = len; + ph_interp.p_memsz = ph_interp.p_filesz; + ph_interp.p_align = 0x1; + + fwrite(&ph_interp, sizeof(ph_interp), 1, elf->fp); + return 0; +} + +int __arm32_elf_write_text(scf_elf_context_t* elf, uint64_t rx_base, uint64_t offset, uint64_t len) +{ + Elf32_Phdr ph_text = {0}; + + ph_text.p_type = PT_LOAD; + ph_text.p_flags = PF_R | PF_X; + ph_text.p_offset = 0; + ph_text.p_vaddr = rx_base + offset; + ph_text.p_paddr = ph_text.p_vaddr; + ph_text.p_filesz = len; + ph_text.p_memsz = ph_text.p_filesz; + ph_text.p_align = 0x200000; + + fwrite(&ph_text, sizeof(ph_text), 1, elf->fp); + return 0; +} + +int __arm32_elf_write_rodata(scf_elf_context_t* elf, uint64_t r_base, uint64_t offset, uint64_t len) +{ + Elf32_Phdr ph_rodata = {0}; + + ph_rodata.p_type = PT_LOAD; + ph_rodata.p_flags = PF_R; + ph_rodata.p_offset = offset; + ph_rodata.p_vaddr = r_base + offset; + ph_rodata.p_paddr = ph_rodata.p_vaddr; + ph_rodata.p_filesz = len; + ph_rodata.p_memsz = ph_rodata.p_filesz; + ph_rodata.p_align = 0x200000; + + fwrite(&ph_rodata, sizeof(ph_rodata), 1, elf->fp); + return 0; +} + +int __arm32_elf_write_data(scf_elf_context_t* elf, uint64_t rw_base, uint64_t offset, uint64_t len) +{ + Elf32_Phdr ph_data = {0}; + + ph_data.p_type = PT_LOAD; + ph_data.p_flags = PF_R | PF_W; + ph_data.p_offset = offset; + ph_data.p_vaddr = rw_base + offset; + ph_data.p_paddr = ph_data.p_vaddr; + ph_data.p_filesz = len; + ph_data.p_memsz = ph_data.p_filesz; + ph_data.p_align = 0x200000; + + fwrite(&ph_data, sizeof(ph_data), 1, elf->fp); + return 0; +} + +int __arm32_elf_write_dynamic(scf_elf_context_t* elf, uint64_t rw_base, uint64_t offset, uint64_t len) +{ + Elf32_Phdr ph_dynamic = {0}; + + ph_dynamic.p_type = PT_DYNAMIC; + ph_dynamic.p_flags = PF_R | PF_W; + ph_dynamic.p_offset = offset; + ph_dynamic.p_vaddr = rw_base + offset; + ph_dynamic.p_paddr = ph_dynamic.p_vaddr; + ph_dynamic.p_filesz = len; + ph_dynamic.p_memsz = ph_dynamic.p_filesz; + ph_dynamic.p_align = 0x8; + + fwrite(&ph_dynamic, sizeof(Elf32_Phdr), 1, elf->fp); + return 0; +} + diff --git a/elf/scf_elf_link.c b/elf/scf_elf_link.c index 514f16f..c1de02e 100644 --- a/elf/scf_elf_link.c +++ b/elf/scf_elf_link.c @@ -274,9 +274,17 @@ int scf_elf_file_read(scf_elf_file_t* ef) #define ELF_READ_RELAS(sname) \ do { \ int ret = scf_elf_read_relas(ef->elf, ef->sname##_relas, ".rela."#sname); \ - if (ret < 0 && ret != -404) { \ - scf_loge("\n"); \ - return ret; \ + if (ret < 0) { \ + if (ret != -404) { \ + scf_loge("\n"); \ + return ret; \ + } \ + \ + ret = scf_elf_read_relas(ef->elf, ef->sname##_relas, ".rel."#sname); \ + if (ret < 0 && ret != -404) { \ + scf_loge("\n"); \ + return ret; \ + } \ } \ } while(0); @@ -425,7 +433,7 @@ sym_error: return ret; } -static int merge_relas(scf_vector_t* dst, scf_vector_t* src, size_t offset, int nb_syms) +static int merge_relas(scf_vector_t* dst, scf_vector_t* src, size_t offset, int nb_syms, const int bits) { scf_elf_rela_t* rela; scf_elf_rela_t* rela2; @@ -435,7 +443,11 @@ static int merge_relas(scf_vector_t* dst, scf_vector_t* src, size_t offset, int rela2 = src->data[j]; rela2->r_offset += offset; - rela2->r_info = ELF64_R_INFO(ELF64_R_SYM(rela2->r_info) + nb_syms, ELF64_R_TYPE(rela2->r_info)); + + if (64 == bits) + rela2->r_info = ELF64_R_INFO(ELF64_R_SYM(rela2->r_info) + nb_syms, ELF64_R_TYPE(rela2->r_info)); + else + rela2->r_info = ELF32_R_INFO(ELF32_R_SYM(rela2->r_info) + nb_syms, ELF32_R_TYPE(rela2->r_info)); rela = calloc(1, sizeof(scf_elf_rela_t)); if (!rela) @@ -453,6 +465,8 @@ static int merge_relas(scf_vector_t* dst, scf_vector_t* src, size_t offset, int return -ENOMEM; } + scf_logw("j: %d, nb_syms: %d:%ld, sym: %s\n", j, nb_syms, ELF32_R_SYM(rela2->r_info), rela2->name); + rela->r_offset = rela2->r_offset; rela->r_info = rela2->r_info; rela->r_addend = rela2->r_addend; @@ -517,6 +531,8 @@ static int merge_syms(scf_elf_file_t* exec, scf_elf_file_t* obj) return -ENOMEM; } + scf_loge("sym: %d, %s\n", exec->syms->size, sym->name); + if (scf_vector_add(exec->syms, sym) < 0) { scf_loge("\n"); return -ENOMEM; @@ -531,13 +547,13 @@ static int merge_syms(scf_elf_file_t* exec, scf_elf_file_t* obj) return 0; } -static int merge_obj(scf_elf_file_t* exec, scf_elf_file_t* obj) +static int merge_obj(scf_elf_file_t* exec, scf_elf_file_t* obj, const int bits) { int nb_syms = exec->syms->size; #define MERGE_RELAS(dst, src, offset) \ do { \ - int ret = merge_relas(dst, src, offset, nb_syms); \ + int ret = merge_relas(dst, src, offset, nb_syms, bits); \ if (ret < 0) { \ scf_loge("\n"); \ return ret; \ @@ -581,7 +597,14 @@ static int merge_obj(scf_elf_file_t* exec, scf_elf_file_t* obj) static int merge_objs(scf_elf_file_t* exec, char* inputs[], int nb_inputs, const char* arch) { int nb_syms = 0; + int bits; int i; + + if (!strcmp(arch, "x64") || !strcmp(arch, "arm64") || !strcmp(arch, "naja")) + bits = 64; + else + bits = 32; + for (i = 0; i < nb_inputs; i++) { scf_elf_sym_t* sym; @@ -599,7 +622,9 @@ static int merge_objs(scf_elf_file_t* exec, char* inputs[], int nb_inputs, const return -1; } - int ret = merge_obj(exec, obj); + scf_loge("i: %d, input: %s\n", i, inputs[i]); + + int ret = merge_obj(exec, obj, bits); if (ret < 0) { scf_loge("\n"); return -1; @@ -612,14 +637,19 @@ static int merge_objs(scf_elf_file_t* exec, char* inputs[], int nb_inputs, const return 0; } -static int _find_sym(scf_elf_sym_t** psym, scf_elf_rela_t* rela, scf_vector_t* symbols) +static int _find_sym(scf_elf_sym_t** psym, scf_elf_rela_t* rela, scf_vector_t* symbols, const int bits) { scf_elf_sym_t* sym; scf_elf_sym_t* sym2; - int sym_idx = ELF64_R_SYM(rela->r_info); + int sym_idx; int j; + if (64 == bits) + sym_idx = ELF64_R_SYM(rela->r_info); + else + sym_idx = ELF32_R_SYM(rela->r_info); + assert(sym_idx >= 1); assert(sym_idx - 1 < symbols->size); @@ -716,6 +746,12 @@ static int merge_ar_obj(scf_elf_file_t* exec, scf_ar_file_t* ar, uint32_t offset { scf_elf_file_t* obj = NULL; + int bits; + if (!strcmp(arch, "x64") || !strcmp(arch, "arm64") || !strcmp(arch, "naja")) + bits = 64; + else + bits = 32; + int ret = __scf_elf_file_open(&obj); if (ret < 0) { scf_loge("\n"); @@ -741,7 +777,7 @@ static int merge_ar_obj(scf_elf_file_t* exec, scf_ar_file_t* ar, uint32_t offset return -1; } - ret = merge_obj(exec, obj); + ret = merge_obj(exec, obj, bits); if (ret < 0) { scf_loge("\n"); return -1; @@ -801,6 +837,12 @@ static int link_relas(scf_elf_file_t* exec, char* afiles[], int nb_afiles, char* scf_vector_t* dlls = scf_vector_alloc(); int i; + int bits; + if (!strcmp(arch, "x64") || !strcmp(arch, "arm64") || !strcmp(arch, "naja")) + bits = 64; + else + bits = 32; + for (i = 0; i < nb_afiles; i++) { if (scf_ar_file_open(&ar, afiles[i]) < 0) { @@ -831,15 +873,19 @@ static int link_relas(scf_elf_file_t* exec, char* afiles[], int nb_afiles, char* rela = exec->text_relas->data[i]; sym = NULL; - int sym_idx = _find_sym(&sym, rela, exec->syms); + int sym_idx = _find_sym(&sym, rela, exec->syms, bits); if (sym_idx >= 0) { i++; continue; } - sym_idx = ELF64_R_SYM(rela->r_info); - sym = exec->syms->data[sym_idx - 1]; + if (64 == bits) + sym_idx = ELF64_R_SYM(rela->r_info); + else + sym_idx = ELF32_R_SYM(rela->r_info); + + sym = exec->syms->data[sym_idx - 1]; uint32_t offset = 0; uint32_t size = 0; @@ -896,7 +942,10 @@ static int link_relas(scf_elf_file_t* exec, char* afiles[], int nb_afiles, char* scf_vector_del(exec->text_relas, rela); scf_vector_add(exec->rela_plt, rela); - rela->r_info = ELF64_R_INFO(j + 1, ELF64_R_TYPE(rela->r_info)); + if (64 == bits) + rela->r_info = ELF64_R_INFO(j + 1, ELF64_R_TYPE(rela->r_info)); + else + rela->r_info = ELF32_R_INFO(j + 1, ELF32_R_TYPE(rela->r_info)); scf_loge("j: %d, sym: %s, r_offset: %#lx, r_addend: %ld\n", j, sym->name, rela->r_offset, rela->r_addend); @@ -906,13 +955,17 @@ static int link_relas(scf_elf_file_t* exec, char* afiles[], int nb_afiles, char* rela = exec->data_relas->data[i]; sym = NULL; - int sym_idx = _find_sym(&sym, rela, exec->syms); + int sym_idx = _find_sym(&sym, rela, exec->syms, bits); if (sym_idx >= 0) continue; - sym_idx = ELF64_R_SYM(rela->r_info); - sym = exec->syms->data[sym_idx - 1]; + if (64 == bits) + sym_idx = ELF64_R_SYM(rela->r_info); + else + sym_idx = ELF32_R_SYM(rela->r_info); + + sym = exec->syms->data[sym_idx - 1]; uint32_t offset = 0; uint32_t size = 0; @@ -942,7 +995,10 @@ static int link_relas(scf_elf_file_t* exec, char* afiles[], int nb_afiles, char* for (j = 0; j < so->rela_plt->size; j++) { rela = so->rela_plt->data[j]; - sym_idx = ELF64_R_SYM(rela->r_info); + if (64 == bits) + sym_idx = ELF64_R_SYM(rela->r_info); + else + sym_idx = ELF32_R_SYM(rela->r_info); if (sym_idx <= 0) continue; diff --git a/elf/scf_elf_native.h b/elf/scf_elf_native.h index 179b4b5..d36abc1 100644 --- a/elf/scf_elf_native.h +++ b/elf/scf_elf_native.h @@ -90,6 +90,9 @@ int elf_read_syms (scf_elf_context_t* elf, scf_vector_t* syms, const char* s int elf_find_sym (elf_sym_t** psym, Elf64_Rela* rela, scf_vector_t* symbols); void elf_process_syms(elf_native_t* native, uint32_t cs_index); +int elf32_find_sym (elf_sym_t** psym, Elf32_Rela* rela, scf_vector_t* symbols); +void elf32_process_syms(elf_native_t* native, uint32_t cs_index); + int elf_write_sections(scf_elf_context_t* elf); int elf_write_shstrtab(scf_elf_context_t* elf); int elf_write_symtab (scf_elf_context_t* elf); diff --git a/elf/scf_elf_native32.c b/elf/scf_elf_native32.c new file mode 100644 index 0000000..70384a8 --- /dev/null +++ b/elf/scf_elf_native32.c @@ -0,0 +1,1098 @@ +#include"scf_elf_native32.h" +#include"scf_elf_link.h" + +int elf32_open(scf_elf_context_t* elf) +{ + if (!elf) + return -EINVAL; + + elf_native_t* e = calloc(1, sizeof(elf_native_t)); + if (!e) + return -ENOMEM; + + e->sh_null.sh_type = SHT_NULL; + + e->sh_symtab.sh_type = SHT_SYMTAB; + e->sh_symtab.sh_flags = 0; + e->sh_symtab.sh_addralign = 4; + + e->sh_strtab.sh_type = SHT_STRTAB; + e->sh_strtab.sh_flags = 0; + e->sh_strtab.sh_addralign = 1; + + e->sh_shstrtab.sh_type = SHT_STRTAB; + e->sh_shstrtab.sh_flags = 0; + e->sh_shstrtab.sh_addralign = 1; + + e->sections = scf_vector_alloc(); + e->symbols = scf_vector_alloc(); + + elf->priv = e; + return 0; +} + +int elf32_close(scf_elf_context_t* elf) +{ + elf_native_t* e = elf->priv; + + if (e) { + free(e); + e = NULL; + } + return 0; +} + +int elf32_add_sym(scf_elf_context_t* elf, const scf_elf_sym_t* sym, const char* sh_name) +{ + elf_sym_t* xsym; + elf_native_t* e = elf->priv; + scf_vector_t* vec = NULL; + + if (!strcmp(sh_name, ".symtab")) + vec = e->symbols; + + else if (!strcmp(sh_name, ".dynsym")) { + + if (!e->dynsyms) { + e->dynsyms = scf_vector_alloc(); + if (!e->dynsyms) + return -ENOMEM; + } + + vec = e->dynsyms; + } else + return -EINVAL; + + xsym = calloc(1, sizeof(elf_sym_t)); + if (!xsym) + return -ENOMEM; + + if (sym->name) + xsym->name = scf_string_cstr(sym->name); + else + xsym->name = NULL; + + xsym->sym.st_size = sym->st_size; + xsym->sym.st_value = sym->st_value; + xsym->sym.st_shndx = sym->st_shndx; + xsym->sym.st_info = sym->st_info; + + xsym->dyn_flag = sym->dyn_flag; + + int ret = scf_vector_add(vec, xsym); + if (ret < 0) { + scf_string_free(xsym->name); + free(xsym); + return ret; + } + + xsym->index = vec->size; + return 0; +} + +int elf32_add_section(scf_elf_context_t* elf, const scf_elf_section_t* section) +{ + elf_native_t* e = elf->priv; + + elf_section_t* s; + elf_section_t* s2; + int i; + + if (section->index > 0) { + + for (i = e->sections->size - 1; i >= 0; i--) { + s = e->sections->data[i]; + + if (s->index == section->index) { + scf_loge("s->index: %d\n", s->index); + return -1; + } + } + } + + s = calloc(1, sizeof(elf_section_t)); + if (!s) + return -ENOMEM; + + s->name = scf_string_cstr(section->name); + if (!s->name) { + free(s); + return -ENOMEM; + } + + s->sh.sh_type = section->sh_type; + s->sh.sh_flags = section->sh_flags; + s->sh.sh_addralign = section->sh_addralign; + + if (section->data && section->data_len > 0) { + s->data = malloc(section->data_len); + if (!s->data) { + scf_string_free(s->name); + free(s); + return -ENOMEM; + } + + memcpy(s->data, section->data, section->data_len); + s->data_len = section->data_len; + } + + if (scf_vector_add(e->sections, s) < 0) { + if (s->data) + free(s->data); + scf_string_free(s->name); + free(s); + return -ENOMEM; + } + + if (0 == section->index) + s->index = e->sections->size; + else { + s->index = section->index; + + for (i = e->sections->size - 2; i >= 0; i--) { + s2 = e->sections->data[i]; + + if (s2->index < s->index) + break; + + e->sections->data[i + 1] = s2; + } + + e->sections->data[i + 1] = s; + } + + return s->index; +} + +int elf32_add_rela_section(scf_elf_context_t* elf, const scf_elf_section_t* section, scf_vector_t* relas) +{ + if (relas->size <= 0) { + scf_loge("\n"); + return -EINVAL; + } + + elf_native_t* e = elf->priv; + + elf_section_t* s = calloc(1, sizeof(elf_section_t)); + if (!s) + return -ENOMEM; + + s->name = scf_string_cstr(section->name); + if (!s->name) { + free(s); + return -ENOMEM; + } + + s->index = e->sections->size + 1; + s->sh.sh_type = SHT_RELA; + s->sh.sh_flags = SHF_INFO_LINK; + s->sh.sh_addralign = section->sh_addralign; + s->sh.sh_link = section->sh_link; + s->sh.sh_info = section->sh_info; + s->sh.sh_entsize = sizeof(Elf32_Rela); + + s->data_len = sizeof(Elf32_Rela) * relas->size; + + s->data = malloc(s->data_len); + if (!s->data) { + scf_string_free(s->name); + free(s); + return -ENOMEM; + } + + Elf32_Rela* pr = (Elf32_Rela*) s->data; + + int i; + for (i = 0; i < relas->size; i++) { + + scf_elf_rela_t* r = relas->data[i]; + + pr[i].r_offset = r->r_offset; + pr[i].r_info = r->r_info; + pr[i].r_addend = r->r_addend; + } + + if (scf_vector_add(e->sections, s) < 0) { + free(s->data); + scf_string_free(s->name); + free(s); + return -ENOMEM; + } + return s->index; +} + +int elf32_read_shstrtab(scf_elf_context_t* elf) +{ + elf_native_t* e = elf->priv; + + if (!elf->fp) + return -EINVAL; + + int ret = fseek(elf->fp, elf->start, SEEK_SET); + if (ret < 0) + return ret; + + ret = fread(&e->eh, sizeof(Elf32_Ehdr), 1, elf->fp); + if (ret != 1) + return -1; + + if (ELFMAG0 != e->eh.e_ident[EI_MAG0] + || ELFMAG1 != e->eh.e_ident[EI_MAG1] + || ELFMAG2 != e->eh.e_ident[EI_MAG2] + || ELFMAG3 != e->eh.e_ident[EI_MAG3]) { + + scf_loge("not elf file\n"); + return -1; + } + + long offset = e->eh.e_shoff + e->eh.e_shentsize * e->eh.e_shstrndx; + fseek(elf->fp, elf->start + offset, SEEK_SET); + + ret = fread(&e->sh_shstrtab, sizeof(Elf32_Shdr), 1, elf->fp); + if (ret != 1) + return -1; + + if (!e->sh_shstrtab_data) { + e->sh_shstrtab_data = scf_string_alloc(); + if (!e->sh_shstrtab_data) + return -ENOMEM; + } + + void* p = realloc(e->sh_shstrtab_data->data, e->sh_shstrtab.sh_size); + if (!p) + return -ENOMEM; + e->sh_shstrtab_data->data = p; + e->sh_shstrtab_data->len = e->sh_shstrtab.sh_size; + e->sh_shstrtab_data->capacity = e->sh_shstrtab.sh_size; + + fseek(elf->fp, elf->start + e->sh_shstrtab.sh_offset, SEEK_SET); + + ret = fread(e->sh_shstrtab_data->data, e->sh_shstrtab.sh_size, 1, elf->fp); + if (ret != 1) + return -1; +#if 0 + int i; + for (i = 0; i < e->sh_shstrtab.sh_size; i++) { + + unsigned char c = e->sh_shstrtab_data->data[i]; + if (c) + printf("%c", c); + else + printf("\n"); + } + printf("\n"); +#endif + return 0; +} + +static int __elf_read_section_data(scf_elf_context_t* elf, elf_section_t* s) +{ + s->data_len = s->sh.sh_size; + + if (s->sh.sh_size > 0) { + + s->data = malloc(s->sh.sh_size); + if (!s->data) + return -1; + + fseek(elf->fp, elf->start + s->sh.sh_offset, SEEK_SET); + + int ret = fread(s->data, s->data_len, 1, elf->fp); + if (ret != 1) { + free(s->data); + s->data = NULL; + s->data_len = 0; + return -1; + } + } + + return 0; +} + +static int __elf_read_section_by_index(scf_elf_context_t* elf, elf_section_t** psection, const int index) +{ + elf_native_t* e = elf->priv; + + if (!e || !elf->fp) + return -1; + + if (!e->sh_shstrtab_data) { + + int ret = elf32_read_shstrtab(elf); + if (ret < 0) + return ret; + } + + if (index >= e->eh.e_shnum) + return -EINVAL; + + elf_section_t* s; + int i; + for (i = 0; i < e->sections->size; i++) { + s = e->sections->data[i]; + + if (index == s->index) { + + if (s->data || __elf_read_section_data(elf, s) == 0) { + *psection = s; + return 0; + } + return -1; + } + } + + s = calloc(1, sizeof(elf_section_t)); + if (!s) + return -ENOMEM; + + long offset = e->eh.e_shoff + e->eh.e_shentsize * index; + fseek(elf->fp, elf->start + offset, SEEK_SET); + + int ret = fread(&s->sh, sizeof(Elf32_Shdr), 1, elf->fp); + if (ret != 1) { + free(s); + return -1; + } + + s->index = index; + s->name = scf_string_cstr(e->sh_shstrtab_data->data + s->sh.sh_name); + if (!s->name) { + free(s); + return -1; + } + + ret = scf_vector_add(e->sections, s); + if (ret < 0) { + scf_string_free(s->name); + free(s); + return -1; + } + + if (__elf_read_section_data(elf, s) == 0) { + *psection = s; + return 0; + } + return -1; +} + +int elf32_read_phdrs(scf_elf_context_t* elf, scf_vector_t* phdrs) +{ + elf_native_t* e = elf->priv; + scf_elf_phdr_t* ph; + Elf32_Ehdr eh; + + if (!e || !elf->fp) + return -1; + + if (!elf->fp) + return -EINVAL; + + int ret = fseek(elf->fp, elf->start, SEEK_SET); + if (ret < 0) + return ret; + + ret = fread(&eh, sizeof(Elf32_Ehdr), 1, elf->fp); + if (ret != 1) + return -1; + + if (ELFMAG0 != eh.e_ident[EI_MAG0] + || ELFMAG1 != eh.e_ident[EI_MAG1] + || ELFMAG2 != eh.e_ident[EI_MAG2] + || ELFMAG3 != eh.e_ident[EI_MAG3]) { + + scf_loge("not elf file\n"); + return -1; + } + + fseek(elf->fp, elf->start + eh.e_phoff, SEEK_SET); + + int i; + for (i = 0; i < eh.e_phnum; i++) { + + ph = calloc(1, sizeof(scf_elf_phdr_t)); + if (!ph) + return -ENOMEM; + + ret = fread(&ph->ph, sizeof(Elf32_Phdr), 1, elf->fp); + + if (ret != 1) { + free(ph); + return -1; + } + + if (scf_vector_add(phdrs, ph) < 0) { + free(ph); + return -ENOMEM; + } + } + + return 0; +} + +static int __elf_read_section(scf_elf_context_t* elf, elf_section_t** psection, const char* name) +{ + elf_native_t* e = elf->priv; + + if (!e || !elf->fp) + return -1; + + if (!e->sh_shstrtab_data) { + + int ret = elf32_read_shstrtab(elf); + if (ret < 0) + return ret; + } + + elf_section_t* s; + int i; + for (i = 0; i < e->sections->size; i++) { + s = e->sections->data[i]; + + if (!scf_string_cmp_cstr(s->name, name)) { + + if (s->data || __elf_read_section_data(elf, s) == 0) { + *psection = s; + return 0; + } + return -1; + } + } + + int j; + for (j = 1; j < e->eh.e_shnum; j++) { + + for (i = 0; i < e->sections->size; i++) { + s = e->sections->data[i]; + + if (j == s->index) + break; + } + + if (i < e->sections->size) + continue; + + s = calloc(1, sizeof(elf_section_t)); + if (!s) + return -ENOMEM; + + long offset = e->eh.e_shoff + e->eh.e_shentsize * j; + fseek(elf->fp, elf->start + offset, SEEK_SET); + + int ret = fread(&s->sh, sizeof(Elf32_Shdr), 1, elf->fp); + if (ret != 1) { + free(s); + return -1; + } + + s->index = j; + s->name = scf_string_cstr(e->sh_shstrtab_data->data + s->sh.sh_name); + if (!s->name) { + free(s); + return -1; + } + + ret = scf_vector_add(e->sections, s); + if (ret < 0) { + scf_string_free(s->name); + free(s); + return -1; + } + + if (!scf_string_cmp_cstr(s->name, name)) + break; + } + + if (j < e->eh.e_shnum) { + + if (!s->data) { + if (__elf_read_section_data(elf, s) == 0) { + *psection = s; + return 0; + } + + return -1; + } else + assert(s->data_len == s->sh.sh_size); + + *psection = s; + return 0; + } + + return -404; +} + +int elf32_read_syms(scf_elf_context_t* elf, scf_vector_t* syms, const char* sh_name) +{ + elf_native_t* e = elf->priv; + + if (!e || !elf->fp) + return -1; + + elf_section_t* symtab = NULL; + elf_section_t* strtab = NULL; + + char* sh_strtab_name = NULL; + + if (!strcmp(sh_name, ".symtab")) + sh_strtab_name = ".strtab"; + + else if (!strcmp(sh_name, ".dynsym")) + sh_strtab_name = ".dynstr"; + else + return -EINVAL; + + int ret = __elf_read_section(elf, &symtab, sh_name); + if (ret < 0) { + scf_loge("\n"); + return -1; + } + + ret = __elf_read_section(elf, &strtab, sh_strtab_name); + if (ret < 0) { + scf_loge("\n"); + return -1; + } + + assert(symtab->data_len % sizeof(Elf32_Sym) == 0); + + scf_loge("0: syms->size: %d, %ld\n", syms->size, symtab->data_len / sizeof(Elf32_Sym)); + + scf_elf_sym_t* esym; + Elf32_Sym* sym; + int i; + int j = 0; + for (i = 0; i < symtab->data_len; i += sizeof(Elf32_Sym)) { + + sym = (Elf32_Sym*)(symtab->data + i); + + assert(sym->st_name < strtab->data_len); + + if (STT_NOTYPE == sym->st_info && 0 == i) { + j++; + continue; + } + + esym = calloc(1, sizeof(scf_elf_sym_t)); + if (!esym) + return -ENOMEM; + + esym->name = strtab->data + sym->st_name; + esym->st_size = sym->st_size; + esym->st_value = sym->st_value; + esym->st_shndx = sym->st_shndx; + esym->st_info = sym->st_info; + + if (scf_vector_add(syms, esym) < 0) { + free(esym); + return -ENOMEM; + } + } + + scf_loge("1: j: %d, syms->size: %d, %ld\n", j, syms->size, symtab->data_len / sizeof(Elf32_Sym)); + + return 0; +} + +int elf32_add_dyn_need(scf_elf_context_t* elf, const char* soname) +{ + elf_native_t* e = elf->priv; + + if (!e || !elf->fp) + return -1; + + if (!e->dyn_needs) { + e->dyn_needs = scf_vector_alloc(); + if (!e->dyn_needs) + return -ENOMEM; + } + + scf_string_t* s = scf_string_cstr(soname); + if (!s) + return -ENOMEM; + + if (scf_vector_add(e->dyn_needs, s) < 0) { + scf_string_free(s); + return -ENOMEM; + } + + scf_loge("soname: %s\n", soname); + return 0; +} + +int elf32_add_dyn_rela(scf_elf_context_t* elf, const scf_elf_rela_t* rela) +{ + elf_native_t* e = elf->priv; + + if (!e || !elf->fp) + return -1; + + if (!e->dyn_relas) { + e->dyn_relas = scf_vector_alloc(); + if (!e->dyn_relas) + return -ENOMEM; + } + + Elf32_Rela* r = calloc(1, sizeof(Elf32_Rela)); + if (!r) + return -ENOMEM; + + if (scf_vector_add(e->dyn_relas, r) < 0) { + free(r); + return -ENOMEM; + } + + r->r_offset = rela->r_offset; + r->r_addend = rela->r_addend; + r->r_info = rela->r_info; + + return 0; +} + +int elf32_read_relas(scf_elf_context_t* elf, scf_vector_t* relas, const char* sh_name) +{ + elf_native_t* e = elf->priv; + + if (!e || !elf->fp) + return -1; + + scf_elf_rela_t* erela; + elf_section_t* sh_rela = NULL; + elf_section_t* symtab = NULL; + elf_section_t* strtab = NULL; + Elf32_Rela* rela; + Elf32_Rel* rel; + Elf32_Sym* sym; + + char* symtab_name = NULL; + char* strtab_name = NULL; + int i; + + int ret = __elf_read_section(elf, &sh_rela, sh_name); + if (ret < 0) + return ret; + + scf_loge("sh_rela: %u\n", sh_rela->sh.sh_link); + + ret = __elf_read_section_by_index(elf, &symtab, sh_rela->sh.sh_link); + if (ret < 0) { + scf_loge("\n"); + return ret; + } + + ret = __elf_read_section_by_index(elf, &strtab, symtab->sh.sh_link); + if (ret < 0) { + scf_loge("\n"); + return ret; + } + + + if (SHT_RELA == sh_rela->sh.sh_type) { + + assert(sh_rela->data_len % sizeof(Elf32_Rela) == 0); + + for (i = 0; i < sh_rela->data_len; i += sizeof(Elf32_Rela)) { + + rela = (Elf32_Rela*)(sh_rela->data + i); + + int sym_idx = ELF32_R_SYM(rela->r_info); + + assert(sym_idx < symtab->data_len / sizeof(Elf32_Sym)); + + sym = (Elf32_Sym*)(symtab->data + sym_idx * sizeof(Elf32_Sym)); + + assert(sym->st_name < strtab->data_len); + + erela = calloc(1, sizeof(scf_elf_rela_t)); + if (!erela) + return -ENOMEM; + + erela->name = strtab->data + sym->st_name; + erela->r_offset = rela->r_offset; + erela->r_info = rela->r_info; + erela->r_addend = rela->r_addend; + + if (scf_vector_add(relas, erela) < 0) { + scf_loge("\n"); + free(erela); + return -ENOMEM; + } + } + + } else { + assert(sh_rela->data_len % sizeof(Elf32_Rel) == 0); + + for (i = 0; i < sh_rela->data_len; i += sizeof(Elf32_Rel)) { + + rel = (Elf32_Rel*)(sh_rela->data + i); + + int sym_idx = ELF32_R_SYM(rel->r_info); + + assert(sym_idx < symtab->data_len / sizeof(Elf32_Sym)); + + sym = (Elf32_Sym*)(symtab->data + sym_idx * sizeof(Elf32_Sym)); + + assert(sym->st_name < strtab->data_len); + + erela = calloc(1, sizeof(scf_elf_rela_t)); + if (!erela) + return -ENOMEM; + + erela->name = strtab->data + sym->st_name; + erela->r_offset = rel->r_offset; + erela->r_info = rel->r_info; + + if (scf_vector_add(relas, erela) < 0) { + scf_loge("\n"); + free(erela); + return -ENOMEM; + } + } + } + + return 0; +} + +int elf32_read_section(scf_elf_context_t* elf, scf_elf_section_t** psection, const char* name) +{ + elf_section_t* s = NULL; + scf_elf_section_t* s2; + elf_native_t* e = elf->priv; + + if (!e || !elf->fp) + return -1; + + int ret = __elf_read_section(elf, &s, name); + if (ret < 0) + return ret; + + s2 = calloc(1, sizeof(scf_elf_section_t)); + if (!s2) + return -ENOMEM; + + s2->index = s->index; + s2->name = s->name->data; + s2->data = s->data; + s2->data_len = s->data_len; + s2->sh_type = s->sh.sh_type; + s2->sh_flags = s->sh.sh_flags; + s2->sh_addralign = s->sh.sh_addralign; + + *psection = s2; + return 0; +} + +int elf32_write_symtab(scf_elf_context_t* elf) +{ + elf_native_t* e = elf->priv; + Elf32_Sym s0 = {0}; + elf_sym_t* s; + + s0.st_info = ELF32_ST_INFO(STB_LOCAL, STT_NOTYPE); + + fwrite(&s0, sizeof(s0), 1, elf->fp); // entry index 0 in symtab is NOTYPE + + int i; + for (i = 0; i < e->symbols->size; i++) { + s = e->symbols->data[i]; + + fwrite(&s->sym, sizeof(s->sym), 1, elf->fp); + } + + return 0; +} + +int elf32_write_strtab(scf_elf_context_t* elf) +{ + elf_sym_t* s; + elf_native_t* e = elf->priv; + uint8_t c = 0; + + fwrite(&c, sizeof(c), 1, elf->fp); + + int i; + for (i = 0; i < e->symbols->size; i++) { + s = e->symbols->data[i]; + + if (s->name) + fwrite(s->name->data, s->name->len + 1, 1, elf->fp); + } + + return 0; +} + +int elf32_write_shstrtab(scf_elf_context_t* elf) +{ + elf_section_t* s; + elf_native_t* e = elf->priv; + uint8_t c = 0; + char* str = ".symtab\0.strtab\0.shstrtab\0"; + int len = strlen(".symtab") + strlen(".strtab") + strlen(".shstrtab") + 3; + + fwrite(&c, sizeof(c), 1, elf->fp); + + int i; + for (i = 0; i < e->sections->size; i++) { + s = e->sections->data[i]; + + fwrite(s->name->data, s->name->len + 1, 1, elf->fp); + } + + fwrite(str, len, 1, elf->fp); + return 0; +} + +int elf32_write_sections(scf_elf_context_t* elf) +{ + elf_section_t* s; + elf_native_t* e = elf->priv; + + int i; + for (i = 0; i < e->sections->size; i++) { + s = e->sections->data[i]; + + scf_loge("sh->name: %s, data: %p, len: %d\n", s->name->data, s->data, s->data_len); + + if (s->data && s->data_len > 0) + fwrite(s->data, s->data_len, 1, elf->fp); + } + + return 0; +} + +int elf32_write_rel(scf_elf_context_t* elf, uint16_t e_machine) +{ + elf_native_t* e = elf->priv; + elf_section_t* s; + elf_sym_t* sym; + + int nb_sections = 1 + e->sections->size + 1 + 1 + 1; + uint64_t shstrtab = 1; + uint64_t strtab = 1; + uint64_t symtab = sizeof(Elf32_Sym ) * (e->symbols->size + 1); + Elf32_Off offset = sizeof(Elf32_Ehdr) + sizeof(Elf32_Shdr) * nb_sections; + + // write elf header + elf_header(&e->eh, ET_REL, e_machine, 0, 0, 0, nb_sections, nb_sections - 1); + fwrite (&e->eh, sizeof(e->eh), 1, elf->fp); + + // write null section header + fwrite(&e->sh_null, sizeof(e->sh_null), 1, elf->fp); + + // write user's section header + int i; + for (i = 0; i < e->sections->size; i++) { + s = e->sections->data[i]; + + if (SHT_RELA == s->sh.sh_type) + s->sh.sh_link = nb_sections - 3; + + section_header(&s->sh, shstrtab, 0, offset, + s->data_len, + s->sh.sh_link, + s->sh.sh_info, + s->sh.sh_entsize); + + s->sh.sh_addralign = 4; + + offset += s->data_len; + shstrtab += s->name->len + 1; + + fwrite(&s->sh, sizeof(s->sh), 1, elf->fp); + } + + // set user's symbols' name + int local_syms = 1; + + for (i = 0; i < e->symbols->size; i++) { + sym = e->symbols->data[i]; + + if (sym->name) { + sym->sym.st_name = strtab; + strtab += sym->name->len + 1; + } else + sym->sym.st_name = 0; + + if (STB_LOCAL == ELF32_ST_BIND(sym->sym.st_info)) + local_syms++; + } + + scf_loge("e->symbols->size: %d\n", e->symbols->size); + // .symtab header + section_header(&e->sh_symtab, shstrtab, 0, offset, symtab, nb_sections - 2, local_syms, sizeof(Elf32_Sym)); + + offset += symtab; + shstrtab += strlen(".symtab") + 1; + + // .strtab header + section_header(&e->sh_strtab, shstrtab, 0, offset, strtab, 0, 0, 0); + + offset += strtab; + shstrtab += strlen(".strtab") + 1; + + // .shstrtab header + uint64_t shstrtab_len = shstrtab + strlen(".shstrtab") + 1; + + section_header(&e->sh_shstrtab, shstrtab, 0, offset, shstrtab_len, 0, 0, 0); + + fwrite(&e->sh_symtab, sizeof(e->sh_symtab), 1, elf->fp); + fwrite(&e->sh_strtab, sizeof(e->sh_strtab), 1, elf->fp); + fwrite(&e->sh_shstrtab, sizeof(e->sh_shstrtab), 1, elf->fp); + + elf32_write_sections(elf); // write user's section data + + elf32_write_symtab (elf); // write .symtab data (user's symbols) + elf32_write_strtab (elf); // write .strtab data (symbol names of symtab) + elf32_write_shstrtab(elf); // write .shstrtab data (section names of all sections) + return 0; +} + +int elf32_sym_cmp(const void* v0, const void* v1) +{ + const elf_sym_t* sym0 = *(const elf_sym_t**)v0; + const elf_sym_t* sym1 = *(const elf_sym_t**)v1; + + if (STB_LOCAL == ELF32_ST_BIND(sym0->sym.st_info)) { + + if (STB_GLOBAL == ELF32_ST_BIND(sym1->sym.st_info)) + return -1; + + } else if (STB_LOCAL == ELF32_ST_BIND(sym1->sym.st_info)) + return 1; + + return 0; +} + +int elf32_find_sym(elf_sym_t** psym, Elf32_Rela* rela, scf_vector_t* symbols) +{ + elf_sym_t* sym; + elf_sym_t* sym2; + + int sym_idx = ELF32_R_SYM(rela->r_info); + int j; + + assert(sym_idx >= 1); + assert(sym_idx - 1 < symbols->size); + + sym = symbols->data[sym_idx - 1]; + + if (0 == sym->sym.st_shndx) { + + int n = 0; + + for (j = 0; j < symbols->size; j++) { + sym2 = symbols->data[j]; + + if (0 == sym2->sym.st_shndx) + continue; + + if (STB_LOCAL == ELF32_ST_BIND(sym2->sym.st_info)) + continue; + + if (!strcmp(sym2->name->data, sym->name->data)) { + sym = sym2; + sym_idx = j + 1; + n++; + } + } + + if (0 == n) { + scf_loge("global symbol: %s not found\n", sym->name->data); + return -1; + + } else if (n > 1) { + scf_loge("tow global symbol: %s\n", sym->name->data); + return -1; + } + } else if (ELF32_ST_TYPE(sym->sym.st_info) == STT_SECTION) { + + for (j = symbols->size - 1; j >= 0; j--) { + sym2 = symbols->data[j]; + + if (ELF32_ST_TYPE(sym2->sym.st_info) != STT_SECTION) + continue; + + if (sym2->sym.st_shndx == sym->sym.st_shndx) { + sym = sym2; + sym_idx = j + 1; + break; + } + } + + assert(j >= 0); + } + + *psym = sym; + return sym_idx; +} + +void elf32_process_syms(elf_native_t* e, uint32_t cs_index) +{ + elf_section_t* s; + Elf32_Rela* rela; + elf_sym_t* sym; + + int i; + int j; + int k; + int shndx = 20; +#if 1 + for (i = e->symbols->size - 1; i >= 0; i--) { + sym = e->symbols->data[i]; + + if (STT_SECTION == ELF32_ST_TYPE(sym->sym.st_info)) { + if (shndx > cs_index) { + + shndx = sym->sym.st_shndx; + + assert(sym->sym.st_shndx - 1 < e->sections->size); + + sym->section = e->sections->data[sym->sym.st_shndx - 1]; + continue; + } + } else if (0 != sym->sym.st_shndx) { + + if (sym->sym.st_shndx - 1 < e->sections->size) + sym->section = e->sections->data[sym->sym.st_shndx - 1]; + continue; + } + + assert(0 == scf_vector_del(e->symbols, sym)); + + scf_string_free(sym->name); + free(sym); + } +#endif + qsort(e->symbols->data, e->symbols->size, sizeof(void*), elf32_sym_cmp); + + for (j = 0; j < e->sections->size; j++) { + s = e->sections->data[j]; + + if (SHT_RELA != s->sh.sh_type) + continue; + + if (!strcmp(s->name->data, ".rela.plt")) + continue; + + assert(s->data_len % sizeof(Elf32_Rela) == 0); + + int sym_idx; + for (k = 0; k < s->data_len; k += sizeof(Elf32_Rela)) { + + rela = (Elf32_Rela*)(s->data + k); + + sym_idx = ELF32_R_SYM(rela->r_info); + + for (i = 0; i < e->symbols->size; i++) { + sym = e->symbols->data[i]; + + if (sym_idx == sym->index) + break; + } + + assert(i < e->symbols->size); + + rela->r_info = ELF32_R_INFO(i + 1, ELF32_R_TYPE(rela->r_info)); + } + } +} + diff --git a/elf/scf_elf_native32.h b/elf/scf_elf_native32.h new file mode 100644 index 0000000..ca53874 --- /dev/null +++ b/elf/scf_elf_native32.h @@ -0,0 +1,154 @@ +#ifndef SCF_ELF_NATIVE32_H +#define SCF_ELF_NATIVE32_H + +#include"scf_elf.h" +#include"scf_vector.h" +#include"scf_string.h" + +typedef struct elf_section_s elf_section_t; + +struct elf_section_s +{ + elf_section_t* link; + elf_section_t* info; + + scf_string_t* name; + + Elf32_Shdr sh; + + uint64_t offset; + + uint16_t index; + uint8_t* data; + int data_len; +}; + +typedef struct { + elf_section_t* section; + + scf_string_t* name; + + Elf32_Sym sym; + + int index; + uint8_t dyn_flag:1; + +} elf_sym_t; + +typedef struct { + Elf32_Ehdr eh; + + Elf32_Shdr sh_null; + + scf_vector_t* sections; + scf_vector_t* phdrs; + + Elf32_Shdr sh_symtab; + scf_vector_t* symbols; + + Elf32_Shdr sh_strtab; + + Elf32_Shdr sh_shstrtab; + scf_string_t* sh_shstrtab_data; + + scf_vector_t* dynsyms; + scf_vector_t* dyn_needs; + scf_vector_t* dyn_relas; + + elf_section_t* interp; + elf_section_t* dynsym; + elf_section_t* dynstr; + elf_section_t* gnu_version; + elf_section_t* gnu_version_r; + elf_section_t* rela_plt; + elf_section_t* plt; + elf_section_t* dynamic; + elf_section_t* got_plt; + +} elf_native_t; + + +int elf32_open (scf_elf_context_t* elf); +int elf32_close(scf_elf_context_t* elf); + +int elf32_add_sym (scf_elf_context_t* elf, const scf_elf_sym_t* sym, const char* sh_name); +int elf32_add_section (scf_elf_context_t* elf, const scf_elf_section_t* section); +int elf32_add_rela_section(scf_elf_context_t* elf, const scf_elf_section_t* section, scf_vector_t* relas); + +int elf32_read_shstrtab(scf_elf_context_t* elf); +int elf32_read_section (scf_elf_context_t* elf, scf_elf_section_t** psection, const char* name); + +int elf32_add_dyn_need(scf_elf_context_t* elf, const char* soname); +int elf32_add_dyn_rela(scf_elf_context_t* elf, const scf_elf_rela_t* rela); + +int elf32_read_phdrs (scf_elf_context_t* elf, scf_vector_t* phdrs); +int elf32_read_relas (scf_elf_context_t* elf, scf_vector_t* relas, const char* sh_name); +int elf32_read_syms (scf_elf_context_t* elf, scf_vector_t* syms, const char* sh_name); + +int elf32_find_sym (elf_sym_t** psym, Elf32_Rela* rela, scf_vector_t* symbols); +void elf32_process_syms(elf_native_t* native, uint32_t cs_index); + +int elf32_write_sections(scf_elf_context_t* elf); +int elf32_write_shstrtab(scf_elf_context_t* elf); +int elf32_write_symtab (scf_elf_context_t* elf); +int elf32_write_strtab (scf_elf_context_t* elf); +int elf32_write_rel (scf_elf_context_t* elf, uint16_t e_machine); + +int elf32_sym_cmp(const void* v0, const void* v1); + +static inline void elf_header(Elf32_Ehdr* eh, + uint16_t e_type, + uint16_t e_machine, + Elf32_Addr e_entry, + Elf32_Off e_phoff, + uint16_t e_phnum, + uint16_t e_shnum, + uint16_t e_shstrndx) +{ + eh->e_ident[EI_MAG0] = ELFMAG0; + eh->e_ident[EI_MAG1] = ELFMAG1; + eh->e_ident[EI_MAG2] = ELFMAG2; + eh->e_ident[EI_MAG3] = ELFMAG3; + eh->e_ident[EI_CLASS] = ELFCLASS32; + eh->e_ident[EI_DATA] = ELFDATA2LSB; + eh->e_ident[EI_VERSION] = EV_CURRENT; + eh->e_ident[EI_OSABI] = ELFOSABI_SYSV; + + eh->e_type = e_type; + eh->e_machine = e_machine; + eh->e_version = EV_CURRENT; + eh->e_entry = e_entry; + eh->e_ehsize = sizeof(Elf32_Ehdr); + + eh->e_flags = 0x5000400; + + eh->e_phoff = e_phoff; + eh->e_phentsize = sizeof(Elf32_Phdr); + eh->e_phnum = e_phnum; + + eh->e_shoff = sizeof(Elf32_Ehdr); + eh->e_shentsize = sizeof(Elf32_Shdr); + eh->e_shnum = e_shnum; + eh->e_shstrndx = e_shstrndx; +} + +static inline void section_header(Elf32_Shdr* sh, + uint32_t sh_name, + Elf32_Addr sh_addr, + Elf32_Off sh_offset, + uint64_t sh_size, + uint32_t sh_link, + uint32_t sh_info, + uint64_t sh_entsize) +{ + sh->sh_name = sh_name; + sh->sh_addr = sh_addr; + sh->sh_offset = sh_offset; + sh->sh_size = sh_size; + sh->sh_link = sh_link; + sh->sh_info = sh_info; + sh->sh_entsize = sh_entsize; +} + +#endif + diff --git a/lib/arm32/_start.o b/lib/arm32/_start.o new file mode 100644 index 0000000000000000000000000000000000000000..9aa371328d38637717764a97f28370f7fc47d570 GIT binary patch literal 684 zcma)4!AiqG5PfS}O+lpUQNc@vg0Oh-16rt_^y0~zY-qrOm6EKWCx5|D@ZY=$9{d5Z zzSm?l?L}Xhoq3bDGqamKot~dL=U{N?+jO#LnB4QdQ zca>m2rT69IG=_{m7L~uTsK{@9%pW5BIK%*-l_mV}^1_E0i%E7L^Rg=RkM)2WO}<`h zb*GEjYOXU1d$bO1KodS`8dLkUUpn!_n%nJ-$eXZRI$~1#zjViyW@a^1Z^sC|)stUq mMJ$v6 literal 0 HcmV?d00001 diff --git a/lib/arm32/_start.s b/lib/arm32/_start.s new file mode 100644 index 0000000..cc8b58a --- /dev/null +++ b/lib/arm32/_start.s @@ -0,0 +1,8 @@ +.text +.global _start, main + +_start: + bl main + mov r7, #1 + swi #0 +.fill 4, 1, 0 diff --git a/lib/arm32/lib/ld-linux-armhf.so.3 b/lib/arm32/lib/ld-linux-armhf.so.3 new file mode 100755 index 0000000000000000000000000000000000000000..27cf78968ddd6c12dc32ff94884fef59eea7abef GIT binary patch literal 110012 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⁡rh*&3fMi4 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≷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 literal 0 HcmV?d00001 diff --git a/lib/arm32/libc.so.6 b/lib/arm32/libc.so.6 new file mode 100755 index 0000000000000000000000000000000000000000..9a761550866994db9dcdeaedb6f70c2dca9a1b80 GIT binary patch literal 971712 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

_>`7$J_qr-ij`;m>v6UdXuGe{As+3UZq0ck`g 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
Ubf@Vc@gNcy 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 z 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 Q-c$&m*%9{~kJA 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 12 ) & 0xf) << 16) | (rd->id << 12) | (imm & 0xfff); + inst = risc_make_inst(c, opcode); + RISC_INST_ADD_CHECK(c->instructions, inst); + + imm >>= 16; + if (imm & 0xffff) { + + // movk rd, imm[31:16] + opcode = (0xe3 << 24) | (0x1 << 22) | (((imm >> 12 ) & 0xf) << 16) | (rd->id << 12) | (imm & 0xfff); + inst = risc_make_inst(c, opcode); + RISC_INST_ADD_CHECK(c->instructions, inst); + } + + return 0; +} + +int arm32_inst_ADR2G(scf_3ac_code_t* c, scf_function_t* f, scf_register_t* rd, scf_variable_t* vs) +{ + scf_register_t* fp = f->rops->find_register("fp"); + scf_instruction_t* inst = NULL; + scf_rela_t* rela = NULL; + + int64_t offset; + uint32_t opcode; + uint32_t SIZE = 0; + uint32_t S = 1; + + int size = f->rops->variable_size(vs); + + if (vs->local_flag || vs->tmp_flag) { + + offset = vs->bp_offset; + + if (offset >= 0 && offset <= 0xff) + + opcode = (0xe2 << 24) | (0x8 << 20) | (fp->id << 16) | (rd->id << 12) | offset; + + else if (offset < 0 && -offset <= 0xff) + + opcode = (0xe2 << 24) | (0x4 << 20) | (fp->id << 16) | (rd->id << 12) | (-offset); + + else { + int ret = arm32_inst_I2G(c, rd, offset, 4); + if (ret < 0) + return ret; + + opcode = (0xe0 << 24) | (0x8 << 20) | (fp->id << 16) | (rd->id << 12) | rd->id; + } + + inst = risc_make_inst(c, opcode); + RISC_INST_ADD_CHECK(c->instructions, inst); + + } else if (vs->global_flag) { + offset = 0; + + opcode = (0xe3 << 24) | (rd->id << 12); + inst = risc_make_inst(c, opcode); + RISC_INST_ADD_CHECK(c->instructions, inst); + RISC_RELA_ADD_CHECK(f->data_relas, rela, c, vs, NULL); + rela->type = R_ARM_REL32; + + opcode = (0xe3 << 24) | (0x4 << 20) | (rd->id << 12); + inst = risc_make_inst(c, opcode); + RISC_INST_ADD_CHECK(c->instructions, inst); + + opcode = (0xe7 << 24) | (0x9 << 20) | (rd->id << 16) | (rd->id << 12) | 0xf; + inst = risc_make_inst(c, opcode); + RISC_INST_ADD_CHECK(c->instructions, inst); + + opcode = (0xe0 << 24) | (0x8 << 20) | (rd->id << 16) | (rd->id << 12) | 0xf; + inst = risc_make_inst(c, opcode); + RISC_INST_ADD_CHECK(c->instructions, inst); + + } else { + scf_loge("temp var should give a register\n"); + return -EINVAL; + } + + return 0; +} + +int arm32_inst_M2G(scf_3ac_code_t* c, scf_function_t* f, scf_register_t* rd, scf_register_t* rb, scf_variable_t* vs) +{ + scf_register_t* fp = f->rops->find_register("fp"); + scf_register_t* ri = NULL; + scf_instruction_t* inst = NULL; + scf_rela_t* rela = NULL; + + int32_t offset; + uint32_t opcode; + + int size = f->rops->variable_size(vs); + + if (!rb) { + if (vs->local_flag || vs->tmp_flag) { + + offset = vs->bp_offset; + rb = fp; + + } else if (vs->global_flag) { + offset = 0; + + opcode = (0xe3 << 24) | (rd->id << 12); + inst = risc_make_inst(c, opcode); + RISC_INST_ADD_CHECK(c->instructions, inst); + RISC_RELA_ADD_CHECK(f->data_relas, rela, c, vs, NULL); + rela->type = R_ARM_REL32; + + opcode = (0xe3 << 24) | (0x4 << 20) | (rd->id << 12); + inst = risc_make_inst(c, opcode); + RISC_INST_ADD_CHECK(c->instructions, inst); + + opcode = (0xe7 << 24) | (0x9 << 20) | (rd->id << 16) | (rd->id << 12) | 0xf; + inst = risc_make_inst(c, opcode); + RISC_INST_ADD_CHECK(c->instructions, inst); + + opcode = (0xe0 << 24) | (0x8 << 20) | (rd->id << 16) | (rd->id << 12) | 0xf; + inst = risc_make_inst(c, opcode); + RISC_INST_ADD_CHECK(c->instructions, inst); + + rb = rd; + + } else { + scf_loge("temp var should give a register\n"); + return -EINVAL; + } + + } else { + if (vs->local_flag || vs->tmp_flag) + offset = vs->bp_offset; + else + offset = vs->offset; + } + + if (1 == size) { + + if (scf_variable_signed(vs)) { + + if (offset >= 0 && offset < 0xff) + opcode = (0xe1 << 24) | (0xd << 20) | (rb->id << 16) | (rd->id << 12) | (((offset & 0xf0) | 0xd) << 4) | (offset & 0xf); + + else if (offset < 0 && offset >= -0xff) { + offset = -offset; + opcode = (0xe1 << 24) | (0x5 << 20) | (rb->id << 16) | (rd->id << 12) | (((offset & 0xf0) | 0xd) << 4) | (offset & 0xf); + + } else { + int ret = risc_select_free_reg(&ri, c, f, 0); + if (ret < 0) { + scf_loge("\n"); + return -EINVAL; + } + + ret = arm32_inst_I2G(c, ri, offset, 4); + if (ret < 0) + return ret; + + opcode = (0xe1 << 24) | (0x9 << 20) | (rb->id << 16) | (rd->id << 12) | (0xd << 4) | ri->id; + } + + } else { + if (offset >= 0 && offset < 0xfff) + opcode = (0xe5 << 24) | (0xd << 20) | (rb->id << 16) | (rd->id << 12) | offset; + + else if (offset < 0 && offset >= -0xfff) { + offset = -offset; + opcode = (0xe5 << 24) | (0x5 << 20) | (rb->id << 16) | (rd->id << 12) | offset; + + } else { + int ret = risc_select_free_reg(&ri, c, f, 0); + if (ret < 0) { + scf_loge("\n"); + return -EINVAL; + } + + ret = arm32_inst_I2G(c, ri, offset, 4); + if (ret < 0) + return ret; + + opcode = (0xe7 << 24) | (0xd << 20) | (rb->id << 16) | (rd->id << 12) | ri->id; + } + } + + } else if (2 == size) { + + if (offset & 0x1) { + scf_loge("memory align error\n"); + return -EINVAL; + } + + if (offset >= 0 && offset < 0xff) + opcode = (0xe1 << 24) | (0xd << 20) | (rb->id << 16) | (rd->id << 12) | (((offset & 0xf0) | 0xb) << 4) | (offset & 0xf); + + else if (offset < 0 && offset >= -0xff) { + offset = -offset; + opcode = (0xe1 << 24) | (0x5 << 20) | (rb->id << 16) | (rd->id << 12) | (((offset & 0xf0) | 0xb) << 4) | (offset & 0xf); + + } else { + int ret = risc_select_free_reg(&ri, c, f, 0); + if (ret < 0) { + scf_loge("\n"); + return -EINVAL; + } + + ret = arm32_inst_I2G(c, ri, offset, 4); + if (ret < 0) + return ret; + + opcode = (0xe1 << 24) | (0x9 << 20) | (rb->id << 16) | (rd->id << 12) | (0xb << 4) | ri->id; + } + + if (scf_variable_signed(vs)) + opcode |= 0x1 << 6; + + } else if (4 == size) { + + if (offset & 0x3) { + scf_loge("memory align error\n"); + return -EINVAL; + } + + if (offset >= 0 && offset < 0xfff) + opcode = (0xe5 << 24) | (0x9 << 20) | (rb->id << 16) | (rd->id << 12) | offset; + + else if (offset < 0 && offset >= -0xfff) { + offset = -offset; + opcode = (0xe5 << 24) | (0x1 << 20) | (rb->id << 16) | (rd->id << 12) | offset; + + } else { + int ret = risc_select_free_reg(&ri, c, f, 0); + if (ret < 0) { + scf_loge("\n"); + return -EINVAL; + } + + ret = arm32_inst_I2G(c, ri, offset, 4); + if (ret < 0) + return ret; + + opcode = (0xe7 << 24) | (0x9 << 20) | (rb->id << 16) | (rd->id << 12) | ri->id; + } + + } else + return -EINVAL; + + inst = risc_make_inst(c, opcode); + RISC_INST_ADD_CHECK(c->instructions, inst); + return 0; +} + +int arm32_inst_G2M(scf_3ac_code_t* c, scf_function_t* f, scf_register_t* rs, scf_register_t* rb, scf_variable_t* vs) +{ + scf_register_t* fp = f->rops->find_register("fp"); + scf_register_t* ri = NULL; + scf_instruction_t* inst = NULL; + scf_rela_t* rela = NULL; + + int32_t offset; + uint32_t opcode; + + int size = f->rops->variable_size(vs); + + if (!rb) { + if (vs->local_flag || vs->tmp_flag) { + + offset = vs->bp_offset; + rb = fp; + + } else if (vs->global_flag) { + offset = 0; + + int ret = risc_select_free_reg(&rb, c, f, 0); + if (ret < 0) { + scf_loge("\n"); + return -EINVAL; + } + + ret = arm32_inst_ADR2G(c, f, rb, vs); + if (ret < 0) + return -EINVAL; + + } else { + scf_loge("temp var should give a register\n"); + return -EINVAL; + } + + } else { + if (vs->local_flag || vs->tmp_flag) + offset = vs->bp_offset; + else + offset = vs->offset; + } + + if (1 == size) { + + if (offset >= 0 && offset < 0xfff) + opcode = (0xe5 << 24) | (0xc << 20) | (rb->id << 16) | (rs->id << 12) | offset; + + else if (offset < 0 && offset >= -0xfff) { + offset = -offset; + opcode = (0xe5 << 24) | (0x4 << 20) | (rb->id << 16) | (rs->id << 12) | offset; + + } else { + int ret = risc_select_free_reg(&ri, c, f, 0); + if (ret < 0) { + scf_loge("\n"); + return -EINVAL; + } + + ret = arm32_inst_I2G(c, ri, offset, 4); + if (ret < 0) + return ret; + + opcode = (0xe7 << 24) | (0xc << 20) | (rb->id << 16) | (rs->id << 12) | ri->id; + } + + } else if (2 == size) { + + if (offset & 0x1) { + scf_loge("memory align error\n"); + return -EINVAL; + } + + if (offset >= 0 && offset < 0xff) + opcode = (0xe1 << 24) | (0xc << 20) | (rb->id << 16) | (rs->id << 12) | (((offset & 0xf0) | 0xb) << 4) | (offset & 0xf); + + else if (offset < 0 && offset >= -0xff) { + offset = -offset; + opcode = (0xe1 << 24) | (0x4 << 20) | (rb->id << 16) | (rs->id << 12) | (((offset & 0xf0) | 0xb) << 4) | (offset & 0xf); + + } else { + int ret = risc_select_free_reg(&ri, c, f, 0); + if (ret < 0) { + scf_loge("\n"); + return -EINVAL; + } + + ret = arm32_inst_I2G(c, ri, offset, 4); + if (ret < 0) + return ret; + + opcode = (0xe1 << 24) | (0x8 << 20) | (rb->id << 16) | (rs->id << 12) | (0xb << 4) | ri->id; + } + + } else if (4 == size) { + + if (offset & 0x3) { + scf_loge("memory align error\n"); + return -EINVAL; + } + + if (offset >= 0 && offset < 0xfff) + opcode = (0xe5 << 24) | (0x8 << 20) | (rb->id << 16) | (rs->id << 12) | offset; + + else if (offset < 0 && offset >= -0xfff) { + offset = -offset; + opcode = (0xe5 << 24) | (0x0 << 20) | (rb->id << 16) | (rs->id << 12) | offset; + + } else { + int ret = risc_select_free_reg(&ri, c, f, 0); + if (ret < 0) { + scf_loge("\n"); + return -EINVAL; + } + + ret = arm32_inst_I2G(c, ri, offset, 4); + if (ret < 0) + return ret; + + opcode = (0xe7 << 24) | (0x8 << 20) | (rb->id << 16) | (rs->id << 12) | ri->id; + } + + } else + return -EINVAL; + + inst = risc_make_inst(c, opcode); + RISC_INST_ADD_CHECK(c->instructions, inst); + + return 0; +} +//////// +int arm32_inst_ISTR2G(scf_3ac_code_t* c, scf_function_t* f, scf_register_t* rd, scf_variable_t* v) +{ + scf_instruction_t* inst = NULL; + scf_rela_t* rela = NULL; + + int size1 = f->rops->variable_size(v); + + assert(4 == rd->bytes); + assert(4 == size1); + + v->global_flag = 1; + v->local_flag = 0; + v->tmp_flag = 0; + + uint32_t opcode; + + opcode = (0xe3 << 24) | (rd->id << 12); + inst = risc_make_inst(c, opcode); + RISC_INST_ADD_CHECK(c->instructions, inst); + RISC_RELA_ADD_CHECK(f->data_relas, rela, c, v, NULL); + rela->type = R_ARM_REL32; + + opcode = (0xe3 << 24) | (0x4 << 20) | (rd->id << 12); + inst = risc_make_inst(c, opcode); + RISC_INST_ADD_CHECK(c->instructions, inst); + + opcode = (0xe7 << 24) | (0x9 << 20) | (rd->id << 16) | (rd->id << 12) | 0xf; + inst = risc_make_inst(c, opcode); + RISC_INST_ADD_CHECK(c->instructions, inst); + + opcode = (0xe0 << 24) | (0x8 << 20) | (rd->id << 16) | (rd->id << 12) | 0xf; + inst = risc_make_inst(c, opcode); + RISC_INST_ADD_CHECK(c->instructions, inst); + + return 0; +} + +int arm32_inst_G2P(scf_3ac_code_t* c, scf_function_t* f, scf_register_t* rs, scf_register_t* rb, int32_t offset, int size) +{ + scf_register_t* ri = NULL; + scf_instruction_t* inst = NULL; + + uint32_t opcode; + + if (!rb) + return -EINVAL; + + if (1 == size) { + + if (offset >= 0 && offset < 0xfff) + opcode = (0xe5 << 24) | (0xc << 20) | (rb->id << 16) | (rs->id << 12) | offset; + + else if (offset < 0 && offset >= -0xfff) { + offset = -offset; + opcode = (0xe5 << 24) | (0x4 << 20) | (rb->id << 16) | (rs->id << 12) | offset; + + } else { + int ret = risc_select_free_reg(&ri, c, f, 0); + if (ret < 0) { + scf_loge("\n"); + return -EINVAL; + } + + ret = arm32_inst_I2G(c, ri, offset, 4); + if (ret < 0) + return ret; + + opcode = (0xe7 << 24) | (0xc << 20) | (rb->id << 16) | (rs->id << 12) | ri->id; + } + + } else if (2 == size) { + + if (offset & 0x1) { + scf_loge("memory align error\n"); + return -EINVAL; + } + + if (offset >= 0 && offset < 0xff) + opcode = (0xe1 << 24) | (0xc << 20) | (rb->id << 16) | (rs->id << 12) | (((offset & 0xf0) | 0xb) << 4) | (offset & 0xf); + + else if (offset < 0 && offset >= -0xff) { + offset = -offset; + opcode = (0xe1 << 24) | (0x4 << 20) | (rb->id << 16) | (rs->id << 12) | (((offset & 0xf0) | 0xb) << 4) | (offset & 0xf); + + } else { + int ret = risc_select_free_reg(&ri, c, f, 0); + if (ret < 0) { + scf_loge("\n"); + return -EINVAL; + } + + ret = arm32_inst_I2G(c, ri, offset, 4); + if (ret < 0) + return ret; + + opcode = (0xe1 << 24) | (0x8 << 20) | (rb->id << 16) | (rs->id << 12) | (0xb << 4) | ri->id; + } + + } else if (4 == size) { + + if (offset & 0x3) { + scf_loge("memory align error\n"); + return -EINVAL; + } + + if (offset >= 0 && offset < 0xfff) + opcode = (0xe5 << 24) | (0x8 << 20) | (rb->id << 16) | (rs->id << 12) | offset; + + else if (offset < 0 && offset >= -0xfff) { + offset = -offset; + opcode = (0xe5 << 24) | (0x0 << 20) | (rb->id << 16) | (rs->id << 12) | offset; + + } else { + int ret = risc_select_free_reg(&ri, c, f, 0); + if (ret < 0) { + scf_loge("\n"); + return -EINVAL; + } + + ret = arm32_inst_I2G(c, ri, offset, 4); + if (ret < 0) + return ret; + + opcode = (0xe7 << 24) | (0x8 << 20) | (rb->id << 16) | (rs->id << 12) | ri->id; + } + + } else + return -EINVAL; + + inst = risc_make_inst(c, opcode); + RISC_INST_ADD_CHECK(c->instructions, inst); + + return 0; +} + +int arm32_inst_P2G(scf_3ac_code_t* c, scf_function_t* f, scf_register_t* rd, scf_register_t* rb, int32_t offset, int size) +{ + scf_register_t* ri = NULL; + scf_instruction_t* inst = NULL; + + uint32_t opcode; + uint32_t SIZE = 0; + uint32_t S = 1; + + if (!rb) + return -EINVAL; + + if (1 == size) { + + if (offset >= 0 && offset < 0xfff) + opcode = (0xe5 << 24) | (0xd << 20) | (rb->id << 16) | (rd->id << 12) | offset; + + else if (offset < 0 && offset >= -0xfff) { + offset = -offset; + opcode = (0xe5 << 24) | (0x5 << 20) | (rb->id << 16) | (rd->id << 12) | offset; + + } else { + int ret = risc_select_free_reg(&ri, c, f, 0); + if (ret < 0) { + scf_loge("\n"); + return -EINVAL; + } + + ret = arm32_inst_I2G(c, ri, offset, 4); + if (ret < 0) + return ret; + + opcode = (0xe7 << 24) | (0xd << 20) | (rb->id << 16) | (rd->id << 12) | ri->id; + } + + } else if (2 == size) { + + if (offset & 0x1) { + scf_loge("memory align error\n"); + return -EINVAL; + } + + if (offset >= 0 && offset < 0xff) + opcode = (0xe1 << 24) | (0xd << 20) | (rb->id << 16) | (rd->id << 12) | (((offset & 0xf0) | 0xb) << 4) | (offset & 0xf); + + else if (offset < 0 && offset >= -0xff) { + offset = -offset; + opcode = (0xe1 << 24) | (0x5 << 20) | (rb->id << 16) | (rd->id << 12) | (((offset & 0xf0) | 0xb) << 4) | (offset & 0xf); + + } else { + int ret = risc_select_free_reg(&ri, c, f, 0); + if (ret < 0) { + scf_loge("\n"); + return -EINVAL; + } + + ret = arm32_inst_I2G(c, ri, offset, 4); + if (ret < 0) + return ret; + + opcode = (0xe1 << 24) | (0x9 << 20) | (rb->id << 16) | (rd->id << 12) | (0xb << 4) | ri->id; + } + + } else if (4 == size) { + + if (offset & 0x3) { + scf_loge("memory align error\n"); + return -EINVAL; + } + + if (offset >= 0 && offset < 0xfff) + opcode = (0xe5 << 24) | (0x9 << 20) | (rb->id << 16) | (rd->id << 12) | offset; + + else if (offset < 0 && offset >= -0xfff) { + offset = -offset; + opcode = (0xe5 << 24) | (0x1 << 20) | (rb->id << 16) | (rd->id << 12) | offset; + + } else { + int ret = risc_select_free_reg(&ri, c, f, 0); + if (ret < 0) { + scf_loge("\n"); + return -EINVAL; + } + + ret = arm32_inst_I2G(c, ri, offset, 4); + if (ret < 0) + return ret; + + opcode = (0xe7 << 24) | (0x9 << 20) | (rb->id << 16) | (rd->id << 12) | ri->id; + } + + } else + return -EINVAL; + + inst = risc_make_inst(c, opcode); + RISC_INST_ADD_CHECK(c->instructions, inst); + return 0; +} + +int arm32_inst_ADRP2G(scf_3ac_code_t* c, scf_function_t* f, scf_register_t* rd, scf_register_t* rb, int32_t offset) +{ + scf_register_t* r = NULL; + scf_instruction_t* inst = NULL; + + uint32_t opcode = 0; + + if (offset >= 0 && offset <= 0xff) + opcode = (0xe2 << 24) | (0x8 << 20) | (rb->id << 16) | (rd->id << 12) | offset; + + else if (offset < 0 && offset >= -0xff) { + offset = -offset; + opcode = (0xe2 << 24) | (0x4 << 20) | (rb->id << 16) | (rd->id << 12) | offset; + + } else { + int ret = risc_select_free_reg(&r, c, f, 0); + if (ret < 0) + return ret; + + ret = arm32_inst_I2G(c, r, offset, 4); + if (ret < 0) + return ret; + + opcode = (0xe0 << 24) | (0x8 << 20) | (rb->id << 16) | (rd->id << 12) | r->id; + } + + inst = risc_make_inst(c, opcode); + RISC_INST_ADD_CHECK(c->instructions, inst); + return 0; +} + +int arm32_inst_ADRSIB2G(scf_3ac_code_t* c, scf_function_t* f, scf_register_t* rd, scf_sib_t* sib) +{ + scf_register_t* rb = sib->base; + scf_register_t* ri = sib->index; + scf_instruction_t* inst = NULL; + + assert(0 == sib->disp); + + if (!rb || !ri) + return -EINVAL; + + uint32_t opcode; + uint32_t SH; + + if (1 == sib->scale) + SH = 0; + + else if (2 == sib->scale) + SH = 1; + + else if (4 == sib->scale) + SH = 2; + else + return -EINVAL; + + opcode = (0xe0 << 24) | (0x8 << 20) | (rb->id << 16) | (rd->id << 12) | (SH << 7) | ri->id; + inst = risc_make_inst(c, opcode); + RISC_INST_ADD_CHECK(c->instructions, inst); + return 0; +} + +int arm32_inst_SIB2G(scf_3ac_code_t* c, scf_function_t* f, scf_register_t* rd, scf_sib_t* sib) +{ + scf_register_t* rb = sib->base; + scf_register_t* ri = sib->index; + scf_instruction_t* inst = NULL; + + assert(0 == sib->disp); + + if (!rb || !ri) + return -EINVAL; + + int scale = sib->scale; + int size = sib->size; + + uint32_t opcode; + + if (1 == size) + opcode = (0xe7 << 24) | (0xd << 20) | (rb->id << 16) | (rd->id << 12) | ri->id; + + else if (2 == size) + opcode = (0xf8 << 24) | (0x3 << 20) | (rb->id << 16) | (rd->id << 12) | (0x1 << 4) | ri->id; + + else if (4 == size) + opcode = (0xe7 << 24) | (0x9 << 20) | (rb->id << 16) | (rd->id << 12) | (0x2 << 7) | ri->id; + else + return -EINVAL; + + inst = risc_make_inst(c, opcode); + RISC_INST_ADD_CHECK(c->instructions, inst); + + return 0; +} + +int arm32_inst_G2SIB(scf_3ac_code_t* c, scf_function_t* f, scf_register_t* rs, scf_sib_t* sib) +{ + scf_register_t* rb = sib->base; + scf_register_t* ri = sib->index; + scf_instruction_t* inst = NULL; + + assert(0 == sib->disp); + + if (!rb || !ri) + return -EINVAL; + + int scale = sib->scale; + int size = sib->size; + + uint32_t opcode; + + if (1 == size) + opcode = (0xe7 << 24) | (0xc << 20) | (rb->id << 16) | (rs->id << 12) | ri->id; + + else if (2 == size) + opcode = (0xf8 << 24) | (0x2 << 20) | (rb->id << 16) | (rs->id << 12) | (0x1 << 4) | ri->id; + + else if (4 == size) + opcode = (0xe7 << 24) | (0x8 << 20) | (rb->id << 16) | (rs->id << 12) | (0x2 << 7) | ri->id; + else + return -EINVAL; + + inst = risc_make_inst(c, opcode); + RISC_INST_ADD_CHECK(c->instructions, inst); + + return 0; +} + +int arm32_inst_M2GF(scf_3ac_code_t* c, scf_function_t* f, scf_register_t* rd, scf_register_t* rb, scf_variable_t* vs) +{ + scf_register_t* fp = f->rops->find_register("fp"); + scf_register_t* ro = NULL; + scf_instruction_t* inst = NULL; + scf_rela_t* rela = NULL; + + int32_t offset; + uint32_t opcode; + uint32_t SIZE = 0; + uint32_t D = 0; + uint32_t V = 0; + + int size = f->rops->variable_size(vs); + + scf_loge("\n"); + return -EINVAL; + + if (!rb) { + if (vs->local_flag || vs->tmp_flag) { + + offset = vs->bp_offset; + rb = fp; + + } else if (vs->global_flag) { + offset = 0; + + int ret = risc_select_free_reg(&rb, c, f, 0); + if (ret < 0) + return ret; + + opcode = (0xe3 << 24) | (rb->id << 12); + inst = risc_make_inst(c, opcode); + RISC_INST_ADD_CHECK(c->instructions, inst); + RISC_RELA_ADD_CHECK(f->data_relas, rela, c, vs, NULL); + rela->type = R_ARM_REL32; + + opcode = (0xe3 << 24) | (0x4 << 20) | (rb->id << 12); + inst = risc_make_inst(c, opcode); + RISC_INST_ADD_CHECK(c->instructions, inst); + + opcode = (0xe7 << 24) | (0x9 << 20) | (rb->id << 16) | (rb->id << 12) | 0xf; + inst = risc_make_inst(c, opcode); + RISC_INST_ADD_CHECK(c->instructions, inst); + + opcode = (0xe0 << 24) | (0x8 << 20) | (rb->id << 16) | (rb->id << 12) | 0xf; + inst = risc_make_inst(c, opcode); + RISC_INST_ADD_CHECK(c->instructions, inst); + + } else { + scf_loge("temp var should give a register\n"); + return -EINVAL; + } + + } else { + if (vs->local_flag || vs->tmp_flag) + offset = vs->bp_offset; + else + offset = vs->offset; + } + + + if (2 == size) { + + if (offset & 0x1) { + scf_loge("memory align error\n"); + return -EINVAL; + } + + offset >>= 1; + SIZE = 1; + D = rd->id & 0x1; + V = rd->id >> 1; + + } else if (4 == size) { + + if (offset & 0x3) { + scf_loge("memory align error\n"); + return -EINVAL; + } + + offset >>= 2; + SIZE = 2; + D = rd->id & 0x1; + V = rd->id >> 1; + + } else if (8 == size) { + + if (offset & 0x7) { + scf_loge("memory align error\n"); + return -EINVAL; + } + + offset >>= 3; + SIZE = 3; + V = rd->id & 0xf; + D = (rd->id >> 4) & 0x1; + } else + return -EINVAL; + + if (offset >= 0 && offset < 0xff) + opcode = (0xed << 24) | (0x9 << 20) | (rb->id << 16) | (0x2 << 10) | (SIZE << 8) | offset; + + else if (offset < 0 && offset >= -0xff) { + offset = -offset; + opcode = (0xed << 24) | (0x1 << 20) | (rb->id << 16) | (0x2 << 10) | (SIZE << 8) | offset; + + } else { + int ret = risc_select_free_reg(&ro, c, f, 0); + if (ret < 0) + return ret; + + ret = arm32_inst_I2G(c, ro, offset, 4); + if (ret < 0) + return ret; + + opcode = (0xe0 << 24) | (0x8 << 20) | (rb->id << 16) | (ro->id << 12) | (SIZE << 7) | ro->id; + inst = risc_make_inst(c, opcode); + RISC_INST_ADD_CHECK(c->instructions, inst); + + opcode = (0xed << 24) | (0x9 << 20) | (ro->id << 16) | (0x2 << 10) | (SIZE << 8) | 0; + } + + opcode |= (D << 22) | (V << 12); + inst = risc_make_inst(c, opcode); + RISC_INST_ADD_CHECK(c->instructions, inst); + + return 0; +} + +scf_instruction_t* arm32_inst_PUSH(scf_3ac_code_t* c, scf_register_t* r) +{ + scf_instruction_t* inst; + uint32_t opcode; + + opcode = (0xe5 << 24) | (0x2 << 20) | (0xd << 16) | (r->id << 12) | 0x4; + inst = risc_make_inst(c, opcode); + + return inst; +} + +scf_instruction_t* arm32_inst_POP(scf_3ac_code_t* c, scf_register_t* r) +{ + scf_instruction_t* inst; + uint32_t opcode; + + opcode = (0xe4 << 24) | (0x9 << 20) | (0xd << 16) | (r->id << 12) | 0x4; + inst = risc_make_inst(c, opcode); + + return inst; +} + +scf_instruction_t* arm32_inst_RET(scf_3ac_code_t* c) +{ + scf_instruction_t* inst; + uint32_t opcode; + + opcode = 0xe12fff1e; + inst = risc_make_inst(c, opcode); + + return inst; +} + +scf_instruction_t* arm32_inst_MOV_SP(scf_3ac_code_t* c, scf_register_t* rd, scf_register_t* rs) +{ + scf_instruction_t* inst; + uint32_t opcode; + + opcode = (0xe1 << 24) | (0xa << 20) | (rd->id << 12) | rs->id; + inst = risc_make_inst(c, opcode); + + return inst; +} + +scf_instruction_t* arm32_inst_MOV_G(scf_3ac_code_t* c, scf_register_t* rd, scf_register_t* rs) +{ + scf_instruction_t* inst; + uint32_t opcode; + + opcode = (0xe1 << 24) | (0xa << 20) | (rd->id << 12) | rs->id; + inst = risc_make_inst(c, opcode); + + return inst; +} + +scf_instruction_t* arm32_inst_MVN(scf_3ac_code_t* c, scf_register_t* rd, scf_register_t* rs) +{ + scf_instruction_t* inst; + uint32_t opcode; + + opcode = (0xe1 << 24) | (0xe << 20) | (rd->id << 12) | rs->id; + inst = risc_make_inst(c, opcode); + + return inst; +} + +scf_instruction_t* arm32_inst_FMOV_G(scf_3ac_code_t* c, scf_register_t* rd, scf_register_t* rs) +{ + scf_instruction_t* inst; + uint32_t opcode; + + opcode = (0xee << 24) | (0xe << 20) | (rd->id << 12) | rs->id; + inst = risc_make_inst(c, opcode); + + return inst; +} + +scf_instruction_t* arm32_inst_MOVSX(scf_3ac_code_t* c, scf_register_t* rd, scf_register_t* rs, int size) +{ + scf_instruction_t* inst; + uint32_t opcode; + + if (1 == size) + opcode = (0xe6 << 24) | (0xa << 20) | (0xf << 16) | (rd->id << 12) | (0x7 << 4) | rs->id; + + else if (2 == size) + opcode = (0xe6 << 24) | (0xb << 20) | (0xf << 16) | (rd->id << 12) | (0x7 << 4) | rs->id; + else + return NULL; + + inst = risc_make_inst(c, opcode); + + return inst; +} + +scf_instruction_t* arm32_inst_MOVZX(scf_3ac_code_t* c, scf_register_t* rd, scf_register_t* rs, int size) +{ + scf_instruction_t* inst; + uint32_t opcode; + + if (1 == size) + opcode = (0xe6 << 24) | (0xe << 20) | (0xf << 16) | (rd->id << 12) | (0x7 << 4) | rs->id; + + else if (2 == size) + opcode = (0xe6 << 24) | (0xf << 20) | (0xf << 16) | (rd->id << 12) | (0x7 << 4) | rs->id; + else + return NULL; + + inst = risc_make_inst(c, opcode); + + return inst; +} + +scf_instruction_t* arm32_inst_CVTSS2SD(scf_3ac_code_t* c, scf_register_t* rd, scf_register_t* rs) +{ + scf_instruction_t* inst; + uint32_t opcode; + + uint32_t M = rs->id & 0x1; + uint32_t Vm = rs->id >> 1; + uint32_t D = rd->id >> 4; + uint32_t Vd = rd->id & 0xf; + + opcode = (0xee << 24) | (0xb7 << 16) | (0xa << 8) | (0xc << 4) | (D << 22) | (Vd << 12) | (M << 5) | Vm; + inst = risc_make_inst(c, opcode); + + return inst; +} + +scf_instruction_t* arm32_inst_CVTSD2SS(scf_3ac_code_t* c, scf_register_t* rd, scf_register_t* rs) +{ + scf_instruction_t* inst; + uint32_t opcode; + + uint32_t M = rd->id >> 4; + uint32_t Vm = rd->id & 0xf; + uint32_t D = rs->id & 0x1; + uint32_t Vd = rs->id >> 1; + + opcode = (0xee << 24) | (0xb7 << 16) | (0xb << 8) | (0xc << 4) | (D << 22) | (Vd << 12) | (M << 5) | Vm; + inst = risc_make_inst(c, opcode); + + return inst; +} + +scf_instruction_t* arm32_inst_CVTF2SI(scf_3ac_code_t* c, scf_register_t* rd, scf_register_t* rs) +{ + scf_instruction_t* inst; + uint32_t opcode; + + uint32_t M = rs->id & 0x1; + uint32_t Vm = rs->id >> 1; + uint32_t D = 15 >> 4; + uint32_t Vd = 15 & 0xf; + uint32_t SZ = (8 == rs->bytes) ? 0x3 : 0x2; + + opcode = (0xee << 24) | (0xb << 20) | (D << 22) | (0xd << 16) | (Vd << 12) | (0x2 << 10) | (SZ << 8) | (0x3 << 6) | (M << 5) | Vm; + inst = risc_make_inst(c, opcode); + if (!inst) + return NULL; + + if (scf_vector_add(c->instructions, inst) < 0) { + free(inst); + return NULL; + } + + opcode = (0xee << 24) | (0x1 << 20) | (Vd << 16) | (rd->id << 12) | (0xa << 8) | (D << 7) | (0x1 << 4); + inst = risc_make_inst(c, opcode); + return inst; +} + +scf_instruction_t* arm32_inst_CVTF2UI(scf_3ac_code_t* c, scf_register_t* rd, scf_register_t* rs) +{ + scf_instruction_t* inst; + uint32_t opcode; + + uint32_t M = rs->id & 0x1; + uint32_t Vm = rs->id >> 1; + uint32_t D = 15 >> 4; + uint32_t Vd = 15 & 0xf; + uint32_t SZ = (8 == rs->bytes) ? 0x3 : 0x2; + + opcode = (0xee << 24) | (0xb << 20) | (D << 22) | (0xc << 16) | (Vd << 12) | (0x2 << 10) | (SZ << 8) | (0x3 << 6) | (M << 5) | Vm; + inst = risc_make_inst(c, opcode); + if (!inst) + return NULL; + + if (scf_vector_add(c->instructions, inst) < 0) { + free(inst); + return NULL; + } + + opcode = (0xee << 24) | (0x1 << 20) | (Vd << 16) | (rd->id << 12) | (0xa << 8) | (D << 7) | (0x1 << 4); + inst = risc_make_inst(c, opcode); + return inst; +} + +scf_instruction_t* arm32_inst_CVTSI2F(scf_3ac_code_t* c, scf_register_t* rd, scf_register_t* rs) +{ + scf_instruction_t* inst; + uint32_t opcode; + + uint32_t D = rs->id & 0x1; + uint32_t Vd = rs->id >> 1; + uint32_t M = 15 >> 4; + uint32_t Vm = 15 & 0xf; + uint32_t SZ = (8 == rd->bytes) ? 0x3 : 0x2; + + opcode = (0xee << 24) | (0x0 << 20) | (Vm << 16) | (rd->id << 12) | (0xa << 8) | (M << 7) | (0x1 << 4); + inst = risc_make_inst(c, opcode); + if (!inst) + return NULL; + + if (scf_vector_add(c->instructions, inst) < 0) { + free(inst); + return NULL; + } + + opcode = (0xee << 24) | (0xb << 20) | (D << 22) | (0x8 << 16) | (Vd << 12) | (0x2 << 10) | (SZ << 8) | (0x3 << 6) | (M << 5) | Vm; + inst = risc_make_inst(c, opcode); + + return inst; +} + +scf_instruction_t* arm32_inst_CVTUI2F(scf_3ac_code_t* c, scf_register_t* rd, scf_register_t* rs) +{ + scf_instruction_t* inst; + uint32_t opcode; + + uint32_t D = rs->id & 0x1; + uint32_t Vd = rs->id >> 1; + uint32_t M = 15 >> 4; + uint32_t Vm = 15 & 0xf; + uint32_t SZ = (8 == rd->bytes) ? 0x3 : 0x2; + + opcode = (0xee << 24) | (0x0 << 20) | (Vm << 16) | (rd->id << 12) | (0xa << 8) | (M << 7) | (0x1 << 4); + inst = risc_make_inst(c, opcode); + if (!inst) + return NULL; + + if (scf_vector_add(c->instructions, inst) < 0) { + free(inst); + return NULL; + } + + opcode = (0xee << 24) | (0xb << 20) | (D << 22) | (0x8 << 16) | (Vd << 12) | (0x2 << 10) | (SZ << 8) | (0x1 << 6) | (M << 5) | Vm; + inst = risc_make_inst(c, opcode); + + return inst; +} + +scf_instruction_t* arm32_inst_SUB_IMM(scf_3ac_code_t* c, scf_register_t* rd, scf_register_t* rs, uint64_t imm) +{ + scf_instruction_t* inst; + uint32_t opcode; + uint32_t sh = 0; + + if (imm > 0xff) { + scf_loge("NOT support too big imm: %#lx\n", imm); + return NULL; + } + + opcode = (0xe2 << 24) | (0x4 << 20) | (rs->id << 16) | (rd->id << 12) | imm; + inst = risc_make_inst(c, opcode); + + return inst; +} + +scf_instruction_t* arm32_inst_CMP_IMM(scf_3ac_code_t* c, scf_register_t* rs, uint64_t imm) +{ + scf_instruction_t* inst; + uint32_t opcode; + uint32_t sh = 0; + + if (imm > 0xff) { + scf_loge("NOT support too big imm: %#lx\n", imm); + return NULL; + } + + opcode = (0xe3 << 24) | (0x5 << 20) | (rs->id << 16) | imm; + inst = risc_make_inst(c, opcode); + + return inst; +} + +scf_instruction_t* arm32_inst_ADD_IMM(scf_3ac_code_t* c, scf_register_t* rd, scf_register_t* rs, uint64_t imm) +{ + scf_instruction_t* inst; + uint32_t opcode; + uint32_t sh = 0; + + if (imm > 0xff) { + scf_loge("NOT support too big imm: %#lx\n", imm); + return NULL; + } + + opcode = (0xe2 << 24) | (0x8 << 20) | (rs->id << 16) | (rd->id << 12) | imm; + inst = risc_make_inst(c, opcode); + + return inst; +} + +scf_instruction_t* arm32_inst_ADD_G(scf_3ac_code_t* c, scf_register_t* rd, scf_register_t* rs0, scf_register_t* rs1) +{ + scf_instruction_t* inst; + uint32_t opcode; + + opcode = (0xe0 << 24) | (0x8 << 20) | (rs0->id << 16) | (rd->id << 12) | rs1->id; + inst = risc_make_inst(c, opcode); + + return inst; +} + +scf_instruction_t* arm32_inst_SHL(scf_3ac_code_t* c, scf_register_t* rd, scf_register_t* rs0, scf_register_t* rs1) +{ + scf_instruction_t* inst; + uint32_t opcode; + + opcode = (0xe1 << 24) | (0xa << 20) | (rd->id << 12) | (rs1->id << 8) | (0x1 << 4) | rs0->id; + inst = risc_make_inst(c, opcode); + + return inst; +} + +scf_instruction_t* arm32_inst_SHR(scf_3ac_code_t* c, scf_register_t* rd, scf_register_t* rs0, scf_register_t* rs1) +{ + scf_instruction_t* inst; + uint32_t opcode; + + opcode = (0xe1 << 24) | (0xa << 20) | (rd->id << 12) | (rs1->id << 8) | (0x3 << 4) | rs0->id; + inst = risc_make_inst(c, opcode); + + return inst; +} + +scf_instruction_t* arm32_inst_ASR(scf_3ac_code_t* c, scf_register_t* rd, scf_register_t* rs0, scf_register_t* rs1) +{ + scf_instruction_t* inst; + uint32_t opcode; + + opcode = (0xe1 << 24) | (0xa << 20) | (rd->id << 12) | (rs1->id << 8) | (0x5 << 4) | rs0->id; + inst = risc_make_inst(c, opcode); + + return inst; +} + +scf_instruction_t* arm32_inst_AND_G(scf_3ac_code_t* c, scf_register_t* rd, scf_register_t* rs0, scf_register_t* rs1) +{ + scf_instruction_t* inst; + uint32_t opcode; + + opcode = (0xe0 << 24) | (0x0 << 20) | (rs0->id << 16) | (rd->id << 12) | rs1->id; + inst = risc_make_inst(c, opcode); + + return inst; +} + +scf_instruction_t* arm32_inst_OR_G(scf_3ac_code_t* c, scf_register_t* rd, scf_register_t* rs0, scf_register_t* rs1) +{ + scf_instruction_t* inst; + uint32_t opcode; + + opcode = (0xe1 << 24) | (0x8 << 20) | (rs0->id << 16) | (rd->id << 12) | rs1->id; + inst = risc_make_inst(c, opcode); + + return inst; +} + +scf_instruction_t* arm32_inst_SUB_G(scf_3ac_code_t* c, scf_register_t* rd, scf_register_t* rs0, scf_register_t* rs1) +{ + scf_instruction_t* inst; + uint32_t opcode; + + opcode = (0xe0 << 24) | (0x4 << 20) | (rs0->id << 16) | (rd->id << 12) | rs1->id; + inst = risc_make_inst(c, opcode); + + return inst; +} + +scf_instruction_t* arm32_inst_CMP_G(scf_3ac_code_t* c, scf_register_t* rs0, scf_register_t* rs1) +{ + scf_instruction_t* inst; + uint32_t opcode; + + opcode = (0xe1 << 24) | (0x5 << 20) | (rs0->id << 16) | rs1->id; + inst = risc_make_inst(c, opcode); + + return inst; +} + +scf_instruction_t* arm32_inst_FCMP(scf_3ac_code_t* c, scf_register_t* rs0, scf_register_t* rs1) +{ + scf_instruction_t* inst; + uint32_t opcode; + uint32_t D; + uint32_t M; + uint32_t Vd; + uint32_t Vm; + uint32_t SIZE; + + if (8 == rs0->bytes) { + D = rs0->id >> 4; + Vd = rs0->id & 0xf; + + M = rs1->id >> 4; + Vm = rs1->id & 0xf; + + SIZE = 3; + + } else { + D = rs0->id & 0x1; + Vd = rs0->id >> 1; + + M = rs1->id & 0x1; + Vm = rs1->id >> 1; + + SIZE = 2; + } + + opcode = (0xee << 24) | (0x1 << 23) | (D << 22) | (0x3 << 20) | (0x4 << 16) | (Vd << 12) | (0x2 << 10) | (SIZE << 8) | (0x1 << 6) | (M << 5) | Vm; + inst = risc_make_inst(c, opcode); + + return inst; +} + +scf_instruction_t* arm32_inst_NEG(scf_3ac_code_t* c, scf_register_t* rd, scf_register_t* rs) +{ + scf_instruction_t* inst; + uint32_t opcode; + + opcode = (0xe1 << 24) | (0x3 << 20) | (rs->id << 16) | rs->id; + inst = risc_make_inst(c, opcode); + + return inst; +} + +scf_instruction_t* arm32_inst_TEQ(scf_3ac_code_t* c, scf_register_t* rs) +{ + scf_instruction_t* inst; + uint32_t opcode; + + opcode = (0xe1 << 24) | (0x3 << 20) | (rs->id << 16) | rs->id; + inst = risc_make_inst(c, opcode); + + return inst; +} + +scf_instruction_t* arm32_inst_FADD(scf_3ac_code_t* c, scf_register_t* rd, scf_register_t* rs0, scf_register_t* rs1) +{ + scf_instruction_t* inst; + uint32_t opcode; + uint32_t D; + uint32_t M; + uint32_t N; + uint32_t Vd; + uint32_t Vm; + uint32_t Vn; + uint32_t SIZE; + + if (8 == rd->bytes) { + D = rd->id >> 4; + Vd = rd->id & 0xf; + + M = rs1->id >> 4; + Vm = rs1->id & 0xf; + + N = rs0->id >> 4; + Vn = rs0->id & 0xf; + + SIZE = 3; + + } else { + D = rd->id & 0x1; + Vd = rd->id >> 1; + + M = rs1->id & 0x1; + Vm = rs1->id >> 1; + + N = rs0->id & 0x1; + Vn = rs0->id >> 1; + + SIZE = 2; + } + + opcode = (0xee << 24) | (D << 22) | (0x3 << 20) | (Vn << 16) | (Vd << 12) | (0x2 << 10) | (SIZE << 8) | (N << 7) | (M << 5) | Vm; + inst = risc_make_inst(c, opcode); + + return inst; +} + +scf_instruction_t* arm32_inst_FSUB(scf_3ac_code_t* c, scf_register_t* rd, scf_register_t* rs0, scf_register_t* rs1) +{ + scf_instruction_t* inst; + uint32_t opcode; + uint32_t D; + uint32_t M; + uint32_t N; + uint32_t Vd; + uint32_t Vm; + uint32_t Vn; + uint32_t SIZE; + + if (8 == rd->bytes) { + D = rd->id >> 4; + Vd = rd->id & 0xf; + + M = rs1->id >> 4; + Vm = rs1->id & 0xf; + + N = rs0->id >> 4; + Vn = rs0->id & 0xf; + + SIZE = 3; + + } else { + D = rd->id & 0x1; + Vd = rd->id >> 1; + + M = rs1->id & 0x1; + Vm = rs1->id >> 1; + + N = rs0->id & 0x1; + Vn = rs0->id >> 1; + + SIZE = 2; + } + + opcode = (0xee << 24) | (D << 22) | (0x3 << 20) | (Vn << 16) | (Vd << 12) | (0x2 << 10) | (SIZE << 8) | (N << 7) | (0x1 << 6) | (M << 5) | Vm; + inst = risc_make_inst(c, opcode); + + return inst; +} + +scf_instruction_t* arm32_inst_MUL(scf_3ac_code_t* c, scf_register_t* rd, scf_register_t* rs0, scf_register_t* rs1) +{ + scf_instruction_t* inst; + uint32_t opcode; + + opcode = (0xe0 << 24) | (rd->id << 16) | (rs1->id << 8) | (0x9 << 4) | rs0->id; + inst = risc_make_inst(c, opcode); + + return inst; +} + +scf_instruction_t* arm32_inst_FMUL(scf_3ac_code_t* c, scf_register_t* rd, scf_register_t* rs0, scf_register_t* rs1) +{ + scf_instruction_t* inst; + uint32_t opcode; + uint32_t D; + uint32_t M; + uint32_t N; + uint32_t Vd; + uint32_t Vm; + uint32_t Vn; + uint32_t SIZE; + + if (8 == rd->bytes) { + D = rd->id >> 4; + Vd = rd->id & 0xf; + + M = rs1->id >> 4; + Vm = rs1->id & 0xf; + + N = rs0->id >> 4; + Vn = rs0->id & 0xf; + + SIZE = 3; + + } else { + D = rd->id & 0x1; + Vd = rd->id >> 1; + + M = rs1->id & 0x1; + Vm = rs1->id >> 1; + + N = rs0->id & 0x1; + Vn = rs0->id >> 1; + + SIZE = 2; + } + + opcode = (0xee << 24) | (0x0 << 23) | (D << 22) | (0x1 << 21) | (Vn << 16) | (Vd << 12) | (0x2 << 10) | (SIZE << 8) | (N << 7) | (M << 5) | Vm; + inst = risc_make_inst(c, opcode); + + return inst; +} + +scf_instruction_t* arm32_inst_FDIV(scf_3ac_code_t* c, scf_register_t* rd, scf_register_t* rs0, scf_register_t* rs1) +{ + scf_instruction_t* inst; + uint32_t opcode; + uint32_t D; + uint32_t M; + uint32_t N; + uint32_t Vd; + uint32_t Vm; + uint32_t Vn; + uint32_t SIZE; + + if (8 == rd->bytes) { + D = rd->id >> 4; + Vd = rd->id & 0xf; + + M = rs1->id >> 4; + Vm = rs1->id & 0xf; + + N = rs0->id >> 4; + Vn = rs0->id & 0xf; + + SIZE = 3; + + } else { + D = rd->id & 0x1; + Vd = rd->id >> 1; + + M = rs1->id & 0x1; + Vm = rs1->id >> 1; + + N = rs0->id & 0x1; + Vn = rs0->id >> 1; + + SIZE = 2; + } + + opcode = (0xee << 24) | (0x1 << 23) | (D << 22) | (Vn << 16) | (Vd << 12) | (0x2 << 10) | (SIZE << 8) | (N << 7) | (M << 5) | Vm; + inst = risc_make_inst(c, opcode); + + return inst; +} + +scf_instruction_t* arm32_inst_DIV(scf_3ac_code_t* c, scf_register_t* rd, scf_register_t* rs0, scf_register_t* rs1) +{ + scf_instruction_t* inst; + uint32_t opcode; + + opcode = (0xe7 << 24) | (0x3 << 20) | (rd->id << 16) | (0xf << 12) | (rs1->id << 8) | (0x1 << 4) | rs0->id; + inst = risc_make_inst(c, opcode); + + return inst; +} + +scf_instruction_t* arm32_inst_SDIV(scf_3ac_code_t* c, scf_register_t* rd, scf_register_t* rs0, scf_register_t* rs1) +{ + scf_instruction_t* inst; + uint32_t opcode; + + opcode = (0xe7 << 24) | (0x1 << 20) | (rd->id << 16) | (0xf << 12) | (rs1->id << 8) | (0x1 << 4) | rs0->id; + inst = risc_make_inst(c, opcode); + + return inst; +} + +scf_instruction_t* arm32_inst_MSUB(scf_3ac_code_t* c, scf_register_t* rd, scf_register_t* rm, scf_register_t* rn, scf_register_t* ra) +{ + scf_instruction_t* inst; + uint32_t opcode; + + opcode = (0xe0 << 24) | (0x6 << 20) | (rd->id << 16) | (ra->id << 12) | (rm->id << 8) | (0x9 << 4) | rn->id; + inst = risc_make_inst(c, opcode); + + return inst; +} + +int arm32_inst_BL(scf_3ac_code_t* c, scf_function_t* f, scf_function_t* pf) +{ + scf_instruction_t* inst; + scf_rela_t* rela; + uint32_t opcode; + + opcode = 0xeb << 24; + inst = risc_make_inst(c, opcode); + + RISC_INST_ADD_CHECK(c->instructions, inst); + RISC_RELA_ADD_CHECK(f->text_relas, rela, c, NULL, pf); + + rela->type = R_ARM_CALL; + return 0; +} + +scf_instruction_t* arm32_inst_BLR(scf_3ac_code_t* c, scf_register_t* r) +{ + scf_instruction_t* inst; + uint32_t opcode; + + opcode = 0xe12fff30 | r->id; + inst = risc_make_inst(c, opcode); + + return inst; +} + +scf_instruction_t* arm32_inst_SETZ(scf_3ac_code_t* c, scf_register_t* rd) +{ + scf_instruction_t* inst; + uint32_t opcode; + uint32_t cc = 1; + + opcode = ((8 == rd->bytes) << 1) | (0x1a << 24) | (0x1 << 23) | (0x1f << 16) | (cc << 12) | (0x3f << 5) | rd->id; + inst = risc_make_inst(c, opcode); + + return inst; +} +scf_instruction_t* arm32_inst_SETNZ(scf_3ac_code_t* c, scf_register_t* rd) +{ + scf_instruction_t* inst; + uint32_t opcode; + uint32_t cc = 0; + + opcode = ((8 == rd->bytes) << 1) | (0x1a << 24) | (0x1 << 23) | (0x1f << 16) | (cc << 12) | (0x3f << 5) | rd->id; + inst = risc_make_inst(c, opcode); + + return inst; +} +scf_instruction_t* arm32_inst_SETGT(scf_3ac_code_t* c, scf_register_t* rd) +{ + scf_instruction_t* inst; + uint32_t opcode; + uint32_t cc = 0xd; + + opcode = ((8 == rd->bytes) << 1) | (0x1a << 24) | (0x1 << 23) | (0x1f << 16) | (cc << 12) | (0x3f << 5) | rd->id; + inst = risc_make_inst(c, opcode); + + return inst; +} +scf_instruction_t* arm32_inst_SETGE(scf_3ac_code_t* c, scf_register_t* rd) +{ + scf_instruction_t* inst; + uint32_t opcode; + uint32_t cc = 0xb; + + opcode = ((8 == rd->bytes) << 1) | (0x1a << 24) | (0x1 << 23) | (0x1f << 16) | (cc << 12) | (0x3f << 5) | rd->id; + inst = risc_make_inst(c, opcode); + + return inst; +} +scf_instruction_t* arm32_inst_SETLT(scf_3ac_code_t* c, scf_register_t* rd) +{ + scf_instruction_t* inst; + uint32_t opcode; + uint32_t cc = 0xa; + + opcode = ((8 == rd->bytes) << 1) | (0x1a << 24) | (0x1 << 23) | (0x1f << 16) | (cc << 12) | (0x3f << 5) | rd->id; + inst = risc_make_inst(c, opcode); + + return inst; +} +scf_instruction_t* arm32_inst_SETLE(scf_3ac_code_t* c, scf_register_t* rd) +{ + scf_instruction_t* inst; + uint32_t opcode; + uint32_t cc = 0xc; + + opcode = ((8 == rd->bytes) << 1) | (0x1a << 24) | (0x1 << 23) | (0x1f << 16) | (cc << 12) | (0x3f << 5) | rd->id; + inst = risc_make_inst(c, opcode); + + return inst; +} + +scf_instruction_t* arm32_inst_JMP(scf_3ac_code_t* c) +{ + scf_instruction_t* inst; + uint32_t opcode; + + opcode = 0xea000000; + inst = risc_make_inst(c, opcode); + + return inst; +} + +scf_instruction_t* arm32_inst_JZ(scf_3ac_code_t* c) +{ + scf_instruction_t* inst; + uint32_t opcode; + + opcode = 0x0a000000; + inst = risc_make_inst(c, opcode); + + return inst; +} + +scf_instruction_t* arm32_inst_JNZ(scf_3ac_code_t* c) +{ + scf_instruction_t* inst; + uint32_t opcode; + + opcode = 0x1a000000; + inst = risc_make_inst(c, opcode); + + return inst; +} + +scf_instruction_t* arm32_inst_JGT(scf_3ac_code_t* c) +{ + scf_instruction_t* inst; + uint32_t opcode; + + opcode = 0xca000000; + inst = risc_make_inst(c, opcode); + + return inst; +} + +scf_instruction_t* arm32_inst_JGE(scf_3ac_code_t* c) +{ + scf_instruction_t* inst; + uint32_t opcode; + + opcode = 0xaa000000; + inst = risc_make_inst(c, opcode); + + return inst; +} + +scf_instruction_t* arm32_inst_JLT(scf_3ac_code_t* c) +{ + scf_instruction_t* inst; + uint32_t opcode; + + opcode = 0xba000000; + inst = risc_make_inst(c, opcode); + + return inst; +} + +scf_instruction_t* arm32_inst_JLE(scf_3ac_code_t* c) +{ + scf_instruction_t* inst; + uint32_t opcode; + + opcode = 0xda000000; + inst = risc_make_inst(c, opcode); + + return inst; +} + +scf_instruction_t* arm32_inst_JA(scf_3ac_code_t* c) +{ + return NULL; +} +scf_instruction_t* arm32_inst_JB(scf_3ac_code_t* c) +{ + return NULL; +} +scf_instruction_t* arm32_inst_JAE(scf_3ac_code_t* c) +{ + return NULL; +} +scf_instruction_t* arm32_inst_JBE(scf_3ac_code_t* c) +{ + return NULL; +} + +void arm32_set_jmp_offset(scf_instruction_t* inst, int32_t bytes) +{ + bytes -= 8; // 'pc = current + 8' + bytes >>= 2; + + assert(bytes < 0x7fffff && bytes > -0x7fffff); + + inst->code[0] |= 0xff & bytes; + inst->code[1] |= 0xff & (bytes >> 8); + inst->code[2] |= 0xff & (bytes >> 16); +} + +int arm32_cmp_update(scf_3ac_code_t* c, scf_function_t* f, scf_instruction_t* cmp) +{ + scf_instruction_t* inst; + scf_register_t* r12 = f->rops->find_register_type_id_bytes(0, 12, 4); + scf_register_t* r14 = f->rops->find_register_type_id_bytes(0, 14, 4); + scf_register_t* r0; + + uint32_t opcode; + uint32_t mov; + uint32_t i0; + uint32_t i1; + + opcode = cmp->code[0]; + opcode |= cmp->code[1] << 8; + opcode |= cmp->code[2] << 16; + opcode |= cmp->code[3] << 24; + + switch (cmp->code[3]) { + // arm32 + case 0xe3: // imm + i0 = (opcode >> 16) & 0xf; + r0 = f->rops->find_register_type_id_bytes(0, i0, 4); + inst = f->iops->MOV_G(c, r12, r0); // use r12 to backup r0 + RISC_INST_ADD_CHECK(c->instructions, inst); + + opcode &= ~(0xf << 16); + opcode |= (0xc << 16); + break; + + case 0xe1: // register + i0 = (opcode >> 16) & 0xf; + i1 = (opcode ) & 0xf; + + r0 = f->rops->find_register_type_id_bytes(0, i0, 4); + inst = f->iops->MOV_G(c, r12, r0); // use r16 to backup r0 + RISC_INST_ADD_CHECK(c->instructions, inst); + + r0 = f->rops->find_register_type_id_bytes(0, i1, 4); + inst = f->iops->MOV_G(c, r14, r0); // use r17 to backup r1 + RISC_INST_ADD_CHECK(c->instructions, inst); + + opcode &= ~(0xf << 16); + opcode |= (0xc << 16); + + opcode &= ~0xf; + opcode |= 0xe; + break; + default: + scf_loge("%#x\n", opcode); + return -EINVAL; + break; + }; + + cmp->code[0] = 0xff & opcode; + cmp->code[1] = 0xff & (opcode >> 8); + cmp->code[2] = 0xff & (opcode >> 16); + cmp->code[3] = 0xff & (opcode >> 24); + return 0; +} + +int arm32_set_rel_veneer(scf_function_t* f) +{ + scf_basic_block_t* bb; + scf_instruction_t* inst; + scf_3ac_code_t* c; + scf_3ac_code_t* end; + scf_list_t* l; + scf_rela_t* r; + + int bytes = f->init_code_bytes; + + for (l = scf_list_head(&f->basic_block_list_head); l != scf_list_sentinel(&f->basic_block_list_head); l = scf_list_next(l)) { + bb = scf_list_data(l, scf_basic_block_t, list); + + bytes += bb->code_bytes; + } + + l = scf_list_tail(&bb->code_list_head); + end = scf_list_data(l, scf_3ac_code_t, list); + + int i; + for (i = 0; i < f->data_relas->size; i++) { + r = f->data_relas->data[i]; + + int offset = bytes - r->inst_offset - 16; // 'pc = current + 8' + + inst = risc_make_inst(end, offset - 4); + RISC_INST_ADD_CHECK(end->instructions, inst); + + r->inst_offset = bytes; + + bytes += 4; + end->inst_bytes += 4; + bb ->code_bytes += 4; + + r->inst->code[0] = 0xff & offset; + r->inst->code[1] &= 0xf0; + r->inst->code[1] |= 0x0f & (offset >> 8); + r->inst->code[2] &= 0xf0; + r->inst->code[2] |= 0x0f & (offset >> 12); + + int j; + for (j = 0; j < r->code->instructions->size; j++) { + inst = r->code->instructions->data[j]; + + if (inst == r->inst) + break; + } + + assert(r->code->instructions->size > j + 1); + + inst = r->code->instructions->data[j + 1]; + + inst->code[0] = 0xff & (offset >> 16); + inst->code[1] &= 0xf0; + inst->code[1] |= 0x0f & (offset >> 24); + inst->code[2] &= 0xf0; + inst->code[2] |= 0x0f & (offset >> 28); + } + + return 0; +} + +scf_inst_ops_t inst_ops_arm32 = +{ + .name = "arm32", + + .BL = arm32_inst_BL, + .BLR = arm32_inst_BLR, + .PUSH = arm32_inst_PUSH, + .POP = arm32_inst_POP, + .TEQ = arm32_inst_TEQ, + .NEG = arm32_inst_NEG, + + .MOVZX = arm32_inst_MOVZX, + .MOVSX = arm32_inst_MOVSX, + .MVN = arm32_inst_MVN, + .MOV_G = arm32_inst_MOV_G, + .MOV_SP = arm32_inst_MOV_SP, + + .ADD_G = arm32_inst_ADD_G, + .ADD_IMM = arm32_inst_ADD_IMM, + .SUB_G = arm32_inst_SUB_G, + .SUB_IMM = arm32_inst_SUB_IMM, + .CMP_G = arm32_inst_CMP_G, + .CMP_IMM = arm32_inst_CMP_IMM, + .AND_G = arm32_inst_AND_G, + .OR_G = arm32_inst_OR_G, + + .MUL = arm32_inst_MUL, + .DIV = arm32_inst_DIV, + .SDIV = arm32_inst_SDIV, + .MSUB = arm32_inst_MSUB, + + .SHL = arm32_inst_SHL, + .SHR = arm32_inst_SHR, + .ASR = arm32_inst_ASR, + + .CVTSS2SD = arm32_inst_CVTSS2SD, + .CVTSD2SS = arm32_inst_CVTSD2SS, + .CVTF2SI = arm32_inst_CVTF2SI, + .CVTF2UI = arm32_inst_CVTF2UI, + .CVTSI2F = arm32_inst_CVTSI2F, + .CVTUI2F = arm32_inst_CVTUI2F, + + .FCMP = arm32_inst_FCMP, + .FADD = arm32_inst_FADD, + .FSUB = arm32_inst_FSUB, + .FMUL = arm32_inst_FMUL, + .FDIV = arm32_inst_FDIV, + .FMOV_G = arm32_inst_FMOV_G, + + .JA = arm32_inst_JA, + .JB = arm32_inst_JB, + .JZ = arm32_inst_JZ, + .JNZ = arm32_inst_JNZ, + .JGT = arm32_inst_JGT, + .JGE = arm32_inst_JGE, + .JLT = arm32_inst_JLT, + .JLE = arm32_inst_JLE, + .JAE = arm32_inst_JAE, + .JBE = arm32_inst_JBE, + .JMP = arm32_inst_JMP, + .RET = arm32_inst_RET, + + .SETZ = arm32_inst_SETZ, + .SETNZ = arm32_inst_SETNZ, + .SETGT = arm32_inst_SETGT, + .SETGE = arm32_inst_SETGE, + .SETLT = arm32_inst_SETLT, + .SETLE = arm32_inst_SETLE, + + .I2G = arm32_inst_I2G, + .M2G = arm32_inst_M2G, + .M2GF = arm32_inst_M2GF, + .G2M = arm32_inst_G2M, + .G2P = arm32_inst_G2P, + .P2G = arm32_inst_P2G, + .ISTR2G = arm32_inst_ISTR2G, + .SIB2G = arm32_inst_SIB2G, + .G2SIB = arm32_inst_G2SIB, + .ADR2G = arm32_inst_ADR2G, + .ADRP2G = arm32_inst_ADRP2G, + .ADRSIB2G = arm32_inst_ADRSIB2G, + + .cmp_update = arm32_cmp_update, + .set_jmp_offset = arm32_set_jmp_offset, + .set_rel_veneer = arm32_set_rel_veneer, +}; + diff --git a/native/risc/scf_arm64.c b/native/risc/scf_arm64.c index d51f810..b23801b 100644 --- a/native/risc/scf_arm64.c +++ b/native/risc/scf_arm64.c @@ -70,7 +70,7 @@ int arm64_inst_ADR2G(scf_3ac_code_t* c, scf_function_t* f, scf_register_t* rd, s uint32_t SIZE = 0; uint32_t S = 1; - int size = risc_variable_size(vs); + int size = f->rops->variable_size(vs); if (vs->local_flag || vs->tmp_flag) { @@ -130,7 +130,7 @@ int arm64_inst_M2G(scf_3ac_code_t* c, scf_function_t* f, scf_register_t* rd, scf uint32_t SIZE = 0; uint32_t S = 1; - int size = risc_variable_size(vs); + int size = f->rops->variable_size(vs); if (!rb) { if (vs->local_flag || vs->tmp_flag) { @@ -251,7 +251,7 @@ int arm64_inst_G2M(scf_3ac_code_t* c, scf_function_t* f, scf_register_t* rs, scf uint32_t SIZE = 0; uint32_t S = 1; - int size = risc_variable_size(vs); + int size = f->rops->variable_size(vs); if (!rb) { if (vs->local_flag || vs->tmp_flag) { @@ -356,7 +356,7 @@ int arm64_inst_ISTR2G(scf_3ac_code_t* c, scf_function_t* f, scf_register_t* rd, scf_instruction_t* inst = NULL; scf_rela_t* rela = NULL; - int size1 = risc_variable_size(v); + int size1 = f->rops->variable_size(v); assert(8 == rd->bytes); assert(8 == size1); @@ -716,7 +716,7 @@ int arm64_inst_M2GF(scf_3ac_code_t* c, scf_function_t* f, scf_register_t* rd, sc uint32_t SIZE = 0; uint32_t S = 1; - int size = risc_variable_size(vs); + int size = f->rops->variable_size(vs); if (!rb) { if (vs->local_flag || vs->tmp_flag) { @@ -1305,15 +1305,20 @@ scf_instruction_t* arm64_inst_MSUB(scf_3ac_code_t* c, scf_register_t* rd, scf_re return inst; } -scf_instruction_t* arm64_inst_BL(scf_3ac_code_t* c) +int arm64_inst_BL(scf_3ac_code_t* c, scf_function_t* f, scf_function_t* pf) { scf_instruction_t* inst; + scf_rela_t* rela; uint32_t opcode; opcode = 0x25 << 26; inst = risc_make_inst(c, opcode); - return inst; + RISC_INST_ADD_CHECK(c->instructions, inst); + RISC_RELA_ADD_CHECK(f->text_relas, rela, c, NULL, pf); + + rela->type = R_AARCH64_CALL26; + return 0; } scf_instruction_t* arm64_inst_BLR(scf_3ac_code_t* c, scf_register_t* r) diff --git a/native/risc/scf_naja.c b/native/risc/scf_naja.c index 2fa5c4f..40d0ea4 100644 --- a/native/risc/scf_naja.c +++ b/native/risc/scf_naja.c @@ -70,7 +70,7 @@ int naja_inst_ADR2G(scf_3ac_code_t* c, scf_function_t* f, scf_register_t* rd, sc uint32_t SIZE = 0; uint32_t S = 1; - int size = risc_variable_size(vs); + int size = f->rops->variable_size(vs); if (vs->local_flag || vs->tmp_flag) { @@ -120,16 +120,16 @@ int naja_inst_ADR2G(scf_3ac_code_t* c, scf_function_t* f, scf_register_t* rd, sc int naja_inst_M2G(scf_3ac_code_t* c, scf_function_t* f, scf_register_t* rd, scf_register_t* rb, scf_variable_t* vs) { - scf_register_t* fp = f->rops->find_register("fp"); - scf_register_t* ri = NULL; - scf_instruction_t* inst = NULL; - scf_rela_t* rela = NULL; + scf_register_t* fp = f->rops->find_register("fp"); + scf_register_t* ri = NULL; + scf_instruction_t* inst = NULL; + scf_rela_t* rela = NULL; int64_t offset; uint32_t opcode; uint32_t SIZE = 0; - int size = risc_variable_size(vs); + int size = f->rops->variable_size(vs); if (!rb) { if (vs->local_flag || vs->tmp_flag) { @@ -228,16 +228,16 @@ int naja_inst_M2G(scf_3ac_code_t* c, scf_function_t* f, scf_register_t* rd, scf_ int naja_inst_G2M(scf_3ac_code_t* c, scf_function_t* f, scf_register_t* rs, scf_register_t* rb, scf_variable_t* vs) { - scf_register_t* fp = f->rops->find_register("fp"); - scf_register_t* ri = NULL; - scf_instruction_t* inst = NULL; - scf_rela_t* rela = NULL; + scf_register_t* fp = f->rops->find_register("fp"); + scf_register_t* ri = NULL; + scf_instruction_t* inst = NULL; + scf_rela_t* rela = NULL; int64_t offset; uint32_t opcode; uint32_t SIZE = 0; - int size = risc_variable_size(vs); + int size = f->rops->variable_size(vs); if (!rb) { if (vs->local_flag || vs->tmp_flag) { @@ -340,7 +340,7 @@ int naja_inst_ISTR2G(scf_3ac_code_t* c, scf_function_t* f, scf_register_t* rd, s scf_instruction_t* inst = NULL; scf_rela_t* rela = NULL; - int size1 = risc_variable_size(v); + int size1 = f->rops->variable_size(v); assert(8 == rd->bytes); assert(8 == size1); @@ -1125,15 +1125,20 @@ scf_instruction_t* naja_inst_MSUB(scf_3ac_code_t* c, scf_register_t* rd, scf_reg return inst; } -scf_instruction_t* naja_inst_BL(scf_3ac_code_t* c) +int naja_inst_BL(scf_3ac_code_t* c, scf_function_t* f, scf_function_t* pf) { scf_instruction_t* inst; + scf_rela_t* rela; uint32_t opcode; opcode = (0x18 << 26); inst = risc_make_inst(c, opcode); - return inst; + RISC_INST_ADD_CHECK(c->instructions, inst); + RISC_RELA_ADD_CHECK(f->text_relas, rela, c, NULL, pf); + + rela->type = R_AARCH64_CALL26; + return 0; } scf_instruction_t* naja_inst_BLR(scf_3ac_code_t* c, scf_register_t* r) diff --git a/native/risc/scf_risc.c b/native/risc/scf_risc.c index f338387..5f46cdb 100644 --- a/native/risc/scf_risc.c +++ b/native/risc/scf_risc.c @@ -4,14 +4,17 @@ #include"scf_3ac.h" extern scf_regs_ops_t regs_ops_arm64; +extern scf_regs_ops_t regs_ops_arm32; extern scf_regs_ops_t regs_ops_naja; extern scf_inst_ops_t inst_ops_arm64; +extern scf_inst_ops_t inst_ops_arm32; extern scf_inst_ops_t inst_ops_naja; static scf_inst_ops_t* inst_ops_array[] = { &inst_ops_arm64, + &inst_ops_arm32, &inst_ops_naja, NULL @@ -20,6 +23,7 @@ static scf_inst_ops_t* inst_ops_array[] = static scf_regs_ops_t* regs_ops_array[] = { ®s_ops_arm64, + ®s_ops_arm32, ®s_ops_naja, NULL @@ -81,7 +85,7 @@ static void _risc_argv_rabi(scf_function_t* f) f->args_float = 0; int bp_int = -8; - int bp_floats = -8 - (int)RISC_ABI_NB * 8; + int bp_floats = -8 - (int)f->rops->ABI_NB * 8; int bp_others = 16; int i; @@ -93,22 +97,22 @@ static void _risc_argv_rabi(scf_function_t* f) assert(f->inline_flag); } - int is_float = scf_variable_float(v); - int size = risc_variable_size(v); + int is_float = scf_variable_float(v); + int size = f->rops->variable_size (v); if (is_float) { - if (f->args_float < RISC_ABI_NB) { + if (f->args_float < f->rops->ABI_NB) { - v->rabi = f->rops->find_register_type_id_bytes(is_float, risc_abi_float_regs[f->args_float], size); + v->rabi = f->rops->find_register_type_id_bytes(is_float, f->rops->abi_float_regs[f->args_float], size); v->bp_offset = bp_floats; bp_floats -= 8; f->args_float++; continue; } - } else if (f->args_int < RISC_ABI_NB) { + } else if (f->args_int < f->rops->ABI_NB) { - v->rabi = f->rops->find_register_type_id_bytes(is_float, risc_abi_regs[f->args_int], size); + v->rabi = f->rops->find_register_type_id_bytes(is_float, f->rops->abi_regs[f->args_int], size); v->bp_offset = bp_int; bp_int -= 8; f->args_int++; @@ -138,7 +142,7 @@ static int _risc_function_init(scf_function_t* f, scf_vector_t* local_vars) _risc_argv_rabi(f); - int local_vars_size = 8 + RISC_ABI_NB * 8 * 2; + int local_vars_size = 8 + f->rops->ABI_NB * 8 * 2; for (i = 0; i < local_vars->size; i++) { v = local_vars->data[i]; @@ -281,12 +285,12 @@ static int _risc_function_finish(scf_native_t* ctx, scf_function_t* f) f->init_code_bytes = 0; int i; - for (i = 0; i < RISC_ABI_CALLEE_SAVES_NB; i++) { + for (i = 0; i < f->rops->ABI_CALLEE_SAVES_NB; i++) { - r = f->rops->find_register_type_id_bytes(0, risc_abi_callee_saves[i], 8); + r = f->rops->find_register_type_id_bytes(0, f->rops->abi_callee_saves[i], 8); if (!r->used) { - r = f->rops->find_register_type_id_bytes(0, risc_abi_callee_saves[i], 4); + r = f->rops->find_register_type_id_bytes(0, f->rops->abi_callee_saves[i], 4); if (!r->used) continue; @@ -580,7 +584,7 @@ static int _risc_select_bb_regs(scf_basic_block_t* bb, scf_native_t* ctx) goto error; } - ret = scf_risc_graph_kcolor(g, 16, colors); + ret = scf_risc_graph_kcolor(g, 16, colors, f); if (ret < 0) goto error; @@ -631,7 +635,7 @@ static int _risc_select_bb_group_regs(scf_bb_group_t* bbg, scf_native_t* ctx) goto error; } - ret = scf_risc_graph_kcolor(g, 16, colors); + ret = scf_risc_graph_kcolor(g, 16, colors, f); if (ret < 0) goto error; @@ -1193,6 +1197,10 @@ int scf_risc_select_inst(scf_native_t* ctx, scf_function_t* f) _risc_set_offset_for_relas(ctx, f, f->text_relas); _risc_set_offset_for_relas(ctx, f, f->data_relas); + + if (f->iops->set_rel_veneer) + return f->iops->set_rel_veneer(f); + return 0; } diff --git a/native/risc/scf_risc.h b/native/risc/scf_risc.h index 4259da1..3821c12 100644 --- a/native/risc/scf_risc.h +++ b/native/risc/scf_risc.h @@ -82,7 +82,7 @@ int scf_risc_select(scf_native_t* ctx); int risc_optimize_peephole(scf_native_t* ctx, scf_function_t* f); -int scf_risc_graph_kcolor(scf_graph_t* graph, int k, scf_vector_t* colors); +int scf_risc_graph_kcolor(scf_graph_t* graph, int k, scf_vector_t* colors, scf_function_t* f); intptr_t risc_bb_find_color (scf_vector_t* dn_colors, scf_dag_node_t* dn); diff --git a/native/risc/scf_risc_bb_color.c b/native/risc/scf_risc_bb_color.c index a65991f..ee58d60 100644 --- a/native/risc/scf_risc_bb_color.c +++ b/native/risc/scf_risc_bb_color.c @@ -170,8 +170,6 @@ int risc_bb_save_dn(intptr_t color, scf_dag_node_t* dn, scf_3ac_code_t* c, scf_b int risc_bb_load_dn2(intptr_t color, scf_dag_node_t* dn, scf_basic_block_t* bb, scf_function_t* f) { scf_register_t* r0; - scf_register_t* r16 = f->rops->find_register_type_id_bytes(0, 16, 8); - scf_register_t* r17 = f->rops->find_register_type_id_bytes(0, 17, 8); scf_instruction_t* cmp = NULL; scf_instruction_t* inst; scf_3ac_code_t* c; diff --git a/native/risc/scf_risc_graph.c b/native/risc/scf_risc_graph.c index f05b156..6765e79 100644 --- a/native/risc/scf_risc_graph.c +++ b/native/risc/scf_risc_graph.c @@ -1,7 +1,7 @@ #include"scf_graph.h" #include"scf_risc.h" -static intptr_t _risc_color_select(scf_graph_node_t* node, scf_vector_t* colors) +static intptr_t _risc_color_select(scf_graph_node_t* node, scf_vector_t* colors, scf_function_t* f) { risc_rcg_node_t* rn = node->data; @@ -16,7 +16,7 @@ static intptr_t _risc_color_select(scf_graph_node_t* node, scf_vector_t* colors) int bytes = RISC_COLOR_BYTES(c); uint32_t type = RISC_COLOR_TYPE(c); - if (bytes == risc_variable_size(rn->dag_node->var) + if (bytes == f->rops->variable_size (rn->dag_node->var) && type == scf_variable_float(rn->dag_node->var)) return c; } @@ -111,7 +111,7 @@ static int _risc_kcolor_delete(scf_graph_t* graph, int k, scf_vector_t* deleted_ } static int _risc_kcolor_fill(scf_graph_t* graph, int k, scf_vector_t* colors, - scf_vector_t* deleted_nodes) + scf_vector_t* deleted_nodes, scf_function_t* f) { scf_logd("graph->nodes->size: %d\n", graph->nodes->size); int i; @@ -157,7 +157,7 @@ static int _risc_kcolor_fill(scf_graph_t* graph, int k, scf_vector_t* colors, assert(colors2->size >= 0); if (0 == node->color) { - node->color = _risc_color_select(node, colors2); + node->color = _risc_color_select(node, colors2, f); if (0 == node->color) { node->color = -1; scf_logd("colors2->size: %d\n", colors2->size); @@ -336,7 +336,7 @@ static void _risc_kcolor_process_conflict(scf_graph_t* graph) } } -static int _risc_graph_kcolor(scf_graph_t* graph, int k, scf_vector_t* colors) +static int _risc_graph_kcolor(scf_graph_t* graph, int k, scf_vector_t* colors, scf_function_t* f) { int ret = -1; scf_vector_t* colors2 = NULL; @@ -354,7 +354,7 @@ static int _risc_graph_kcolor(scf_graph_t* graph, int k, scf_vector_t* colors) if (0 == _risc_kcolor_check(graph)) { scf_logd("graph->nodes->size: %d\n", graph->nodes->size); - ret = _risc_kcolor_fill(graph, k, colors, deleted_nodes); + ret = _risc_kcolor_fill(graph, k, colors, deleted_nodes, f); if (ret < 0) goto error; @@ -386,12 +386,12 @@ static int _risc_graph_kcolor(scf_graph_t* graph, int k, scf_vector_t* colors) goto error; } - int reg_size0 = risc_variable_size(rn0->dag_node->var); - int reg_size1 = risc_variable_size(rn1->dag_node->var); + int reg_size0 = f->rops->variable_size(rn0->dag_node->var); + int reg_size1 = f->rops->variable_size(rn1->dag_node->var); if (reg_size0 > reg_size1) { - node0->color = _risc_color_select(node0, colors2); + node0->color = _risc_color_select(node0, colors2, f); if (0 == node0->color) goto overflow; @@ -409,7 +409,7 @@ static int _risc_graph_kcolor(scf_graph_t* graph, int k, scf_vector_t* colors) assert(!scf_vector_find(colors2, (void*)node1->color)); } else { - node1->color = _risc_color_select(node1, colors2); + node1->color = _risc_color_select(node1, colors2, f); if (0 == node1->color) goto overflow; @@ -436,7 +436,7 @@ static int _risc_graph_kcolor(scf_graph_t* graph, int k, scf_vector_t* colors) if (ret < 0) goto error; - ret = scf_risc_graph_kcolor(graph, k - 1, colors2); + ret = scf_risc_graph_kcolor(graph, k - 1, colors2, f); if (ret < 0) goto error; @@ -460,7 +460,7 @@ overflow: goto error; node_max->color = -1; - ret = scf_risc_graph_kcolor(graph, k, colors); + ret = scf_risc_graph_kcolor(graph, k, colors, f); if (ret < 0) goto error; @@ -469,7 +469,7 @@ overflow: goto error; } - ret = _risc_kcolor_fill(graph, k, colors, deleted_nodes); + ret = _risc_kcolor_fill(graph, k, colors, deleted_nodes, f); if (ret < 0) goto error; @@ -487,7 +487,7 @@ error: return ret; } -int scf_risc_graph_kcolor(scf_graph_t* graph, int k, scf_vector_t* colors) +int scf_risc_graph_kcolor(scf_graph_t* graph, int k, scf_vector_t* colors, scf_function_t* f) { if (!graph || !colors || 0 == colors->size) { scf_loge("\n"); @@ -496,7 +496,7 @@ int scf_risc_graph_kcolor(scf_graph_t* graph, int k, scf_vector_t* colors) _risc_kcolor_process_conflict(graph); - return _risc_graph_kcolor(graph, k, colors); + return _risc_graph_kcolor(graph, k, colors, f); } diff --git a/native/risc/scf_risc_inst.c b/native/risc/scf_risc_inst.c index d6bedbd..560275f 100644 --- a/native/risc/scf_risc_inst.c +++ b/native/risc/scf_risc_inst.c @@ -29,7 +29,7 @@ } -static int _risc_inst_call_stack_size(scf_3ac_code_t* c) +static int _risc_inst_call_stack_size(scf_3ac_code_t* c, scf_function_t* f) { int stack_size = 0; @@ -41,7 +41,7 @@ static int _risc_inst_call_stack_size(scf_3ac_code_t* c) if (src->dag_node->rabi2) continue; - int size = risc_variable_size(v); + int size = f->rops->variable_size(v); if (size & 0x7) size = (size + 7) >> 3 << 3; @@ -63,7 +63,7 @@ static int _risc_inst_call_argv(scf_native_t* ctx, scf_3ac_code_t* c, scf_functi scf_risc_OpCode_t* lea; scf_risc_OpCode_t* mov; scf_risc_OpCode_t* movx; - scf_instruction_t* inst; + scf_instruction_t* inst; uint32_t opcode; @@ -71,14 +71,15 @@ static int _risc_inst_call_argv(scf_native_t* ctx, scf_3ac_code_t* c, scf_functi int ret; int i; for (i = c->srcs->size - 1; i >= 1; i--) { - scf_3ac_operand_t* src = c->srcs->data[i]; - scf_variable_t* v = src->dag_node->var; - scf_register_t* rd = src->rabi; - scf_register_t* rabi = src->dag_node->rabi2; - scf_register_t* rs = NULL; - int size = risc_variable_size(v); - int is_float = scf_variable_float(v); + scf_3ac_operand_t* src = c->srcs->data[i]; + scf_variable_t* v = src->dag_node->var; + scf_register_t* rd = src->rabi; + scf_register_t* rabi = src->dag_node->rabi2; + scf_register_t* rs = NULL; + + int size = f->rops->variable_size (v); + int is_float = scf_variable_float(v); if (!rabi) { rabi = f->rops->find_register_type_id_bytes(is_float, SCF_RISC_REG_X0, size); @@ -90,16 +91,19 @@ static int _risc_inst_call_argv(scf_native_t* ctx, scf_3ac_code_t* c, scf_functi } } + scf_loge("i: %d, size: %d, v: %s\n", i, size, v->w->text->data); + movx = NULL; if (!is_float) { - mov = risc_find_OpCode(SCF_RISC_MOV, 8, 8, SCF_RISC_G2E); + mov = risc_find_OpCode(SCF_RISC_MOV, f->rops->MAX_BYTES, f->rops->MAX_BYTES, SCF_RISC_G2E); + + if (size < f->rops->MAX_BYTES) { - if (size < 8) { if (scf_variable_signed(v)) - movx = risc_find_OpCode(SCF_RISC_MOVSX, size, 8, SCF_RISC_E2G); + movx = risc_find_OpCode(SCF_RISC_MOVSX, size, f->rops->MAX_BYTES, SCF_RISC_E2G); else if (size < 4) - movx = risc_find_OpCode(SCF_RISC_MOVZX, size, 8, SCF_RISC_E2G); + movx = risc_find_OpCode(SCF_RISC_MOVZX, size, f->rops->MAX_BYTES, SCF_RISC_E2G); } if (0 == src->dag_node->color) { @@ -116,7 +120,7 @@ static int _risc_inst_call_argv(scf_native_t* ctx, scf_3ac_code_t* c, scf_functi return ret; } - rabi = f->rops->find_register_color_bytes(rabi->color, 8); + rabi = f->rops->find_register_color_bytes(rabi->color, f->rops->MAX_BYTES); rs = rabi; } else { if (src->dag_node->color < 0) @@ -153,7 +157,7 @@ static int _risc_inst_call_argv(scf_native_t* ctx, scf_3ac_code_t* c, scf_functi } RISC_SELECT_REG_CHECK(&rs, src->dag_node, c, f, 1); - rs = f->rops->find_register_color_bytes(rs->color, 8); + rs = f->rops->find_register_color_bytes(rs->color, f->rops->MAX_BYTES); } if (movx) { @@ -228,7 +232,7 @@ static int _risc_call_save_ret_regs(scf_3ac_code_t* c, scf_function_t* f, scf_fu r = f->rops->find_register_type_id_bytes(is_float, 0, 8); } else - r = f->rops->find_register_type_id_bytes(is_float, risc_abi_ret_regs[i], 8); + r = f->rops->find_register_type_id_bytes(is_float, f->rops->abi_ret_regs[i], f->rops->MAX_BYTES); int ret = f->rops->overflow_reg(r, c, f); if (ret < 0) { @@ -254,7 +258,7 @@ static int _risc_dst_reg_valid(scf_function_t* f, scf_register_t* rd, scf_regist for (i = abi_idx; i < abi_total; i++) { - r = f->rops->find_register_type_id_bytes(RISC_COLOR_TYPE(rd->color), risc_abi_ret_regs[i], rd->bytes); + r = f->rops->find_register_type_id_bytes(RISC_COLOR_TYPE(rd->color), f->rops->abi_ret_regs[i], rd->bytes); if (RISC_COLOR_CONFLICT(r->color, rd->color)) return 0; @@ -308,7 +312,7 @@ static int _risc_call_update_dsts(scf_native_t* ctx, scf_3ac_code_t* c, scf_func continue; int is_float = scf_variable_float(v); - int dst_size = risc_variable_size (v); + int dst_size = f->rops->variable_size (v); if (is_float) { if (i > 0) { @@ -328,7 +332,7 @@ static int _risc_call_update_dsts(scf_native_t* ctx, scf_3ac_code_t* c, scf_func idx_float++; } else { - rs = f->rops->find_register_type_id_bytes(is_float, risc_abi_ret_regs[idx_int], dst_size); + rs = f->rops->find_register_type_id_bytes(is_float, f->rops->abi_ret_regs[idx_int], dst_size); mov = risc_find_OpCode(SCF_RISC_MOV, dst_size, dst_size, SCF_RISC_G2E); @@ -408,12 +412,16 @@ static int _risc_inst_call_handler(scf_native_t* ctx, scf_3ac_code_t* c) return -EINVAL; } - scf_risc_context_t* risc = ctx->priv; - scf_function_t* f = risc->f; + scf_instruction_t* inst_sp2 = NULL; + scf_instruction_t* inst_sp = NULL; + scf_instruction_t* inst; + + scf_risc_context_t* risc = ctx->priv; + scf_function_t* f = risc->f; - scf_3ac_operand_t* src0 = c->srcs->data[0]; - scf_variable_t* var_pf = src0->dag_node->var; - scf_function_t* pf = var_pf->func_ptr; + scf_3ac_operand_t* src0 = c->srcs->data[0]; + scf_variable_t* var_pf = src0->dag_node->var; + scf_function_t* pf = var_pf->func_ptr; if (SCF_FUNCTION_PTR != var_pf->type || !pf) { scf_loge("\n"); @@ -429,9 +437,6 @@ static int _risc_inst_call_handler(scf_native_t* ctx, scf_3ac_code_t* c) scf_register_t* lr = f->rops->find_register("lr"); scf_register_t* sp = f->rops->find_register("sp"); scf_register_t* x0 = f->rops->find_register("x0"); - scf_instruction_t* inst; - scf_instruction_t* inst_sp = NULL; - scf_instruction_t* inst_sp2 = NULL; lr->used = 1; sp->used = 1; @@ -460,7 +465,7 @@ static int _risc_inst_call_handler(scf_native_t* ctx, scf_3ac_code_t* c) risc_call_rabi(NULL, NULL, c, f); - int32_t stack_size = _risc_inst_call_stack_size(c); + int32_t stack_size = _risc_inst_call_stack_size(c, f); if (stack_size > 0) { inst_sp = risc_make_inst(c, 0); inst_sp2 = risc_make_inst(c, 0); @@ -474,14 +479,16 @@ static int _risc_inst_call_handler(scf_native_t* ctx, scf_3ac_code_t* c) return ret; } - scf_register_t* saved_regs[RISC_ABI_CALLER_SAVES_NB]; + scf_register_t* saved_regs[RISC_ABI_CALLER_SAVES_MAX]; - int save_size = f->rops->caller_save_regs(c, f, risc_abi_caller_saves, RISC_ABI_CALLER_SAVES_NB, stack_size, saved_regs); + int save_size = f->rops->caller_save_regs(c, f, f->rops->abi_caller_saves, f->rops->ABI_CALLER_SAVES_NB, stack_size, saved_regs); if (save_size < 0) { scf_loge("\n"); return save_size; } + scf_loge("stack_size: %d, save_size: %d\n", stack_size, save_size); + if (stack_size > 0) { assert(inst_sp); assert(inst_sp2); @@ -517,19 +524,33 @@ static int _risc_inst_call_handler(scf_native_t* ctx, scf_3ac_code_t* c) inst = NULL; } else return -ENOMEM; + + } else { + scf_vector_del(c->instructions, inst_sp2); + + free(inst_sp2); + inst_sp2 = NULL; } + + } else { + scf_vector_del(c->instructions, inst_sp); + scf_vector_del(c->instructions, inst_sp2); + + free(inst_sp); + free(inst_sp2); + + inst_sp = NULL; + inst_sp2 = NULL; } if (var_pf->const_literal_flag) { assert(0 == src0->dag_node->color); - inst = ctx->iops->BL(c); - RISC_INST_ADD_CHECK(c->instructions, inst); - - scf_rela_t* rela = NULL; - - RISC_RELA_ADD_CHECK(f->text_relas, rela, c, NULL, pf); - rela->type = R_AARCH64_CALL26; + ret = ctx->iops->BL(c, f, pf); + if (ret < 0) { + scf_loge("\n"); + return ret; + } } else { assert(0 != src0->dag_node->color); @@ -559,11 +580,11 @@ static int _risc_inst_call_handler(scf_native_t* ctx, scf_3ac_code_t* c) } int nb_updated = 0; - scf_register_t* updated_regs[RISC_ABI_RET_NB * 2]; + scf_register_t* updated_regs[RISC_ABI_RET_MAX * 2]; if (pf->rets && pf->rets->size > 0 && c->dsts) { - nb_updated = _risc_call_update_dsts(ctx, c, f, updated_regs, RISC_ABI_RET_NB * 2); + nb_updated = _risc_call_update_dsts(ctx, c, f, updated_regs, f->rops->ABI_RET_NB * 2); if (nb_updated < 0) { scf_loge("\n"); return nb_updated; @@ -571,7 +592,7 @@ static int _risc_inst_call_handler(scf_native_t* ctx, scf_3ac_code_t* c) } if (save_size > 0) { - ret = f->rops->pop_regs(c, f, saved_regs, save_size >> 3, updated_regs, nb_updated); + ret = f->rops->pop_regs(c, f, saved_regs, save_size / f->rops->MAX_BYTES, updated_regs, nb_updated); if (ret < 0) { scf_loge("\n"); return ret; @@ -827,7 +848,7 @@ static int _risc_inst_neg_handler(scf_native_t* ctx, scf_3ac_code_t* c) uint32_t opcode; int is_float = scf_variable_float(v); - int size = risc_variable_size(v); + int size = f->rops->variable_size(v); if (!is_float) { @@ -980,7 +1001,7 @@ static int _risc_inst_inc_pointer_handler(scf_native_t* ctx, scf_3ac_code_t* c) scf_register_t* r = NULL; scf_sib_t sib = {0}; - int size = risc_variable_size(vm); + int size = f->rops->variable_size(vm); int ret = risc_pointer_reg(&sib, base->dag_node, member->dag_node, c, f); if (ret < 0) @@ -1047,7 +1068,7 @@ static int _risc_inst_dec_pointer_handler(scf_native_t* ctx, scf_3ac_code_t* c) scf_register_t* r = NULL; scf_sib_t sib = {0}; - int size = risc_variable_size(vm); + int size = f->rops->variable_size(vm); int ret = risc_pointer_reg(&sib, base->dag_node, member->dag_node, c, f); if (ret < 0) @@ -1122,7 +1143,7 @@ static int _risc_inst_inc_post_pointer_handler(scf_native_t* ctx, scf_3ac_code_t scf_register_t* rd = NULL; scf_sib_t sib = {0}; - int size = risc_variable_size(vm); + int size = f->rops->variable_size(vm); int ret = risc_pointer_reg(&sib, base->dag_node, member->dag_node, c, f); if (ret < 0) @@ -1200,7 +1221,7 @@ static int _risc_inst_dec_post_pointer_handler(scf_native_t* ctx, scf_3ac_code_t scf_register_t* rd = NULL; scf_sib_t sib = {0}; - int size = risc_variable_size(vm); + int size = f->rops->variable_size(vm); int ret = risc_pointer_reg(&sib, base->dag_node, member->dag_node, c, f); if (ret < 0) @@ -1814,7 +1835,7 @@ static int _risc_inst_va_start_handler(scf_native_t* ctx, scf_3ac_code_t* c) scf_variable_t* v = ap->dag_node->var; int offset_int = -f->args_int * 8 - 8; - int offset_float = -f->args_float * 8 - RISC_ABI_NB * 8 - 8; + int offset_float = -f->args_float * 8 - f->rops->ABI_NB * 8 - 8; int offset_others = 16; if (v->bp_offset >= 0) { @@ -1963,7 +1984,7 @@ static int _risc_inst_va_arg_handler(scf_native_t* ctx, scf_3ac_code_t* c) RISC_SELECT_REG_CHECK(&rptr, ptr->dag_node, c, f, 0); int is_float = scf_variable_float(v); - int size = risc_variable_size(v); + int size = f->rops->variable_size(v); uint32_t nints = RISC_ABI_NB; uint32_t nfloats = RISC_ABI_NB; @@ -3291,8 +3312,8 @@ static int _risc_inst_cast_handler(scf_native_t* ctx, scf_3ac_code_t* c) scf_variable_t* vs = s->var; scf_variable_t* vd = d->var; - int src_size = risc_variable_size(vs); - int dst_size = risc_variable_size(vd); + int src_size = f->rops->variable_size(vs); + int dst_size = f->rops->variable_size(vd); RISC_SELECT_REG_CHECK(&rd, d, c, f, 0); @@ -3585,8 +3606,8 @@ static int _risc_inst_return_handler(scf_native_t* ctx, scf_3ac_code_t* c) v = src->dag_node->var; - int size = risc_variable_size(v); - int is_float = scf_variable_float(v); + int size = f->rops->variable_size (v); + int is_float = scf_variable_float(v); if (i > 0 && is_float) { scf_loge("\n"); @@ -3607,7 +3628,7 @@ static int _risc_inst_return_handler(scf_native_t* ctx, scf_3ac_code_t* c) return -1; } else { - rd = f->rops->find_register_type_id_bytes(is_float, risc_abi_ret_regs[i], retsize); + rd = f->rops->find_register_type_id_bytes(is_float, f->rops->abi_ret_regs[i], retsize); if (0 == src->dag_node->color) { if (rd->bytes > size) @@ -3714,7 +3735,7 @@ static int _risc_inst_memset_handler(scf_native_t* ctx, scf_3ac_code_t* c) #if 0 #define RISC_MEMSET_LOAD_REG(r, dn) \ do { \ - int size = risc_variable_size(dn->var); \ + int size = f->rops->variable_size(dn->var); \ assert(8 == size); \ \ if (0 == dn->color) { \ @@ -3769,12 +3790,12 @@ static int _risc_inst_end_handler(scf_native_t* ctx, scf_3ac_code_t* c) scf_register_t* r; int i; - for (i = RISC_ABI_CALLEE_SAVES_NB - 1; i >= 0; i--) { + for (i = f->rops->ABI_CALLEE_SAVES_NB - 1; i >= 0; i--) { - r = f->rops->find_register_type_id_bytes(0, risc_abi_callee_saves[i], 8); + r = f->rops->find_register_type_id_bytes(0, f->rops->abi_callee_saves[i], 8); if (!r->used) { - r = f->rops->find_register_type_id_bytes(0, risc_abi_callee_saves[i], 4); + r = f->rops->find_register_type_id_bytes(0, f->rops->abi_callee_saves[i], 4); if (!r->used) continue; @@ -3998,7 +4019,7 @@ static int _risc_inst_assign_handler(scf_native_t* ctx, scf_3ac_code_t* c) assert(0 != d->color); - int size = risc_variable_size(v); + int size = f->rops->variable_size(v); int is_float = scf_variable_float(v); RISC_SELECT_REG_CHECK(&rd, d, c, f, 0); @@ -5011,7 +5032,7 @@ static int _risc_inst_assign_array_index_handler(scf_native_t* ctx, scf_3ac_code scf_instruction_t* inst; int is_float = scf_variable_float(vs); - int size = risc_variable_size (vs); + int size = f->rops->variable_size (vs); if (size > vscale->data.i) size = vscale->data.i; @@ -5093,7 +5114,7 @@ static int _risc_inst_add_assign_array_index_handler(scf_native_t* ctx, scf_3ac_ scf_instruction_t* inst; int is_float = scf_variable_float(vs); - int size = risc_variable_size (vs); + int size = f->rops->variable_size (vs); if (size > vscale->data.i) size = vscale->data.i; @@ -5192,7 +5213,7 @@ static int _risc_inst_sub_assign_array_index_handler(scf_native_t* ctx, scf_3ac_ scf_instruction_t* inst; int is_float = scf_variable_float(vs); - int size = risc_variable_size (vs); + int size = f->rops->variable_size (vs); if (size > vscale->data.i) size = vscale->data.i; @@ -5293,7 +5314,7 @@ static int _risc_inst_and_assign_array_index_handler(scf_native_t* ctx, scf_3ac_ scf_instruction_t* inst; int is_float = scf_variable_float(vs); - int size = risc_variable_size (vs); + int size = f->rops->variable_size (vs); if (size > vscale->data.i) size = vscale->data.i; @@ -5383,7 +5404,7 @@ static int _risc_inst_or_assign_array_index_handler(scf_native_t* ctx, scf_3ac_c scf_instruction_t* inst; int is_float = scf_variable_float(vs); - int size = risc_variable_size (vs); + int size = f->rops->variable_size (vs); if (size > vscale->data.i) size = vscale->data.i; diff --git a/native/risc/scf_risc_rcg.c b/native/risc/scf_risc_rcg.c index 23af842..c106364 100644 --- a/native/risc/scf_risc_rcg.c +++ b/native/risc/scf_risc_rcg.c @@ -302,7 +302,7 @@ static int _risc_rcg_call(scf_native_t* ctx, scf_3ac_code_t* c, scf_graph_t* g) if (c->dsts) { - if (c->dsts->size > RISC_ABI_RET_NB) { + if (c->dsts->size > f->rops->ABI_RET_NB) { scf_loge("\n"); return -EINVAL; } @@ -321,13 +321,13 @@ static int _risc_rcg_call(scf_native_t* ctx, scf_3ac_code_t* c, scf_graph_t* g) continue; int is_float = scf_variable_float(dn->var); - int size = risc_variable_size (dn->var); + int size = f->rops->variable_size (dn->var); if (0 == i) r = f->rops->find_register_type_id_bytes(is_float, SCF_RISC_REG_X0, size); else if (!is_float) - r = f->rops->find_register_type_id_bytes(is_float, risc_abi_ret_regs[i], size); + r = f->rops->find_register_type_id_bytes(is_float, f->rops->abi_ret_regs[i], size); else r = NULL; @@ -383,7 +383,7 @@ static int _risc_rcg_call(scf_native_t* ctx, scf_3ac_code_t* c, scf_graph_t* g) scf_register_t* rabi = NULL; scf_graph_node_t* gn_rabi = NULL; - rabi = f->rops->find_register_type_id_bytes(0, risc_abi_regs[i], dn_pf->var->size); + rabi = f->rops->find_register_type_id_bytes(0, f->rops->abi_regs[i], dn_pf->var->size); ret = _risc_rcg_make_node(&gn_rabi, g, NULL, rabi); if (ret < 0) { @@ -862,7 +862,7 @@ static int _risc_rcg_return_handler(scf_native_t* ctx, scf_3ac_code_t* c, scf_gr dn = src->dag_node; int is_float = scf_variable_float(dn->var); - int size = risc_variable_size(dn->var); + int size = f->rops->variable_size(dn->var); size = size > 4 ? 8 : 4; @@ -874,7 +874,7 @@ static int _risc_rcg_return_handler(scf_native_t* ctx, scf_3ac_code_t* c, scf_gr r = f->rops->find_register_type_id_bytes(is_float, 0, size); } else - r = f->rops->find_register_type_id_bytes(is_float, risc_abi_ret_regs[i], size); + r = f->rops->find_register_type_id_bytes(is_float, f->rops->abi_ret_regs[i], size); ret = _risc_rcg_make_node(&gn, g, dn, r); if (ret < 0) @@ -904,28 +904,6 @@ static int _risc_rcg_memset_handler(scf_native_t* ctx, scf_3ac_code_t* c, scf_gr if (!c->srcs || c->srcs->size != 3) return -EINVAL; #if 0 - for (i = 0; i < c->srcs->size; i++) { - src = c->srcs->data[i]; - dn = src->dag_node; - - int size = risc_variable_size (dn->var); - size = size > 4 ? 8 : 4; - - if (0 == i) - r = risc_find_register_type_id_bytes(0, SCF_RISC_REG_DI, size); - - else if (1 == i) - r = risc_find_register_type_id_bytes(0, SCF_RISC_REG_AX, size); - - else if (2 == i) - r = risc_find_register_type_id_bytes(0, SCF_RISC_REG_CX, size); - else - return -EINVAL; - - ret = _risc_rcg_make_node(&gn, g, dn, r, NULL); - if (ret < 0) - return ret; - } #endif return 0; } diff --git a/native/risc/scf_risc_reg.c b/native/risc/scf_risc_reg.c index 3b7d661..dda0bca 100644 --- a/native/risc/scf_risc_reg.c +++ b/native/risc/scf_risc_reg.c @@ -7,8 +7,8 @@ int risc_save_var2(scf_dag_node_t* dn, scf_register_t* r, scf_3ac_code_t* c, scf scf_risc_OpCode_t* mov; scf_instruction_t* inst; - int size = risc_variable_size(v); - int is_float = scf_variable_float(v); + int size = f->rops->variable_size (v); + int is_float = scf_variable_float(v); assert(size == r->bytes); @@ -89,8 +89,8 @@ int risc_load_const(scf_register_t* r, scf_dag_node_t* dn, scf_3ac_code_t* c, sc v = dn->var; r->used = 1; - int size = risc_variable_size(v); - int is_float = scf_variable_float(v); + int size = f->rops->variable_size (v); + int is_float = scf_variable_float(v); if (SCF_FUNCTION_PTR == v->type) { @@ -130,8 +130,8 @@ int risc_load_reg(scf_register_t* r, scf_dag_node_t* dn, scf_3ac_code_t* c, scf_ scf_instruction_t* inst; scf_rela_t* rela = NULL; - int is_float = scf_variable_float(dn->var); - int var_size = risc_variable_size(dn->var); + int is_float = scf_variable_float(dn->var); + int var_size = f->rops->variable_size (dn->var); r->used = 1; @@ -209,7 +209,7 @@ int risc_select_reg(scf_register_t** preg, scf_dag_node_t* dn, scf_3ac_code_t* c int ret; int is_float = scf_variable_float(dn->var); - int var_size = risc_variable_size(dn->var); + int var_size = f->rops->variable_size(dn->var); if (dn->color > 0) { r = f->rops->find_register_color(dn->color); @@ -361,7 +361,7 @@ int risc_pointer_reg(scf_sib_t* sib, scf_dag_node_t* base, scf_dag_node_t* membe sib->index = NULL; sib->scale = 0; sib->disp = disp; - sib->size = risc_variable_size(vm); + sib->size = f->rops->variable_size(vm); return 0; } @@ -562,17 +562,17 @@ void risc_call_rabi(int* p_nints, int* p_nfloats, scf_3ac_code_t* c, scf_functio src = c->srcs->data[i]; dn = src->dag_node; - int is_float = scf_variable_float(dn->var); - int size = risc_variable_size (dn->var); + int is_float = scf_variable_float(dn->var); + int size = f->rops->variable_size (dn->var); if (is_float) { - if (nfloats < RISC_ABI_NB) - dn->rabi2 = f->rops->find_register_type_id_bytes(is_float, risc_abi_float_regs[nfloats++], size); + if (nfloats < f->rops->ABI_NB) + dn->rabi2 = f->rops->find_register_type_id_bytes(is_float, f->rops->abi_float_regs[nfloats++], size); else dn->rabi2 = NULL; } else { - if (nints < RISC_ABI_NB) - dn->rabi2 = f->rops->find_register_type_id_bytes(is_float, risc_abi_regs[nints++], size); + if (nints < f->rops->ABI_NB) + dn->rabi2 = f->rops->find_register_type_id_bytes(is_float, f->rops->abi_regs[nints++], size); else dn->rabi2 = NULL; } diff --git a/native/risc/scf_risc_reg.h b/native/risc/scf_risc_reg.h index 4fea8c2..abd1e68 100644 --- a/native/risc/scf_risc_reg.h +++ b/native/risc/scf_risc_reg.h @@ -31,127 +31,17 @@ assert(dn->color > 0); \ } while (0) -static uint32_t risc_abi_regs[] = -{ - SCF_RISC_REG_X0, - SCF_RISC_REG_X1, - SCF_RISC_REG_X2, - SCF_RISC_REG_X3, - SCF_RISC_REG_X4, - SCF_RISC_REG_X5, - SCF_RISC_REG_X6, - SCF_RISC_REG_X7, -}; - -static uint32_t risc_abi_float_regs[] = -{ - SCF_RISC_REG_D0, - SCF_RISC_REG_D1, - SCF_RISC_REG_D2, - SCF_RISC_REG_D3, - SCF_RISC_REG_D4, - SCF_RISC_REG_D5, - SCF_RISC_REG_D6, - SCF_RISC_REG_D7, -}; -#define RISC_ABI_NB (sizeof(risc_abi_regs) / sizeof(risc_abi_regs[0])) - -static uint32_t risc_abi_ret_regs[] = -{ - SCF_RISC_REG_X0, - SCF_RISC_REG_X1, - SCF_RISC_REG_X2, - SCF_RISC_REG_X3, -}; -#define RISC_ABI_RET_NB (sizeof(risc_abi_ret_regs) / sizeof(risc_abi_ret_regs[0])) - -static uint32_t risc_abi_caller_saves[] = -{ - SCF_RISC_REG_X0, - SCF_RISC_REG_X1, - SCF_RISC_REG_X2, - SCF_RISC_REG_X3, - SCF_RISC_REG_X4, - SCF_RISC_REG_X5, - SCF_RISC_REG_X6, - SCF_RISC_REG_X7, - - SCF_RISC_REG_X9, - SCF_RISC_REG_X10, - SCF_RISC_REG_X11, - SCF_RISC_REG_X12, - SCF_RISC_REG_X13, - SCF_RISC_REG_X14, - SCF_RISC_REG_X15, -}; -#define RISC_ABI_CALLER_SAVES_NB (sizeof(risc_abi_caller_saves) / sizeof(risc_abi_caller_saves[0])) - -static uint32_t risc_abi_callee_saves[] = -{ - SCF_RISC_REG_X19, - SCF_RISC_REG_X20, - SCF_RISC_REG_X21, - SCF_RISC_REG_X22, - SCF_RISC_REG_X23, - SCF_RISC_REG_X24, - SCF_RISC_REG_X25, - SCF_RISC_REG_X26, - SCF_RISC_REG_X27, - SCF_RISC_REG_X28, - SCF_RISC_REG_X29, - SCF_RISC_REG_X30, -}; -#define RISC_ABI_CALLEE_SAVES_NB (sizeof(risc_abi_callee_saves) / sizeof(risc_abi_callee_saves[0])) - -static inline int risc_variable_size(scf_variable_t* v) -{ - if (v->nb_dimentions > 0) - return 8; - - if (v->type >= SCF_STRUCT && 0 == v->nb_pointers) - return 8; - - return v->size < 4 ? 4 : v->size; -} - -typedef int (*risc_sib_fill_pt)(scf_sib_t* sib, scf_dag_node_t* base, scf_dag_node_t* index, scf_3ac_code_t* c, scf_function_t* f); - -int risc_registers_init(); -int risc_registers_reset(); -void risc_registers_clear(); -scf_vector_t* risc_register_colors(); - -scf_register_t* risc_find_register(const char* name); - -scf_register_t* risc_find_register_type_id_bytes(uint32_t type, uint32_t id, int bytes); - -scf_register_t* risc_find_register_color(intptr_t color); - -scf_register_t* risc_find_register_color_bytes(intptr_t color, int bytes); - -scf_register_t* risc_find_abi_register(int index, int bytes); - -scf_register_t* risc_select_overflowed_reg(scf_dag_node_t* dn, scf_3ac_code_t* c, int is_float); - -int risc_reg_cached_vars(scf_register_t* r); - -int risc_save_var(scf_dag_node_t* dn, scf_3ac_code_t* c, scf_function_t* f); +#define RISC_ABI_CALLER_SAVES_MAX 32 +#define RISC_ABI_RET_MAX 8 -int risc_save_var2(scf_dag_node_t* dn, scf_register_t* r, scf_3ac_code_t* c, scf_function_t* f); - -int risc_pop_regs(scf_3ac_code_t* c, scf_function_t* f, scf_register_t** regs, int nb_regs, scf_register_t** updated_regs, int nb_updated); +int risc_save_var (scf_dag_node_t* dn, scf_3ac_code_t* c, scf_function_t* f); -int risc_caller_save_regs(scf_3ac_code_t* c, scf_function_t* f, uint32_t* regs, int nb_regs, int stack_size, scf_register_t** saved_regs); +int risc_save_var2(scf_dag_node_t* dn, scf_register_t* r, scf_3ac_code_t* c, scf_function_t* f); -int risc_save_reg(scf_register_t* r, scf_3ac_code_t* c, scf_function_t* f); +int risc_save_reg (scf_register_t* r, scf_3ac_code_t* c, scf_function_t* f); int risc_load_const(scf_register_t* r, scf_dag_node_t* dn, scf_3ac_code_t* c, scf_function_t* f); int risc_load_reg (scf_register_t* r, scf_dag_node_t* dn, scf_3ac_code_t* c, scf_function_t* f); -int risc_reg_used (scf_register_t* r, scf_dag_node_t* dn); - -int risc_overflow_reg (scf_register_t* r, scf_3ac_code_t* c, scf_function_t* f); -int risc_overflow_reg2(scf_register_t* r, scf_dag_node_t* dn, scf_3ac_code_t* c, scf_function_t* f); -int risc_overflow_reg3(scf_register_t* r, scf_dag_node_t* dn, scf_3ac_code_t* c, scf_function_t* f); int risc_select_reg(scf_register_t** preg, scf_dag_node_t* dn, scf_3ac_code_t* c, scf_function_t* f, int load_flag); @@ -165,39 +55,5 @@ int risc_array_index_reg(scf_sib_t* sib, scf_dag_node_t* base, s void risc_call_rabi(int* p_nints, int* p_nfloats, scf_3ac_code_t* c, scf_function_t* f); -static inline int risc_inst_data_is_reg(scf_inst_data_t* id) -{ - scf_register_t* fp = (scf_register_t*)risc_find_register("fp"); - scf_register_t* sp = (scf_register_t*)risc_find_register("sp"); - - if (!id->flag && id->base && id->base != sp && id->base != fp && 0 == id->imm_size) - return 1; - return 0; -} - -static inline int risc_inst_data_is_local(scf_inst_data_t* id) -{ - scf_register_t* fp = (scf_register_t*)risc_find_register("fp"); - scf_register_t* sp = (scf_register_t*)risc_find_register("sp"); - - if (id->flag && (id->base == fp || id->base == sp)) - return 1; - return 0; -} - -static inline int risc_inst_data_is_global(scf_inst_data_t* id) -{ - if (id->flag && !id->base) - return 1; - return 0; -} - -static inline int risc_inst_data_is_const(scf_inst_data_t* id) -{ - if (!id->flag && id->imm_size > 0) - return 1; - return 0; -} - #endif diff --git a/native/risc/scf_risc_reg_arm32.c b/native/risc/scf_risc_reg_arm32.c new file mode 100644 index 0000000..36108b1 --- /dev/null +++ b/native/risc/scf_risc_reg_arm32.c @@ -0,0 +1,937 @@ +#include"scf_risc.h" + +#define SCF_RISC_REG_FP 11 +#define SCF_RISC_REG_SP 13 +#define SCF_RISC_REG_LR 14 +#define SCF_RISC_REG_PC 15 + +scf_register_t arm32_registers[] = { + + {0, 1, "b0", RISC_COLOR(0, 0, 0x1), NULL, 0, 0}, + {0, 2, "h0", RISC_COLOR(0, 0, 0x3), NULL, 0, 0}, + {0, 4, "x0", RISC_COLOR(0, 0, 0xf), NULL, 0, 0}, + + {1, 1, "b1", RISC_COLOR(0, 1, 0x1), NULL, 0, 0}, + {1, 2, "h1", RISC_COLOR(0, 1, 0x3), NULL, 0, 0}, + {1, 4, "x1", RISC_COLOR(0, 1, 0xf), NULL, 0, 0}, + + {2, 1, "b2", RISC_COLOR(0, 2, 0x1), NULL, 0, 0}, + {2, 2, "h2", RISC_COLOR(0, 2, 0x3), NULL, 0, 0}, + {2, 4, "x2", RISC_COLOR(0, 2, 0xf), NULL, 0, 0}, + + {3, 1, "b3", RISC_COLOR(0, 3, 0x1), NULL, 0, 0}, + {3, 2, "h3", RISC_COLOR(0, 3, 0x3), NULL, 0, 0}, + {3, 4, "x3", RISC_COLOR(0, 3, 0xf), NULL, 0, 0}, + + {4, 1, "b4", RISC_COLOR(0, 4, 0x1), NULL, 0, 0}, + {4, 2, "h4", RISC_COLOR(0, 4, 0x3), NULL, 0, 0}, + {4, 4, "x4", RISC_COLOR(0, 4, 0xf), NULL, 0, 0}, + + {5, 1, "b5", RISC_COLOR(0, 5, 0x1), NULL, 0, 0}, + {5, 2, "h5", RISC_COLOR(0, 5, 0x3), NULL, 0, 0}, + {5, 4, "x5", RISC_COLOR(0, 5, 0xf), NULL, 0, 0}, + + {6, 1, "b6", RISC_COLOR(0, 6, 0x1), NULL, 0, 0}, + {6, 2, "h6", RISC_COLOR(0, 6, 0x3), NULL, 0, 0}, + {6, 4, "x6", RISC_COLOR(0, 6, 0xf), NULL, 0, 0}, + + {7, 1, "b7", RISC_COLOR(0, 7, 0x1), NULL, 0, 0}, + {7, 2, "h7", RISC_COLOR(0, 7, 0x3), NULL, 0, 0}, + {7, 4, "x7", RISC_COLOR(0, 7, 0xf), NULL, 0, 0}, + + {8, 1, "b8", RISC_COLOR(0, 8, 0x1), NULL, 0, 0}, + {8, 2, "h8", RISC_COLOR(0, 8, 0x3), NULL, 0, 0}, + {8, 4, "x8", RISC_COLOR(0, 8, 0xf), NULL, 0, 0}, + + {9, 1, "b9", RISC_COLOR(0, 9, 0x1), NULL, 0, 0}, + {9, 2, "h9", RISC_COLOR(0, 9, 0x3), NULL, 0, 0}, + {9, 4, "x9", RISC_COLOR(0, 9, 0xf), NULL, 0, 0}, + + {10, 1, "b10", RISC_COLOR(0, 10, 0x1), NULL, 0, 0}, + {10, 2, "h10", RISC_COLOR(0, 10, 0x3), NULL, 0, 0}, + {10, 4, "x10", RISC_COLOR(0, 10, 0xf), NULL, 0, 0}, + + {11, 4, "fp", RISC_COLOR(0, 11, 0xf), NULL, 0, 0}, + + {12, 4, "x12", RISC_COLOR(0, 12, 0xf), NULL, 0, 0}, + + {13, 4, "sp", RISC_COLOR(0, 13, 0xf), NULL, 0, 0}, + + {14, 4, "lr", RISC_COLOR(0, 14, 0xf), NULL, 0, 0}, + +// {15, 4, "pc", RISC_COLOR(0, 15, 0xf), NULL, 0, 0}, + +#if 0 + {0, 2, "h0", RISC_COLOR(1, 0, 0x3), NULL, 0, 0}, + {0, 4, "s0", RISC_COLOR(1, 0, 0xf), NULL, 0, 0}, + {0, 8, "d0", RISC_COLOR(1, 0, 0xff), NULL, 0, 0}, + + {1, 2, "h1", RISC_COLOR(1, 1, 0x3), NULL, 0, 0}, + {1, 4, "s1", RISC_COLOR(1, 1, 0xf), NULL, 0, 0}, + {1, 8, "d1", RISC_COLOR(1, 1, 0xff), NULL, 0, 0}, + + {2, 2, "h2", RISC_COLOR(1, 2, 0x3), NULL, 0, 0}, + {2, 4, "s2", RISC_COLOR(1, 2, 0xf), NULL, 0, 0}, + {2, 8, "d2", RISC_COLOR(1, 2, 0xff), NULL, 0, 0}, + + {3, 2, "h3", RISC_COLOR(1, 3, 0x3), NULL, 0, 0}, + {3, 4, "s3", RISC_COLOR(1, 3, 0xf), NULL, 0, 0}, + {3, 8, "d3", RISC_COLOR(1, 3, 0xff), NULL, 0, 0}, + + {4, 2, "h4", RISC_COLOR(1, 4, 0x3), NULL, 0, 0}, + {4, 4, "s4", RISC_COLOR(1, 4, 0xf), NULL, 0, 0}, + {4, 8, "d4", RISC_COLOR(1, 4, 0xff), NULL, 0, 0}, + + {5, 2, "h5", RISC_COLOR(1, 5, 0x3), NULL, 0, 0}, + {5, 4, "s5", RISC_COLOR(1, 5, 0xf), NULL, 0, 0}, + {5, 8, "d5", RISC_COLOR(1, 5, 0xff), NULL, 0, 0}, + + {6, 2, "h6", RISC_COLOR(1, 6, 0x3), NULL, 0, 0}, + {6, 4, "s6", RISC_COLOR(1, 6, 0xf), NULL, 0, 0}, + {6, 8, "d6", RISC_COLOR(1, 6, 0xff), NULL, 0, 0}, + + {7, 2, "h7", RISC_COLOR(1, 7, 0x3), NULL, 0, 0}, + {7, 4, "s7", RISC_COLOR(1, 7, 0xf), NULL, 0, 0}, + {7, 8, "d7", RISC_COLOR(1, 7, 0xff), NULL, 0, 0}, + + {8, 2, "h8", RISC_COLOR(1, 8, 0x3), NULL, 0, 0}, + {8, 4, "s8", RISC_COLOR(1, 8, 0xf), NULL, 0, 0}, + {8, 8, "d8", RISC_COLOR(1, 8, 0xff), NULL, 0, 0}, + + {9, 2, "h9", RISC_COLOR(1, 9, 0x3), NULL, 0, 0}, + {9, 4, "s9", RISC_COLOR(1, 9, 0xf), NULL, 0, 0}, + {9, 8, "d9", RISC_COLOR(1, 9, 0xff), NULL, 0, 0}, + + {10, 2, "h10", RISC_COLOR(1, 10, 0x3), NULL, 0, 0}, + {10, 4, "s10", RISC_COLOR(1, 10, 0xf), NULL, 0, 0}, + {10, 8, "d10", RISC_COLOR(1, 10, 0xff), NULL, 0, 0}, + + {11, 2, "h11", RISC_COLOR(1, 11, 0x3), NULL, 0, 0}, + {11, 4, "s11", RISC_COLOR(1, 11, 0xf), NULL, 0, 0}, + {11, 8, "d11", RISC_COLOR(1, 11, 0xff), NULL, 0, 0}, + + {12, 2, "h12", RISC_COLOR(1, 12, 0x3), NULL, 0, 0}, + {12, 4, "s12", RISC_COLOR(1, 12, 0xf), NULL, 0, 0}, + {12, 8, "d12", RISC_COLOR(1, 12, 0xff), NULL, 0, 0}, + + {13, 2, "h13", RISC_COLOR(1, 13, 0x3), NULL, 0, 0}, + {13, 4, "s13", RISC_COLOR(1, 13, 0xf), NULL, 0, 0}, + {13, 8, "d13", RISC_COLOR(1, 13, 0xff), NULL, 0, 0}, + + {14, 2, "h14", RISC_COLOR(1, 14, 0x3), NULL, 0, 0}, + {14, 4, "s14", RISC_COLOR(1, 14, 0xf), NULL, 0, 0}, + {14, 8, "d14", RISC_COLOR(1, 14, 0xff), NULL, 0, 0}, + + {15, 2, "h15", RISC_COLOR(1, 15, 0x3), NULL, 0, 0}, + {15, 4, "s15", RISC_COLOR(1, 15, 0xf), NULL, 0, 0}, + {15, 8, "d15", RISC_COLOR(1, 15, 0xff), NULL, 0, 0}, + + {16, 2, "h16", RISC_COLOR(1, 16, 0x3), NULL, 0, 0}, + {16, 4, "s16", RISC_COLOR(1, 16, 0xf), NULL, 0, 0}, + {16, 8, "d16", RISC_COLOR(1, 16, 0xff), NULL, 0, 0}, + + {17, 2, "h17", RISC_COLOR(1, 17, 0x3), NULL, 0, 0}, + {17, 4, "s17", RISC_COLOR(1, 17, 0xf), NULL, 0, 0}, + {17, 8, "d17", RISC_COLOR(1, 17, 0xff), NULL, 0, 0}, + + {18, 2, "h18", RISC_COLOR(1, 18, 0x3), NULL, 0, 0}, + {18, 4, "s18", RISC_COLOR(1, 18, 0xf), NULL, 0, 0}, + {18, 8, "d18", RISC_COLOR(1, 18, 0xff), NULL, 0, 0}, + + {19, 2, "h19", RISC_COLOR(1, 19, 0x3), NULL, 0, 0}, + {19, 4, "s19", RISC_COLOR(1, 19, 0xf), NULL, 0, 0}, + {19, 8, "d19", RISC_COLOR(1, 19, 0xff), NULL, 0, 0}, + + {20, 2, "h20", RISC_COLOR(1, 20, 0x3), NULL, 0, 0}, + {20, 4, "s20", RISC_COLOR(1, 20, 0xf), NULL, 0, 0}, + {20, 8, "d20", RISC_COLOR(1, 20, 0xff), NULL, 0, 0}, + + {21, 2, "h21", RISC_COLOR(1, 21, 0x3), NULL, 0, 0}, + {21, 4, "s21", RISC_COLOR(1, 21, 0xf), NULL, 0, 0}, + {21, 8, "d21", RISC_COLOR(1, 21, 0xff), NULL, 0, 0}, + + {22, 2, "h22", RISC_COLOR(1, 22, 0x3), NULL, 0, 0}, + {22, 4, "s22", RISC_COLOR(1, 22, 0xf), NULL, 0, 0}, + {22, 8, "d22", RISC_COLOR(1, 22, 0xff), NULL, 0, 0}, + + {23, 2, "h23", RISC_COLOR(1, 23, 0x3), NULL, 0, 0}, + {23, 4, "s23", RISC_COLOR(1, 23, 0xf), NULL, 0, 0}, + {23, 8, "d23", RISC_COLOR(1, 23, 0xff), NULL, 0, 0}, + + {24, 2, "h24", RISC_COLOR(1, 24, 0x3), NULL, 0, 0}, + {24, 4, "s24", RISC_COLOR(1, 24, 0xf), NULL, 0, 0}, + {24, 8, "d24", RISC_COLOR(1, 24, 0xff), NULL, 0, 0}, + + {25, 2, "h25", RISC_COLOR(1, 25, 0x3), NULL, 0, 0}, + {25, 4, "s25", RISC_COLOR(1, 25, 0xf), NULL, 0, 0}, + {25, 8, "d25", RISC_COLOR(1, 25, 0xff), NULL, 0, 0}, + + {26, 2, "h26", RISC_COLOR(1, 26, 0x3), NULL, 0, 0}, + {26, 4, "s26", RISC_COLOR(1, 26, 0xf), NULL, 0, 0}, + {26, 8, "d26", RISC_COLOR(1, 26, 0xff), NULL, 0, 0}, + + {27, 2, "h27", RISC_COLOR(1, 27, 0x3), NULL, 0, 0}, + {27, 4, "s27", RISC_COLOR(1, 27, 0xf), NULL, 0, 0}, + {27, 8, "d27", RISC_COLOR(1, 27, 0xff), NULL, 0, 0}, + + {28, 2, "h28", RISC_COLOR(1, 28, 0x3), NULL, 0, 0}, + {28, 4, "s28", RISC_COLOR(1, 28, 0xf), NULL, 0, 0}, + {28, 8, "d28", RISC_COLOR(1, 28, 0xff), NULL, 0, 0}, + + {29, 2, "h29", RISC_COLOR(1, 29, 0x3), NULL, 0, 0}, + {29, 4, "s29", RISC_COLOR(1, 29, 0xf), NULL, 0, 0}, + {29, 8, "d29", RISC_COLOR(1, 29, 0xff), NULL, 0, 0}, + + {30, 2, "h30", RISC_COLOR(1, 30, 0x3), NULL, 0, 0}, + {30, 4, "s30", RISC_COLOR(1, 30, 0xf), NULL, 0, 0}, + {30, 8, "d30", RISC_COLOR(1, 30, 0xff), NULL, 0, 0}, + + {31, 2, "h31", RISC_COLOR(1, 31, 0x3), NULL, 0, 0}, + {31, 4, "s31", RISC_COLOR(1, 31, 0xf), NULL, 0, 0}, + {31, 8, "d31", RISC_COLOR(1, 31, 0xff), NULL, 0, 0}, +#endif +}; + +static uint32_t arm32_abi_regs[] = +{ + SCF_RISC_REG_X0, + SCF_RISC_REG_X1, + SCF_RISC_REG_X2, + SCF_RISC_REG_X3, +}; + +static uint32_t arm32_abi_float_regs[] = +{ + SCF_RISC_REG_D0, + SCF_RISC_REG_D1, + SCF_RISC_REG_D2, + SCF_RISC_REG_D3, + SCF_RISC_REG_D4, + SCF_RISC_REG_D5, + SCF_RISC_REG_D6, + SCF_RISC_REG_D7, +}; + +static uint32_t arm32_abi_ret_regs[] = +{ + SCF_RISC_REG_X0, + SCF_RISC_REG_X1, + SCF_RISC_REG_X2, + SCF_RISC_REG_X3, +}; + +static uint32_t arm32_abi_caller_saves[] = +{ + SCF_RISC_REG_X0, + SCF_RISC_REG_X1, + SCF_RISC_REG_X2, + SCF_RISC_REG_X3, +}; + +static uint32_t arm32_abi_callee_saves[] = +{ + SCF_RISC_REG_X4, + SCF_RISC_REG_X5, + SCF_RISC_REG_X6, + SCF_RISC_REG_X7, + SCF_RISC_REG_X8, + SCF_RISC_REG_X9, + SCF_RISC_REG_X10, + SCF_RISC_REG_X11, + SCF_RISC_REG_X13, + SCF_RISC_REG_X14, +}; + +static int arm32_variable_size(scf_variable_t* v) +{ + if (v->nb_dimentions > 0) + return 4; + + if (v->nb_pointers > 0) + return 4; + + if (v->type >= SCF_STRUCT) + return 4; + + return v->size; +} + +scf_register_t* arm32_find_register(const char* name) +{ + int i; + for (i = 0; i < sizeof(arm32_registers) / sizeof(arm32_registers[0]); i++) { + + scf_register_t* r = &(arm32_registers[i]); + + if (!strcmp(r->name, name)) + return r; + } + return NULL; +} + +scf_register_t* arm32_find_register_type_id_bytes(uint32_t type, uint32_t id, int bytes) +{ + int i; + + if (bytes > 4 && 0 == type) + bytes = 4; + + for (i = 0; i < sizeof(arm32_registers) / sizeof(arm32_registers[0]); i++) { + + scf_register_t* r = &(arm32_registers[i]); + + if (RISC_COLOR_TYPE(r->color) == type && r->id == id && r->bytes == bytes) + return r; + } + return NULL; +} + +scf_register_t* arm32_find_register_color(intptr_t color) +{ + int i; + for (i = 0; i < sizeof(arm32_registers) / sizeof(arm32_registers[0]); i++) { + + scf_register_t* r = &(arm32_registers[i]); + + if (r->color == color) + return r; + } + return NULL; +} + +scf_register_t* arm32_find_register_color_bytes(intptr_t color, int bytes) +{ + int i; + + if (bytes > 4 && 0 == RISC_COLOR_TYPE(color)) + bytes = 4; + + for (i = 0; i < sizeof(arm32_registers) / sizeof(arm32_registers[0]); i++) { + + scf_register_t* r = &(arm32_registers[i]); + + if (RISC_COLOR_CONFLICT(r->color, color) && r->bytes == bytes) + return r; + } + return NULL; +} + +scf_vector_t* arm32_register_colors() +{ + scf_vector_t* colors = scf_vector_alloc(); + if (!colors) + return NULL; + + int i; + for (i = 0; i < sizeof(arm32_registers) / sizeof(arm32_registers[0]); i++) { + + scf_register_t* r = &(arm32_registers[i]); + + if (SCF_RISC_REG_SP == r->id + || SCF_RISC_REG_FP == r->id + || SCF_RISC_REG_LR == r->id + || SCF_RISC_REG_X12 == r->id) + continue; + + int ret = scf_vector_add(colors, (void*)r->color); + if (ret < 0) { + scf_vector_free(colors); + return NULL; + } + } +#if 0 + srand(time(NULL)); + for (i = 0; i < colors->size; i++) { + int j = rand() % colors->size; + + void* t = colors->data[i]; + colors->data[i] = colors->data[j]; + colors->data[j] = t; + } +#endif + return colors; +} + +int arm32_reg_cached_vars(scf_register_t* r) +{ + int nb_vars = 0; + int i; + + for (i = 0; i < sizeof(arm32_registers) / sizeof(arm32_registers[0]); i++) { + + scf_register_t* r2 = &(arm32_registers[i]); + + if (SCF_RISC_REG_SP == r2->id + || SCF_RISC_REG_FP == r2->id + || SCF_RISC_REG_LR == r2->id + || SCF_RISC_REG_X12 == r2->id) + continue; + + if (!RISC_COLOR_CONFLICT(r->color, r2->color)) + continue; + + nb_vars += r2->dag_nodes->size; + } + + return nb_vars; +} + +int arm32_registers_init() +{ + int i; + for (i = 0; i < sizeof(arm32_registers) / sizeof(arm32_registers[0]); i++) { + + scf_register_t* r = &(arm32_registers[i]); + + if (SCF_RISC_REG_SP == r->id + || SCF_RISC_REG_FP == r->id + || SCF_RISC_REG_LR == r->id + || SCF_RISC_REG_X12 == r->id) + continue; + + assert(!r->dag_nodes); + + r->dag_nodes = scf_vector_alloc(); + if (!r->dag_nodes) + return -ENOMEM; + + r->used = 0; + } + + return 0; +} + +void arm32_registers_clear() +{ + int i; + for (i = 0; i < sizeof(arm32_registers) / sizeof(arm32_registers[0]); i++) { + + scf_register_t* r = &(arm32_registers[i]); + + if (SCF_RISC_REG_SP == r->id + || SCF_RISC_REG_FP == r->id + || SCF_RISC_REG_LR == r->id + || SCF_RISC_REG_X12 == r->id) + continue; + + if (r->dag_nodes) { + scf_vector_free(r->dag_nodes); + r->dag_nodes = NULL; + } + + r->used = 0; + } +} + +static scf_register_t* risc_reg_cached_min_vars(scf_register_t** regs, int nb_regs) +{ + scf_register_t* r_min = NULL; + + int min = 0; + int i; + + for (i = 0; i < nb_regs; i++) { + scf_register_t* r = regs[i]; + + int nb_vars = arm32_reg_cached_vars(r); + + if (!r_min) { + r_min = r; + min = nb_vars; + continue; + } + + if (min > nb_vars) { + r_min = r; + min = nb_vars; + } + } + + return r_min; +} + +int arm32_caller_save_regs(scf_3ac_code_t* c, scf_function_t* f, uint32_t* regs, int nb_regs, int stack_size, scf_register_t** saved_regs) +{ + int i; + int j; + scf_instruction_t* inst; + scf_register_t* r; + scf_register_t* r2; + scf_register_t* sp = arm32_find_register("sp"); + + uint32_t opcode; + + int ret; + int size = 0; + int k = 0; + + for (j = 0; j < nb_regs; j++) { + r2 = arm32_find_register_type_id_bytes(0, regs[j], f->rops->MAX_BYTES); + + for (i = 0; i < sizeof(arm32_registers) / sizeof(arm32_registers[0]); i++) { + r = &(arm32_registers[i]); + + if (SCF_RISC_REG_SP == r->id + || SCF_RISC_REG_FP == r->id + || SCF_RISC_REG_LR == r->id + || SCF_RISC_REG_X12 == r->id) + continue; + + if (0 == r->dag_nodes->size) + continue; + + if (RISC_COLOR_CONFLICT(r2->color, r->color)) + break; + } + + if (i == sizeof(arm32_registers) / sizeof(arm32_registers[0])) + continue; + + if (stack_size > 0) { + ret = f->iops->G2P(c, f, r2, sp, size + stack_size, r2->bytes); + if (ret < 0) + return ret; + } else { + inst = f->iops->PUSH(NULL, r2); + RISC_INST_ADD_CHECK(c->instructions, inst); + } + + saved_regs[k++] = r2; + size += r2->bytes; + } + + while (size & 0xf) { + r2 = saved_regs[k - 1]; + + if (stack_size > 0) { + ret = f->iops->G2P(c, f, r2, sp, size + stack_size, r2->bytes); + if (ret < 0) + return ret; + + } else { + inst = f->iops->PUSH(NULL, r2); + RISC_INST_ADD_CHECK(c->instructions, inst); + } + + saved_regs[k++] = r2; + size += r2->bytes; + } + + if (stack_size > 0) { + for (j = 0; j < k / 2; j++) { + + i = k - 1 - j; + SCF_XCHG(saved_regs[i], saved_regs[j]); + } + } + + return size; +} + +int arm32_pop_regs(scf_3ac_code_t* c, scf_function_t* f, scf_register_t** regs, int nb_regs, scf_register_t** updated_regs, int nb_updated) +{ + int i; + int j; + + scf_register_t* sp = arm32_find_register("sp"); + scf_register_t* r; + scf_register_t* r2; + scf_instruction_t* inst; + + for (j = nb_regs - 1; j >= 0; j--) { + r2 = regs[j]; + + for (i = 0; i < sizeof(arm32_registers) / sizeof(arm32_registers[0]); i++) { + r = &(arm32_registers[i]); + + if (SCF_RISC_REG_SP == r->id + || SCF_RISC_REG_FP == r->id + || SCF_RISC_REG_LR == r->id + || SCF_RISC_REG_X12 == r->id) + continue; + + if (0 == r->dag_nodes->size) + continue; + + if (RISC_COLOR_CONFLICT(r2->color, r->color)) + break; + } + + if (i == sizeof(arm32_registers) / sizeof(arm32_registers[0])) + continue; + + for (i = 0; i < nb_updated; i++) { + + r = updated_regs[i]; + + if (RISC_COLOR_CONFLICT(r2->color, r->color)) + break; + } + + if (i == nb_updated) { + inst = f->iops->POP(c, r2); + RISC_INST_ADD_CHECK(c->instructions, inst); + } else { + inst = f->iops->ADD_IMM(c, sp, sp, 4); + RISC_INST_ADD_CHECK(c->instructions, inst); + } + } + return 0; +} + +int arm32_registers_reset() +{ + int i; + for (i = 0; i < sizeof(arm32_registers) / sizeof(arm32_registers[0]); i++) { + + scf_register_t* r = &(arm32_registers[i]); + + if (SCF_RISC_REG_SP == r->id + || SCF_RISC_REG_FP == r->id + || SCF_RISC_REG_LR == r->id + || SCF_RISC_REG_X12 == r->id) + continue; + + if (!r->dag_nodes) + continue; + + int j = 0; + while (j < r->dag_nodes->size) { + scf_dag_node_t* dn = r->dag_nodes->data[j]; + + if (dn->var->w) + scf_logw("drop: v_%d_%d/%s\n", dn->var->w->line, dn->var->w->pos, dn->var->w->text->data); + else + scf_logw("drop: v_%#lx\n", 0xffff & (uintptr_t)dn->var); + + int ret = scf_vector_del(r->dag_nodes, dn); + if (ret < 0) { + scf_loge("\n"); + return ret; + } + + dn->loaded = 0; + dn->color = 0; + } + } + + return 0; +} + + +int arm32_overflow_reg(scf_register_t* r, scf_3ac_code_t* c, scf_function_t* f) +{ + int i; + + for (i = 0; i < sizeof(arm32_registers) / sizeof(arm32_registers[0]); i++) { + + scf_register_t* r2 = &(arm32_registers[i]); + + if (SCF_RISC_REG_SP == r2->id + || SCF_RISC_REG_FP == r2->id + || SCF_RISC_REG_LR == r2->id + || SCF_RISC_REG_X12 == r2->id) + continue; + + if (!RISC_COLOR_CONFLICT(r->color, r2->color)) + continue; + + int ret = risc_save_reg(r2, c, f); + if (ret < 0) { + scf_loge("\n"); + return ret; + } + } + + r->used = 1; + return 0; +} + +int arm32_overflow_reg2(scf_register_t* r, scf_dag_node_t* dn, scf_3ac_code_t* c, scf_function_t* f) +{ + scf_register_t* r2; + scf_dag_node_t* dn2; + + int i; + int j; + + for (i = 0; i < sizeof(arm32_registers) / sizeof(arm32_registers[0]); i++) { + + r2 = &(arm32_registers[i]); + + if (SCF_RISC_REG_SP == r2->id + || SCF_RISC_REG_FP == r2->id + || SCF_RISC_REG_LR == r2->id + || SCF_RISC_REG_X12 == r2->id) + continue; + + if (!RISC_COLOR_CONFLICT(r->color, r2->color)) + continue; + + for (j = 0; j < r2->dag_nodes->size; ) { + dn2 = r2->dag_nodes->data[j]; + + if (dn2 == dn) { + j++; + continue; + } + + int ret = risc_save_var(dn2, c, f); + if (ret < 0) + return ret; + } + } + + r->used = 1; + return 0; +} + +int arm32_overflow_reg3(scf_register_t* r, scf_dag_node_t* dn, scf_3ac_code_t* c, scf_function_t* f) +{ + scf_register_t* r2; + scf_dn_status_t* ds2; + scf_dag_node_t* dn2; + + int i; + int j; + int ret; + + for (i = 0; i < sizeof(arm32_registers) / sizeof(arm32_registers[0]); i++) { + + r2 = &(arm32_registers[i]); + + if (SCF_RISC_REG_SP == r2->id + || SCF_RISC_REG_FP == r2->id + || SCF_RISC_REG_LR == r2->id + || SCF_RISC_REG_X12 == r2->id) + continue; + + if (!RISC_COLOR_CONFLICT(r->color, r2->color)) + continue; + + for (j = 0; j < r2->dag_nodes->size; ) { + dn2 = r2->dag_nodes->data[j]; + + if (dn2 == dn) { + j++; + continue; + } + + ds2 = scf_vector_find_cmp(c->active_vars, dn2, scf_dn_status_cmp); + if (!ds2) { + j++; + continue; + } + + if (!ds2->active) { + j++; + continue; + } +#if 1 + scf_variable_t* v = dn->var; + scf_variable_t* v2 = dn2->var; + if (v->w) + scf_loge("v_%d_%d/%s, bp_offset: %d\n", v->w->line, v->w->pos, v->w->text->data, v->bp_offset); + else + scf_loge("v_%#lx, bp_offset: %d\n", 0xffff & (uintptr_t)v, v->bp_offset); + + if (v2->w) + scf_loge("v2_%d_%d/%s, bp_offset: %d\n", v2->w->line, v2->w->pos, v2->w->text->data, v2->bp_offset); + else + scf_loge("v2_%#lx, bp_offset: %d\n", 0xffff & (uintptr_t)v2, v2->bp_offset); +#endif + int ret = risc_save_var(dn2, c, f); + if (ret < 0) + return ret; + } + } + + r->used = 1; + return 0; +} + +int arm32_reg_used(scf_register_t* r, scf_dag_node_t* dn) +{ + scf_register_t* r2; + scf_dag_node_t* dn2; + + int i; + int j; + + for (i = 0; i < sizeof(arm32_registers) / sizeof(arm32_registers[0]); i++) { + + r2 = &(arm32_registers[i]); + + if (SCF_RISC_REG_SP == r2->id + || SCF_RISC_REG_FP == r2->id + || SCF_RISC_REG_LR == r2->id + || SCF_RISC_REG_X12 == r2->id) + continue; + + if (!RISC_COLOR_CONFLICT(r->color, r2->color)) + continue; + + for (j = 0; j < r2->dag_nodes->size; j++) { + dn2 = r2->dag_nodes->data[j]; + + if (dn2 != dn) + return 1; + } + } + return 0; +} + +scf_register_t* arm32_select_overflowed_reg(scf_dag_node_t* dn, scf_3ac_code_t* c, int is_float) +{ + scf_vector_t* neighbors = NULL; + scf_graph_node_t* gn = NULL; + scf_register_t* free_regs[sizeof(arm32_registers) / sizeof(arm32_registers[0])]; + + int nb_free_regs = 0; + int bytes = 4; + int ret; + int i; + int j; + + assert(c->rcg); + + if (dn) { + is_float = scf_variable_float(dn->var); + bytes = arm32_variable_size (dn->var); + } + + ret = risc_rcg_find_node(&gn, c->rcg, dn, NULL); + if (ret < 0) + neighbors = c->rcg->nodes; + else + neighbors = gn->neighbors; + + for (i = 0; i < sizeof(arm32_registers) / sizeof(arm32_registers[0]); i++) { + + scf_register_t* r = &(arm32_registers[i]); + + if (SCF_RISC_REG_SP == r->id + || SCF_RISC_REG_FP == r->id + || SCF_RISC_REG_LR == r->id + || SCF_RISC_REG_X12 == r->id) + continue; + + if (r->bytes < bytes || RISC_COLOR_TYPE(r->color) != is_float) + continue; + + for (j = 0; j < neighbors->size; j++) { + + scf_graph_node_t* neighbor = neighbors->data[j]; + risc_rcg_node_t* rn = neighbor->data; + + if (rn->dag_node) { + if (rn->dag_node->color <= 0) + continue; + + if (RISC_COLOR_CONFLICT(r->color, rn->dag_node->color)) + break; + } else { + assert(rn->reg); + + if (RISC_COLOR_CONFLICT(r->color, rn->reg->color)) + break; + } + } + + if (j == neighbors->size) + free_regs[nb_free_regs++] = r; + } + + if (nb_free_regs > 0) + return risc_reg_cached_min_vars(free_regs, nb_free_regs); + + for (i = 0; i < sizeof(arm32_registers) / sizeof(arm32_registers[0]); i++) { + + scf_register_t* r = &(arm32_registers[i]); + + if (SCF_RISC_REG_SP == r->id + || SCF_RISC_REG_FP == r->id + || SCF_RISC_REG_LR == r->id + || SCF_RISC_REG_X12 == r->id) + continue; + + if (r->bytes < bytes || RISC_COLOR_TYPE(r->color) != is_float) + continue; + + if (c->dsts) { + scf_3ac_operand_t* dst; + + for (j = 0; j < c->dsts->size; j++) { + dst = c->dsts->data[j]; + + if (dst->dag_node && dst->dag_node->color > 0 + && RISC_COLOR_CONFLICT(r->color, dst->dag_node->color)) + break; + } + + if (j < c->dsts->size) + continue; + } + + if (c->srcs) { + scf_3ac_operand_t* src; + + for (j = 0; j < c->srcs->size; j++) { + src = c->srcs->data[j]; + + if (src->dag_node && src->dag_node->color > 0 + && RISC_COLOR_CONFLICT(r->color, src->dag_node->color)) + break; + } + + if (j < c->srcs->size) + continue; + } + + return r; + } + + return NULL; +} + +scf_regs_ops_t regs_ops_arm32 = +{ + .name = "arm32", + + .abi_regs = arm32_abi_regs, + .abi_float_regs = arm32_abi_float_regs, + .abi_ret_regs = arm32_abi_ret_regs, + .abi_caller_saves = arm32_abi_caller_saves, + .abi_callee_saves = arm32_abi_callee_saves, + + .ABI_NB = sizeof(arm32_abi_regs) / sizeof(uint32_t), + .ABI_RET_NB = sizeof(arm32_abi_ret_regs) / sizeof(uint32_t), + .ABI_CALLER_SAVES_NB = sizeof(arm32_abi_caller_saves) / sizeof(uint32_t), + .ABI_CALLEE_SAVES_NB = sizeof(arm32_abi_callee_saves) / sizeof(uint32_t), + + .MAX_BYTES = 4, + + .registers_init = arm32_registers_init, + .registers_reset = arm32_registers_reset, + .registers_clear = arm32_registers_clear, + .register_colors = arm32_register_colors, + + .reg_used = arm32_reg_used, + .reg_cached_vars = arm32_reg_cached_vars, + + .variable_size = arm32_variable_size, + + .caller_save_regs = arm32_caller_save_regs, + .pop_regs = arm32_pop_regs, + + .find_register = arm32_find_register, + .find_register_color = arm32_find_register_color, + .find_register_color_bytes = arm32_find_register_color_bytes, + .find_register_type_id_bytes = arm32_find_register_type_id_bytes, + + .select_overflowed_reg = arm32_select_overflowed_reg, + .overflow_reg = arm32_overflow_reg, + .overflow_reg2 = arm32_overflow_reg2, + .overflow_reg3 = arm32_overflow_reg3, +}; + diff --git a/native/risc/scf_risc_reg_arm64.c b/native/risc/scf_risc_reg_arm64.c index 4560f4b..8a7b321 100644 --- a/native/risc/scf_risc_reg_arm64.c +++ b/native/risc/scf_risc_reg_arm64.c @@ -1,5 +1,9 @@ #include"scf_risc.h" +#define SCF_RISC_REG_FP 29 +#define SCF_RISC_REG_LR 30 +#define SCF_RISC_REG_SP 31 + scf_register_t arm64_registers[] = { {0, 4, "w0", RISC_COLOR(0, 0, 0xf), NULL, 0, 0}, @@ -231,6 +235,85 @@ scf_register_t arm64_registers[] = { {31, 8, "d31", RISC_COLOR(1, 31, 0xff), NULL, 0, 0}, }; +static uint32_t arm64_abi_regs[] = +{ + SCF_RISC_REG_X0, + SCF_RISC_REG_X1, + SCF_RISC_REG_X2, + SCF_RISC_REG_X3, + SCF_RISC_REG_X4, + SCF_RISC_REG_X5, + SCF_RISC_REG_X6, + SCF_RISC_REG_X7, +}; + +static uint32_t arm64_abi_float_regs[] = +{ + SCF_RISC_REG_D0, + SCF_RISC_REG_D1, + SCF_RISC_REG_D2, + SCF_RISC_REG_D3, + SCF_RISC_REG_D4, + SCF_RISC_REG_D5, + SCF_RISC_REG_D6, + SCF_RISC_REG_D7, +}; + +static uint32_t arm64_abi_ret_regs[] = +{ + SCF_RISC_REG_X0, + SCF_RISC_REG_X1, + SCF_RISC_REG_X2, + SCF_RISC_REG_X3, +}; + +static uint32_t arm64_abi_caller_saves[] = +{ + SCF_RISC_REG_X0, + SCF_RISC_REG_X1, + SCF_RISC_REG_X2, + SCF_RISC_REG_X3, + SCF_RISC_REG_X4, + SCF_RISC_REG_X5, + SCF_RISC_REG_X6, + SCF_RISC_REG_X7, + + SCF_RISC_REG_X9, + SCF_RISC_REG_X10, + SCF_RISC_REG_X11, + SCF_RISC_REG_X12, + SCF_RISC_REG_X13, + SCF_RISC_REG_X14, + SCF_RISC_REG_X15, +}; + +static uint32_t arm64_abi_callee_saves[] = +{ + SCF_RISC_REG_X19, + SCF_RISC_REG_X20, + SCF_RISC_REG_X21, + SCF_RISC_REG_X22, + SCF_RISC_REG_X23, + SCF_RISC_REG_X24, + SCF_RISC_REG_X25, + SCF_RISC_REG_X26, + SCF_RISC_REG_X27, + SCF_RISC_REG_X28, + SCF_RISC_REG_X29, + SCF_RISC_REG_X30, +}; + +static int arm64_variable_size(scf_variable_t* v) +{ + if (v->nb_dimentions > 0) + return 8; + + if (v->type >= SCF_STRUCT && 0 == v->nb_pointers) + return 8; + + return v->size < 4 ? 4 : v->size; +} + scf_register_t* arm64_find_register(const char* name) { int i; @@ -394,7 +477,7 @@ void arm64_registers_clear() } } -scf_register_t* risc_reg_cached_min_vars(scf_register_t** regs, int nb_regs) +static scf_register_t* risc_reg_cached_min_vars(scf_register_t** regs, int nb_regs) { scf_register_t* r_min = NULL; @@ -775,7 +858,7 @@ scf_register_t* arm64_select_overflowed_reg(scf_dag_node_t* dn, scf_3ac_code_t* if (dn) { is_float = scf_variable_float(dn->var); - bytes = risc_variable_size (dn->var); + bytes = arm64_variable_size (dn->var); } ret = risc_rcg_find_node(&gn, c->rcg, dn, NULL); @@ -874,10 +957,28 @@ scf_register_t* arm64_select_overflowed_reg(scf_dag_node_t* dn, scf_3ac_code_t* return NULL; } +#define RISC_ABI_NB (sizeof(arm64_abi_regs) / sizeof(arm64_abi_regs[0])) +#define RISC_ABI_RET_NB (sizeof(risc_abi_ret_regs) / sizeof(risc_abi_ret_regs[0])) +#define RISC_ABI_CALLER_SAVES_NB (sizeof(risc_abi_caller_saves) / sizeof(risc_abi_caller_saves[0])) +#define RISC_ABI_CALLEE_SAVES_NB (sizeof(risc_abi_callee_saves) / sizeof(risc_abi_callee_saves[0])) + scf_regs_ops_t regs_ops_arm64 = { .name = "arm64", + .abi_regs = arm64_abi_regs, + .abi_float_regs = arm64_abi_float_regs, + .abi_ret_regs = arm64_abi_ret_regs, + .abi_caller_saves = arm64_abi_caller_saves, + .abi_callee_saves = arm64_abi_callee_saves, + + .ABI_NB = sizeof(arm64_abi_regs) / sizeof(uint32_t), + .ABI_RET_NB = sizeof(arm64_abi_ret_regs) / sizeof(uint32_t), + .ABI_CALLER_SAVES_NB = sizeof(arm64_abi_caller_saves) / sizeof(uint32_t), + .ABI_CALLEE_SAVES_NB = sizeof(arm64_abi_callee_saves) / sizeof(uint32_t), + + .MAX_BYTES = 8, + .registers_init = arm64_registers_init, .registers_reset = arm64_registers_reset, .registers_clear = arm64_registers_clear, @@ -886,6 +987,8 @@ scf_regs_ops_t regs_ops_arm64 = .reg_used = arm64_reg_used, .reg_cached_vars = arm64_reg_cached_vars, + .variable_size = arm64_variable_size, + .caller_save_regs = arm64_caller_save_regs, .pop_regs = arm64_pop_regs, @@ -904,6 +1007,19 @@ scf_regs_ops_t regs_ops_naja = { .name = "naja", + .abi_regs = arm64_abi_regs, + .abi_float_regs = arm64_abi_float_regs, + .abi_ret_regs = arm64_abi_ret_regs, + .abi_caller_saves = arm64_abi_caller_saves, + .abi_callee_saves = arm64_abi_callee_saves, + + .ABI_NB = sizeof(arm64_abi_regs) / sizeof(uint32_t), + .ABI_RET_NB = sizeof(arm64_abi_ret_regs) / sizeof(uint32_t), + .ABI_CALLER_SAVES_NB = sizeof(arm64_abi_caller_saves) / sizeof(uint32_t), + .ABI_CALLEE_SAVES_NB = sizeof(arm64_abi_callee_saves) / sizeof(uint32_t), + + .MAX_BYTES = 8, + .registers_init = arm64_registers_init, .registers_reset = arm64_registers_reset, .registers_clear = arm64_registers_clear, @@ -912,6 +1028,8 @@ scf_regs_ops_t regs_ops_naja = .reg_used = arm64_reg_used, .reg_cached_vars = arm64_reg_cached_vars, + .variable_size = arm64_variable_size, + .caller_save_regs = arm64_caller_save_regs, .pop_regs = arm64_pop_regs, diff --git a/native/risc/scf_risc_util.h b/native/risc/scf_risc_util.h index bed67ce..5e943f2 100644 --- a/native/risc/scf_risc_util.h +++ b/native/risc/scf_risc_util.h @@ -222,12 +222,10 @@ enum scf_risc_REGs { SCF_RISC_REG_X28 = 28, SCF_RISC_REG_X29 = 29, - SCF_RISC_REG_FP = 29, SCF_RISC_REG_X30 = 30, - SCF_RISC_REG_LR = 30, - SCF_RISC_REG_SP = 31, + SCF_RISC_REG_X31 = 31, }; enum scf_risc_EG_types { diff --git a/native/scf_native.h b/native/scf_native.h index e5b0b66..e3cf74f 100644 --- a/native/scf_native.h +++ b/native/scf_native.h @@ -99,6 +99,19 @@ struct scf_regs_ops_s { const char* name; + uint32_t* abi_regs; + uint32_t* abi_float_regs; + uint32_t* abi_ret_regs; + uint32_t* abi_caller_saves; + uint32_t* abi_callee_saves; + + const int ABI_NB; + const int ABI_RET_NB; + const int ABI_CALLER_SAVES_NB; + const int ABI_CALLEE_SAVES_NB; + + const int MAX_BYTES; + int (*registers_init )(); int (*registers_reset )(); void (*registers_clear )(); @@ -107,6 +120,8 @@ struct scf_regs_ops_s int (*reg_used )(scf_register_t* r, scf_dag_node_t* dn); int (*reg_cached_vars )(scf_register_t* r); + int (*variable_size )(scf_variable_t* v); + int (*caller_save_regs)(scf_3ac_code_t* c, scf_function_t* f, uint32_t* regs, int nb_regs, int stack_size, scf_register_t** saved_regs); int (*pop_regs )(scf_3ac_code_t* c, scf_function_t* f, scf_register_t** regs, int nb_regs, scf_register_t** updated_regs, int nb_updated); @@ -126,7 +141,7 @@ struct scf_inst_ops_s { const char* name; - scf_instruction_t* (*BL )(scf_3ac_code_t* c); + int (*BL )(scf_3ac_code_t* c, scf_function_t* f, scf_function_t* pf); scf_instruction_t* (*BLR )(scf_3ac_code_t* c, scf_register_t* r); scf_instruction_t* (*PUSH )(scf_3ac_code_t* c, scf_register_t* r); scf_instruction_t* (*POP )(scf_3ac_code_t* c, scf_register_t* r); @@ -143,68 +158,69 @@ struct scf_inst_ops_s scf_instruction_t* (*ADD_IMM )(scf_3ac_code_t* c, scf_register_t* rd, scf_register_t* rs, uint64_t imm); scf_instruction_t* (*SUB_G )(scf_3ac_code_t* c, scf_register_t* rd, scf_register_t* rs0, scf_register_t* rs1); scf_instruction_t* (*SUB_IMM )(scf_3ac_code_t* c, scf_register_t* rd, scf_register_t* rs, uint64_t imm); - scf_instruction_t* (*CMP_G)(scf_3ac_code_t* c, scf_register_t* rs0, scf_register_t* rs1); - scf_instruction_t* (*CMP_IMM)(scf_3ac_code_t* c, scf_register_t* rs, uint64_t imm); - scf_instruction_t* (*AND_G)(scf_3ac_code_t* c, scf_register_t* rd, scf_register_t* rs0, scf_register_t* rs1); - scf_instruction_t* (*OR_G)(scf_3ac_code_t* c, scf_register_t* rd, scf_register_t* rs0, scf_register_t* rs1); + scf_instruction_t* (*CMP_G )(scf_3ac_code_t* c, scf_register_t* rs0, scf_register_t* rs1); + scf_instruction_t* (*CMP_IMM )(scf_3ac_code_t* c, scf_register_t* rs, uint64_t imm); + scf_instruction_t* (*AND_G )(scf_3ac_code_t* c, scf_register_t* rd, scf_register_t* rs0, scf_register_t* rs1); + scf_instruction_t* (*OR_G )(scf_3ac_code_t* c, scf_register_t* rd, scf_register_t* rs0, scf_register_t* rs1); scf_instruction_t* (*MUL )(scf_3ac_code_t* c, scf_register_t* rd, scf_register_t* rs0, scf_register_t* rs1); scf_instruction_t* (*DIV )(scf_3ac_code_t* c, scf_register_t* rd, scf_register_t* rs0, scf_register_t* rs1); scf_instruction_t* (*SDIV )(scf_3ac_code_t* c, scf_register_t* rd, scf_register_t* rs0, scf_register_t* rs1); scf_instruction_t* (*MSUB )(scf_3ac_code_t* c, scf_register_t* rd, scf_register_t* rm, scf_register_t* rn, scf_register_t* ra); - scf_instruction_t* (*SHL)(scf_3ac_code_t* c, scf_register_t* rd, scf_register_t* rs0, scf_register_t* rs1); - scf_instruction_t* (*SHR)(scf_3ac_code_t* c, scf_register_t* rd, scf_register_t* rs0, scf_register_t* rs1); - scf_instruction_t* (*ASR)(scf_3ac_code_t* c, scf_register_t* rd, scf_register_t* rs0, scf_register_t* rs1); + scf_instruction_t* (*SHL )(scf_3ac_code_t* c, scf_register_t* rd, scf_register_t* rs0, scf_register_t* rs1); + scf_instruction_t* (*SHR )(scf_3ac_code_t* c, scf_register_t* rd, scf_register_t* rs0, scf_register_t* rs1); + scf_instruction_t* (*ASR )(scf_3ac_code_t* c, scf_register_t* rd, scf_register_t* rs0, scf_register_t* rs1); scf_instruction_t* (*CVTSS2SD)(scf_3ac_code_t* c, scf_register_t* rd, scf_register_t* rs); scf_instruction_t* (*CVTSD2SS)(scf_3ac_code_t* c, scf_register_t* rd, scf_register_t* rs); - scf_instruction_t* (*CVTF2SI)(scf_3ac_code_t* c, scf_register_t* rd, scf_register_t* rs); - scf_instruction_t* (*CVTF2UI)(scf_3ac_code_t* c, scf_register_t* rd, scf_register_t* rs); - scf_instruction_t* (*CVTSI2F)(scf_3ac_code_t* c, scf_register_t* rd, scf_register_t* rs); - scf_instruction_t* (*CVTUI2F)(scf_3ac_code_t* c, scf_register_t* rd, scf_register_t* rs); - - scf_instruction_t* (*FCMP)(scf_3ac_code_t* c, scf_register_t* rs0, scf_register_t* rs1); - scf_instruction_t* (*FADD)(scf_3ac_code_t* c, scf_register_t* rd, scf_register_t* rs0, scf_register_t* rs1); - scf_instruction_t* (*FSUB)(scf_3ac_code_t* c, scf_register_t* rd, scf_register_t* rs0, scf_register_t* rs1); - scf_instruction_t* (*FMUL)(scf_3ac_code_t* c, scf_register_t* rd, scf_register_t* rs0, scf_register_t* rs1); - scf_instruction_t* (*FDIV)(scf_3ac_code_t* c, scf_register_t* rd, scf_register_t* rs0, scf_register_t* rs1); - scf_instruction_t* (*FMOV_G)(scf_3ac_code_t* c, scf_register_t* rd, scf_register_t* rs); - - scf_instruction_t* (*JA )(scf_3ac_code_t* c); - scf_instruction_t* (*JB )(scf_3ac_code_t* c); - scf_instruction_t* (*JZ )(scf_3ac_code_t* c); - scf_instruction_t* (*JNZ)(scf_3ac_code_t* c); - scf_instruction_t* (*JGT)(scf_3ac_code_t* c); - scf_instruction_t* (*JGE)(scf_3ac_code_t* c); - scf_instruction_t* (*JLT)(scf_3ac_code_t* c); - scf_instruction_t* (*JLE)(scf_3ac_code_t* c); - scf_instruction_t* (*JMP)(scf_3ac_code_t* c); - scf_instruction_t* (*JAE)(scf_3ac_code_t* c); - scf_instruction_t* (*JBE)(scf_3ac_code_t* c); - scf_instruction_t* (*RET)(scf_3ac_code_t* c); - - scf_instruction_t* (*SETZ )(scf_3ac_code_t* c, scf_register_t* rd); - scf_instruction_t* (*SETNZ)(scf_3ac_code_t* c, scf_register_t* rd); - scf_instruction_t* (*SETGT)(scf_3ac_code_t* c, scf_register_t* rd); - scf_instruction_t* (*SETGE)(scf_3ac_code_t* c, scf_register_t* rd); - scf_instruction_t* (*SETLT)(scf_3ac_code_t* c, scf_register_t* rd); - scf_instruction_t* (*SETLE)(scf_3ac_code_t* c, scf_register_t* rd); - - int (*I2G )(scf_3ac_code_t* c, scf_register_t* rd, uint64_t imm, int bytes); - int (*M2G )(scf_3ac_code_t* c, scf_function_t* f, scf_register_t* rd, scf_register_t* rb, scf_variable_t* vs); - int (*M2GF )(scf_3ac_code_t* c, scf_function_t* f, scf_register_t* rd, scf_register_t* rb, scf_variable_t* vs); - int (*G2M )(scf_3ac_code_t* c, scf_function_t* f, scf_register_t* rs, scf_register_t* rb, scf_variable_t* vs); - int (*G2P )(scf_3ac_code_t* c, scf_function_t* f, scf_register_t* rs, scf_register_t* rb, int32_t offset, int size); - int (*P2G )(scf_3ac_code_t* c, scf_function_t* f, scf_register_t* rd, scf_register_t* rb, int32_t offset, int size); - int (*ISTR2G)(scf_3ac_code_t* c, scf_function_t* f, scf_register_t* rd, scf_variable_t* vs); - int (*SIB2G )(scf_3ac_code_t* c, scf_function_t* f, scf_register_t* rd, scf_sib_t* sib); - int (*G2SIB )(scf_3ac_code_t* c, scf_function_t* f, scf_register_t* rd, scf_sib_t* sib); - int (*ADR2G )(scf_3ac_code_t* c, scf_function_t* f, scf_register_t* rd, scf_variable_t* vs); - int (*ADRP2G)(scf_3ac_code_t* c, scf_function_t* f, scf_register_t* rd, scf_register_t* rb, int32_t offset); - - int (*ADRSIB2G )(scf_3ac_code_t* c, scf_function_t* f, scf_register_t* rd, scf_sib_t* sib); - int (*cmp_update)(scf_3ac_code_t* c, scf_function_t* f, scf_instruction_t* inst); + scf_instruction_t* (*CVTF2SI )(scf_3ac_code_t* c, scf_register_t* rd, scf_register_t* rs); + scf_instruction_t* (*CVTF2UI )(scf_3ac_code_t* c, scf_register_t* rd, scf_register_t* rs); + scf_instruction_t* (*CVTSI2F )(scf_3ac_code_t* c, scf_register_t* rd, scf_register_t* rs); + scf_instruction_t* (*CVTUI2F )(scf_3ac_code_t* c, scf_register_t* rd, scf_register_t* rs); + + scf_instruction_t* (*FCMP )(scf_3ac_code_t* c, scf_register_t* rs0, scf_register_t* rs1); + scf_instruction_t* (*FADD )(scf_3ac_code_t* c, scf_register_t* rd, scf_register_t* rs0, scf_register_t* rs1); + scf_instruction_t* (*FSUB )(scf_3ac_code_t* c, scf_register_t* rd, scf_register_t* rs0, scf_register_t* rs1); + scf_instruction_t* (*FMUL )(scf_3ac_code_t* c, scf_register_t* rd, scf_register_t* rs0, scf_register_t* rs1); + scf_instruction_t* (*FDIV )(scf_3ac_code_t* c, scf_register_t* rd, scf_register_t* rs0, scf_register_t* rs1); + scf_instruction_t* (*FMOV_G )(scf_3ac_code_t* c, scf_register_t* rd, scf_register_t* rs); + + scf_instruction_t* (*JA )(scf_3ac_code_t* c); + scf_instruction_t* (*JB )(scf_3ac_code_t* c); + scf_instruction_t* (*JZ )(scf_3ac_code_t* c); + scf_instruction_t* (*JNZ )(scf_3ac_code_t* c); + scf_instruction_t* (*JGT )(scf_3ac_code_t* c); + scf_instruction_t* (*JGE )(scf_3ac_code_t* c); + scf_instruction_t* (*JLT )(scf_3ac_code_t* c); + scf_instruction_t* (*JLE )(scf_3ac_code_t* c); + scf_instruction_t* (*JMP )(scf_3ac_code_t* c); + scf_instruction_t* (*JAE )(scf_3ac_code_t* c); + scf_instruction_t* (*JBE )(scf_3ac_code_t* c); + scf_instruction_t* (*RET )(scf_3ac_code_t* c); + + scf_instruction_t* (*SETZ )(scf_3ac_code_t* c, scf_register_t* rd); + scf_instruction_t* (*SETNZ )(scf_3ac_code_t* c, scf_register_t* rd); + scf_instruction_t* (*SETGT )(scf_3ac_code_t* c, scf_register_t* rd); + scf_instruction_t* (*SETGE )(scf_3ac_code_t* c, scf_register_t* rd); + scf_instruction_t* (*SETLT )(scf_3ac_code_t* c, scf_register_t* rd); + scf_instruction_t* (*SETLE )(scf_3ac_code_t* c, scf_register_t* rd); + + int (*I2G )(scf_3ac_code_t* c, scf_register_t* rd, uint64_t imm, int bytes); + int (*M2G )(scf_3ac_code_t* c, scf_function_t* f, scf_register_t* rd, scf_register_t* rb, scf_variable_t* vs); + int (*M2GF )(scf_3ac_code_t* c, scf_function_t* f, scf_register_t* rd, scf_register_t* rb, scf_variable_t* vs); + int (*G2M )(scf_3ac_code_t* c, scf_function_t* f, scf_register_t* rs, scf_register_t* rb, scf_variable_t* vs); + int (*G2P )(scf_3ac_code_t* c, scf_function_t* f, scf_register_t* rs, scf_register_t* rb, int32_t offset, int size); + int (*P2G )(scf_3ac_code_t* c, scf_function_t* f, scf_register_t* rd, scf_register_t* rb, int32_t offset, int size); + int (*ISTR2G )(scf_3ac_code_t* c, scf_function_t* f, scf_register_t* rd, scf_variable_t* vs); + int (*SIB2G )(scf_3ac_code_t* c, scf_function_t* f, scf_register_t* rd, scf_sib_t* sib); + int (*G2SIB )(scf_3ac_code_t* c, scf_function_t* f, scf_register_t* rd, scf_sib_t* sib); + int (*ADR2G )(scf_3ac_code_t* c, scf_function_t* f, scf_register_t* rd, scf_variable_t* vs); + int (*ADRP2G )(scf_3ac_code_t* c, scf_function_t* f, scf_register_t* rd, scf_register_t* rb, int32_t offset); + int (*ADRSIB2G )(scf_3ac_code_t* c, scf_function_t* f, scf_register_t* rd, scf_sib_t* sib); + + int (*cmp_update )(scf_3ac_code_t* c, scf_function_t* f, scf_instruction_t* inst); + int (*set_rel_veneer)(scf_function_t* f); void (*set_jmp_offset)(scf_instruction_t* inst, int32_t bytes); }; diff --git a/parse/Makefile b/parse/Makefile index f6faa4c..1795ff2 100644 --- a/parse/Makefile +++ b/parse/Makefile @@ -37,16 +37,21 @@ CFILES += ../native/risc/scf_risc_opcode.c CFILES += ../native/risc/scf_risc_rcg.c CFILES += ../native/risc/scf_risc_reg.c CFILES += ../native/risc/scf_risc_reg_arm64.c +CFILES += ../native/risc/scf_risc_reg_arm32.c CFILES += ../native/risc/scf_arm64.c +CFILES += ../native/risc/scf_arm32.c CFILES += ../native/risc/scf_naja.c CFILES += ../elf/scf_elf.c CFILES += ../elf/scf_elf_link.c CFILES += ../elf/scf_elf_native.c +CFILES += ../elf/scf_elf_native32.c CFILES += ../elf/scf_elf_x64.c CFILES += ../elf/scf_elf_x64_so.c CFILES += ../elf/scf_elf_arm64.c CFILES += ../elf/scf_elf_arm64_so.c +CFILES += ../elf/scf_elf_arm32.c +CFILES += ../elf/scf_elf_arm32_so.c CFILES += ../elf/scf_elf_naja.c CFILES += ../elf/scf_elf_naja_so.c CFILES += ../elf/scf_dwarf.c diff --git a/parse/main.c b/parse/main.c index b4aedef..0eae6c3 100644 --- a/parse/main.c +++ b/parse/main.c @@ -27,6 +27,17 @@ static char* __arm64_sofiles[] = "../lib/arm64/libc.so.6", }; +static char* __arm32_objs[] = +{ + "../lib/arm32/_start.o", +}; + +static char* __arm32_sofiles[] = +{ + "../lib/arm32//lib/ld-linux-armhf.so.3", + "../lib/arm32/libc.so.6", +}; + void usage(char* path) { fprintf(stderr, "Usage: %s [-c] [-a arch] [-o out] src0 [src1]\n\n", path); @@ -177,6 +188,9 @@ int main(int argc, char* argv[]) if (!strcmp(arch, "arm64") || !strcmp(arch, "naja")) MAIN_ADD_FILES(__arm64_objs, __arm64_sofiles); + + else if (!strcmp(arch, "arm32")) + MAIN_ADD_FILES(__arm32_objs, __arm32_sofiles); else MAIN_ADD_FILES(__objs, __sofiles); diff --git a/parse/scf_parse2.c b/parse/scf_parse2.c index b1db283..98b9d9b 100644 --- a/parse/scf_parse2.c +++ b/parse/scf_parse2.c @@ -1845,6 +1845,15 @@ static int _scf_parse_add_data_relas(scf_parse_t* parse, scf_elf_context_t* elf) s.sh_link = 0; s.sh_info = SCF_SHNDX_DATA; + if (!strcmp(elf->ops->machine, "arm32")) { + + for (i = 0; i < relas->size; i++) { + rela = relas->data[i]; + + rela->r_info = ELF32_R_INFO(ELF64_R_SYM(rela->r_info), ELF64_R_TYPE(rela->r_info)); + } + } + ret = scf_elf_add_rela_section(elf, &s, relas); } error: @@ -1925,9 +1934,10 @@ static int _add_debug_section(scf_elf_context_t* elf, const char* name, const sc static int _add_debug_relas(scf_vector_t* debug_relas, scf_parse_t* parse, scf_elf_context_t* elf, int sh_index, const char* sh_name) { - scf_elf_sym_t* sym; - scf_vector_t* relas; - scf_rela_t* r; + scf_elf_rela_t* rela; + scf_elf_sym_t* sym; + scf_vector_t* relas; + scf_rela_t* r; int ret; int i; @@ -1955,7 +1965,7 @@ static int _add_debug_relas(scf_vector_t* debug_relas, scf_parse_t* parse, scf_e return -EINVAL; } - scf_elf_rela_t* rela = calloc(1, sizeof(scf_elf_rela_t)); + rela = calloc(1, sizeof(scf_elf_rela_t)); if (!rela) return -ENOMEM; @@ -1985,6 +1995,15 @@ static int _add_debug_relas(scf_vector_t* debug_relas, scf_parse_t* parse, scf_e s.sh_link = 0; s.sh_info = sh_index; + if (!strcmp(elf->ops->machine, "arm32")) { + + for (i = 0; i < relas->size; i++) { + rela = relas->data[i]; + + rela->r_info = ELF32_R_INFO(ELF64_R_SYM(rela->r_info), ELF64_R_TYPE(rela->r_info)); + } + } + ret = scf_elf_add_rela_section(elf, &s, relas); #endif @@ -2151,6 +2170,7 @@ static int _scf_parse_add_text_relas(scf_parse_t* parse, scf_elf_context_t* elf, if (relas->size > 0) { scf_elf_section_t s = {0}; + scf_elf_rela_t* r; s.name = ".rela.text"; s.sh_type = SHT_RELA; @@ -2161,6 +2181,15 @@ static int _scf_parse_add_text_relas(scf_parse_t* parse, scf_elf_context_t* elf, s.sh_link = 0; s.sh_info = SCF_SHNDX_TEXT; + if (!strcmp(elf->ops->machine, "arm32")) { + + for (i = 0; i < relas->size; i++) { + r = relas->data[i]; + + r->r_info = ELF32_R_INFO(ELF64_R_SYM(r->r_info), ELF64_R_TYPE(r->r_info)); + } + } + ret = scf_elf_add_rela_section(elf, &s, relas); } error: diff --git a/vm/Makefile b/vm/Makefile index 9d1be3e..cbc0a74 100644 --- a/vm/Makefile +++ b/vm/Makefile @@ -3,10 +3,13 @@ CFILES += ../util/scf_string.c CFILES += ../elf/scf_elf.c CFILES += ../elf/scf_elf_link.c CFILES += ../elf/scf_elf_native.c +CFILES += ../elf/scf_elf_native32.c CFILES += ../elf/scf_elf_x64.c CFILES += ../elf/scf_elf_x64_so.c CFILES += ../elf/scf_elf_arm64.c CFILES += ../elf/scf_elf_arm64_so.c +CFILES += ../elf/scf_elf_arm32.c +CFILES += ../elf/scf_elf_arm32_so.c CFILES += ../elf/scf_elf_naja.c CFILES += ../elf/scf_elf_naja_so.c CFILES += ../elf/scf_dwarf.c -- 2.25.1