/* * TCCKX.C - KolibriOS/KX file output for the TinyC Compiler * * Copyright (c) 2021 Coldy * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ typedef struct { char magic[4]; long flags; long i_ptr; } kx_header; static kx_header __kx_header = { 'K','X',0, 0, 0x40, 0 }; typedef struct LibraryEntry { uint32_t ImportEntry; uint32_t LibraryName; }; /*union ImportEntry { uint32_t ImportStr; uint32_t ImportPrt; };*/ //static char __kx_import_table_sym[] = "__i_ptr__"; void kx_build_imports(me_info* me) { ElfW(Sym) *sym; int sym_index, sym_end; sym_end = symtab_section->data_offset / sizeof(ElfW(Sym)); CString *str_arr, *len_arr; int nlib = 0; int i; if (me->header.version != 2) return; str_arr = tcc_malloc(sizeof(CString) * me->s1->nb_loaded_dlls); if (str_arr == 0) { return; } len_arr = tcc_malloc(sizeof(CString)* me->s1->nb_loaded_dlls); if (len_arr == 0) { tcc_free(str_arr); return; } for (sym_index = 1; sym_index < sym_end; ++sym_index) { sym = (ElfW(Sym) *)symtab_section->data + sym_index; if (sym->st_shndx == SHN_UNDEF) { const char *name = symtab_section->link->data + sym->st_name; int dynsym_index = find_elf_sym(me->s1->dynsymtab_section, name); if (dynsym_index == 0) { //if (strcmp(name, __kx_import_table_sym) != 0) { tcc_error/*_noabort*/("undefined symbol '%s'", name); //continue; // FIXME: stop compile! //} //continue; } // KOS support 32 bit only Elf32_Sym* dyn_sym = &((ElfW(Sym) *)me->s1->dynsymtab_section->data)[dynsym_index]; DLLReference **dllref = me->s1->loaded_dlls; i = dyn_sym->st_size - 1; // TCC store dll index in dyn_sym->st_size field if (dllref[i]->level != -1) { char* dll_name = dllref[i]->name; char dll_len = strlen(dll_name) + 1; nlib++; cstr_new(&str_arr[i]); cstr_new(&len_arr[i]); cstr_ccat(&len_arr[i], dll_len); cstr_cat(&str_arr[i], dll_name, dll_len); //Mark dll as already used dllref[i]->level = -1; } char name_len = strlen(name) + 1; cstr_ccat(&len_arr[i], name_len); cstr_cat(&str_arr[i], name, name_len); } } /*if (len_arr[0].size == 0) { //tcc_error(""); return; }*/ // Zero terminate of ptr (was BUG#3) i = 0; do { cstr_ccat(&len_arr[i], 0); i++; } while (i < nlib); kx_import_table* imp_sect; imp_sect = tcc_mallocz(sizeof(kx_import_table)); imp_sect->data = tcc_mallocz(1024); // FIXME!!! imp_sect->data_size = 0; //imp_sect->sh_addr = me->header.image_size;// +1; long imp_data = imp_sect->data; //FIXME change to long for gcc compatible? // Strings i = 0; do { memcpy(imp_data, str_arr[i].data, str_arr[i].size); imp_data += str_arr[i].size; imp_sect->data_size += str_arr[i].size; i++; } while (i < nlib); // Align pad (check algorithm!) int align = 4 - (me->header.image_size + imp_sect->data_size) % 4; imp_data += align; imp_sect->data_size += align; /*add_elf_sym( me->s1->dynsymtab_section, me->header.image_size + imp_sect->data_size, 0, ELFW(ST_INFO)(STB_GLOBAL, STT_NOTYPE), 0, SHN_ABS, __kx_import_table_sym);*/ __kx_header.i_ptr = me->header.image_size + imp_sect->data_size; struct LibraryEntry lib; lib.ImportEntry = me->header.image_size + imp_sect->data_size + (nlib * 8) + 4; lib.LibraryName = me->header.image_size + 0; // LibraryEntry memcpy(imp_data, &lib, sizeof(struct LibraryEntry)); if (nlib > 1) { int prev = 0; i = 1; do { lib.ImportEntry += (len_arr[prev].size - 2) * 4 + 4; //TODO: check that +4 is correct lib.LibraryName = me->header.image_size + str_arr[prev].size; imp_data += sizeof(struct LibraryEntry); imp_sect->data_size += sizeof(struct LibraryEntry); memcpy(imp_data, &lib, sizeof(struct LibraryEntry)); prev++; i++; } while (i < nlib); } // End of LibraryEntry imp_data += sizeof(struct LibraryEntry) + 4; imp_sect->data_size += sizeof(struct LibraryEntry) + 4; char name_len; long l, nl; l = me->header.image_size; i = 0; do { char* len_data = len_arr[i].data; name_len = *len_data++; // Skip library name nl = name_len; do { const char *name = (const char *)str_arr[i].data + nl; add_elf_sym( me->s1->dynsymtab_section, me->header.image_size + imp_sect->data_size, 0, ELFW(ST_INFO)(STB_GLOBAL, STT_NOTYPE), 0, SHN_ABS, name); l += name_len; memcpy(imp_data, &l, 4); imp_data += 4; imp_sect->data_size += 4; name_len = */*++*/len_data/*++*/; //(was BUG#3) nl = nl + name_len; } while (/*name_len*/*(++len_data) > 0); imp_data += 4; imp_sect->data_size += 4; l += name_len; i++; } while (i < nlib); me->header.image_size += imp_sect->data_size; me->imp_table = imp_sect; tcc_free(str_arr); tcc_free(len_arr); } void kx_init(me_info* me) { ElfW(Sym) *sym; int sym_index = 1, sym_end = symtab_section->data_offset / sizeof(ElfW(Sym)); // Check that we have at last one import... for (; sym_index < sym_end; ++sym_index) { sym = (ElfW(Sym) *)symtab_section->data + sym_index; if (sym->st_shndx == SHN_UNDEF) break; } if ((sym_index < sym_end) && // ... and user attached at last one *.def (me->s1->nb_loaded_dlls)) me->header.version = 2; //tcc_add_crt(me->s1, "start1.o"); } long kx_get_header_length(me_info* me) { if (me->header.version = 2) return sizeof(kx_header); return 0; } void kx_write_header(me_info* me, FILE* f) { if (me->header.version = 2) fwrite(&__kx_header, 1, sizeof(kx_header), f); } void kx_write_imports(me_info* me, FILE* f) { if (me->imp_table) fwrite(me->imp_table->data, 1, me->imp_table->data_size, f); } void kx_free(me_info* me) { kx_import_table* imp = me->imp_table; if (imp){ tcc_free(imp->data); tcc_free(imp); } }