/* for the -run option: dynamically load symbol from dll */ void *resolve_sym(struct TCCState *s1, const char *symbol, int type) { char buffer[100]; int sym_index, dll_index; void *addr, **m; DLLReference *dllref; sym_index = pe_find_import(s1, symbol); if (0 == sym_index) return NULL; dll_index = ((Elf32_Sym *)s1->dynsymtab_section->data + sym_index)->st_value; dllref = s1->loaded_dlls[dll_index-1]; if ( !dllref->handle ) { dllref->handle = LoadLibrary(dllref->name); } addr = GetProcAddress(dllref->handle, symbol); if (NULL == addr) addr = GetProcAddress(dllref->handle, get_alt_symbol(buffer, symbol)); if (addr && STT_OBJECT == type) { /* need to return a pointer to the address for data objects */ m = (void**)tcc_malloc(sizeof addr), *m = addr, addr = m; #ifdef MEM_DEBUG /* yep, we don't free it */ mem_cur_size -= sizeof (void*); #endif } return addr; }
void *load_data(int fd, unsigned long file_offset, unsigned long size) { void *data; data = tcc_malloc(size); lseek(fd, file_offset, SEEK_SET); read(fd, data, size); return data; }
void cut_code_buffer(CodeBuffer *cb) { int i; int code_buffer_size = ind - cb->ind; int branch_buffer_size = br - cb->br; cb->code = (unsigned char *) tcc_malloc(code_buffer_size); memcpy(cb->code, code + cb->ind, code_buffer_size); cb->branch = (Branch *) tcc_malloc(branch_buffer_size * sizeof(Branch)); memcpy(cb->branch, branch + cb->br, branch_buffer_size * sizeof(Branch)); for (i = 0; i < branch_buffer_size; ++i) { Branch *b = cb->branch + i; b->ind -= cb->ind; if (b->type == CodeJump) b->target -= cb->br; } ind = cb->ind; br = cb->br; cb->ind = code_buffer_size; cb->br = branch_buffer_size; }
/* ------------------------------------------------------------- */ PUB_FN int pe_load_def_file(TCCState *s1, int fd) { DLLReference *dllref; int state = 0, ret = -1; char line[400], dllname[80], *p; FILE *fp = fdopen(dup(fd), "rb"); if (NULL == fp) goto quit; for (;;) { p = get_line(line, sizeof line, fp); if (NULL == p) break; if (0 == *p || ';' == *p) continue; switch (state) { case 0: if (0 != strnicmp(p, "LIBRARY", 7)) goto quit; strcpy(dllname, trimfront(p+7)); ++state; continue; case 1: if (0 != stricmp(p, "EXPORTS")) goto quit; ++state; continue; case 2: dllref = tcc_malloc(sizeof(DLLReference) + strlen(dllname)); strcpy(dllref->name, dllname); dllref->level = 0; dynarray_add((void ***) &s1->loaded_dlls, &s1->nb_loaded_dlls, dllref); ++state; default: add_elf_sym(s1->dynsymtab_section, s1->nb_loaded_dlls, 0, ELF32_ST_INFO(STB_GLOBAL, STT_FUNC), 0, text_section->sh_num, p); continue; } } ret = 0; quit: if (fp) fclose(fp); if (ret) error_noabort("unrecognized export definition file format"); return ret; }
int pe_load_def_file(TCCState *s1, int fd) { DLLReference *dllref; int state = 0, ret = -1, hint; char line[400], dllname[80], *p, *ordinal; FILE *fp = fdopen(dup(fd), "rb"); if (fp == NULL) goto quit; for (;;) { p = get_line(line, sizeof line, fp); if (p == NULL) break; if (*p == 0 || *p == ';') continue; switch (state) { case 0: if (strncasecmp(p, "LIBRARY", 7) != 0) goto quit; strcpy(dllname, trimfront(p + 7)); ++state; continue; case 1: if (strcasecmp(p, "EXPORTS") != 0) goto quit; ++state; continue; case 2: dllref = tcc_malloc(sizeof(DLLReference) + strlen(dllname)); strcpy(dllref->name, dllname); dllref->level = 0; dynarray_add((void ***) &s1->loaded_dlls, &s1->nb_loaded_dlls, dllref); ++state; default: hint = 0; ordinal = strchr(p, '@'); if (ordinal) { *ordinal = 0; trimback(p, ordinal); ordinal++; hint = atoi(ordinal); } add_elf_sym(s1->dynsymtab_section, s1->nb_loaded_dlls, 0, ELF32_ST_INFO(STB_GLOBAL, STT_FUNC), hint, text_section->sh_num, p); continue; } } ret = 0; quit: if (fp) fclose(fp); if (ret) error_noabort("unrecognized export definition file format"); return ret; }
static int pe_assign_addresses(struct pe_info *pe) { int i, k, o, c; DWORD addr; int *section_order; struct section_info *si; struct section_info *merged_text; struct section_info *merged_data; Section *s; // pe->thunk = new_section(pe->s1, ".iedat", SHT_PROGBITS, SHF_ALLOC); section_order = tcc_malloc(pe->s1->nb_sections * sizeof (int)); for (o = k = 0 ; k < sec_last; ++k) { for (i = 1; i < pe->s1->nb_sections; ++i) { s = pe->s1->sections[i]; if (k == pe_section_class(s)) { s->sh_addr = pe->imagebase; section_order[o++] = i; } } } pe->sec_info = tcc_mallocz(o * sizeof (struct section_info)); addr = pe->imagebase + 1; merged_text = NULL; merged_data = NULL; for (i = 0; i < o; ++i) { k = section_order[i]; s = pe->s1->sections[k]; c = pe_section_class(s); si = &pe->sec_info[pe->sec_count]; #ifdef PE_MERGE_DATA if (c == sec_data && merged_data == NULL) { merged_data = si; } if (c == sec_bss && merged_data != NULL) { // Append .bss to .data s->sh_addr = addr = ((addr - 1) | 15) + 1; addr += s->data_offset; merged_data->sh_size = addr - merged_data->sh_addr; merged_data->last->next = s; merged_data->last = s; continue; } #endif if (c == sec_text) { if (s->unused) continue; if (merged_text) { merged_text->sh_size = align(merged_text->sh_size, s->sh_addralign); s->sh_addr = merged_text->sh_addr + merged_text->sh_size; merged_text->sh_size += s->data_offset; addr = merged_text->sh_addr + merged_text->sh_size; merged_text->last->next = s; merged_text->last = s; continue; } else { merged_text = si; } } strcpy(si->name, c == sec_text ? ".text" : s->name); si->cls = c; si->ord = k; si->sh_addr = s->sh_addr = addr = pe_virtual_align(addr); si->sh_flags = s->sh_flags; si->first = si->last = s; if (c == sec_data && pe->thunk == NULL) { pe->thunk = s; } if (s == pe->thunk) { pe_build_imports(pe); pe_build_exports(pe); } if (c == sec_reloc) { pe_build_reloc(pe); } if (s->data_offset) { si->sh_size = s->data_offset; addr += s->data_offset; pe->sec_count++; } } tcc_free(section_order); return 0; }
static int pe_write(struct pe_info *pe) { int i; int fd; FILE *op; FILE *stubfile; char *stub; int stub_size; DWORD file_offset, r; Section *s; if (pe->stub) { stubfile = fopen(pe->stub, "rb"); if (stubfile == NULL) { error_noabort("could not read '%s': %s", pe->stub, strerror(errno)); return 1; } fseek(stubfile, 0, SEEK_END); stub_size = ftell(stubfile); fseek(stubfile, 0, SEEK_SET); if (stub_size < sizeof(IMAGE_DOS_HEADER)) { error_noabort("invalid stub (%d bytes): %s", stub_size, pe->stub); return 1; } stub = tcc_malloc(stub_size); if (fread(stub, 1, stub_size, stubfile) != stub_size) { error_noabort("error reading stub '%s': %s", pe->stub, strerror(errno)); return 1; } fclose(stubfile); } else { stub_size = DOSSTUB_SIZE + sizeof(IMAGE_DOS_HEADER); stub = tcc_malloc(stub_size); memcpy(stub, &pe_doshdr, sizeof(IMAGE_DOS_HEADER)); memcpy(stub + sizeof(IMAGE_DOS_HEADER), pe_dosstub, DOSSTUB_SIZE); } ((PIMAGE_DOS_HEADER) stub)->e_lfanew = stub_size; fd = open(pe->filename, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, 0777); if (fd < 0) { error_noabort("could not write '%s': %s", pe->filename, strerror(errno)); return 1; } op = fdopen(fd, "wb"); pe->sizeofheaders = pe_file_align(pe, stub_size + sizeof(DWORD) + sizeof(IMAGE_FILE_HEADER) + sizeof(IMAGE_OPTIONAL_HEADER) + pe->sec_count * sizeof (IMAGE_SECTION_HEADER)); file_offset = pe->sizeofheaders; pe_fpad(op, file_offset, 0); if (verbose == 2) { printf("------------------------------------\n virt file size ord section" "\n"); } for (i = 0; i < pe->sec_count; ++i) { struct section_info *si = pe->sec_info + i; const char *sh_name = si->name; unsigned long addr = si->sh_addr - pe->imagebase; unsigned long size = si->sh_size; IMAGE_SECTION_HEADER *psh = &si->ish; if (verbose == 2) { printf("%6lx %6lx %6lx %4d %s\n", addr, file_offset, size, si->ord, sh_name); } switch (si->cls) { case sec_text: pe_opthdr.BaseOfCode = addr; pe_opthdr.SizeOfCode += size; pe_opthdr.AddressOfEntryPoint = ((Elf32_Sym *) symtab_section->data)[pe->start_sym_index].st_value - pe->imagebase; break; case sec_data: pe_opthdr.BaseOfData = addr; pe_opthdr.SizeOfInitializedData += size; break; case sec_bss: pe_opthdr.SizeOfUninitializedData += size; break; case sec_reloc: pe_set_datadir(IMAGE_DIRECTORY_ENTRY_BASERELOC, addr, size); break; case sec_rsrc: pe_set_datadir(IMAGE_DIRECTORY_ENTRY_RESOURCE, addr, size); break; case sec_stab: break; } if (pe->thunk == pe->s1->sections[si->ord]) { if (pe->imp_size) { pe_set_datadir(IMAGE_DIRECTORY_ENTRY_IMPORT, pe->imp_offs + addr, pe->imp_size); pe_set_datadir(IMAGE_DIRECTORY_ENTRY_IAT, pe->iat_offs + addr, pe->iat_size); } if (pe->exp_size) { pe_set_datadir(IMAGE_DIRECTORY_ENTRY_EXPORT, pe->exp_offs + addr, pe->exp_size); } } strcpy((char *) psh->Name, sh_name); psh->Characteristics = pe_sec_flags[si->cls]; psh->VirtualAddress = addr; psh->Misc.VirtualSize = size; pe_opthdr.SizeOfImage = umax(pe_virtual_align(size + addr), pe_opthdr.SizeOfImage); if (si->sh_size) { psh->PointerToRawData = r = file_offset; for (s = si->first; s; s = s->next) { if (s->sh_type != SHT_NOBITS) { file_offset = align(file_offset, s->sh_addralign); pe_fpad(op, file_offset, si->cls == sec_text ? 0x90 : 0x00); fwrite(s->data, 1, s->data_offset, op); file_offset += s->data_offset; } } file_offset = pe_file_align(pe, file_offset); psh->SizeOfRawData = file_offset - r; pe_fpad(op, file_offset, 0); } } pe_filehdr.TimeDateStamp = time(NULL); pe_filehdr.NumberOfSections = pe->sec_count; pe_filehdr.Characteristics = do_debug ? 0x0102 : 0x030E; pe_opthdr.SizeOfHeaders = pe->sizeofheaders; pe_opthdr.ImageBase = pe->imagebase; pe_opthdr.FileAlignment = pe->filealign; if (pe->type == PE_DLL) { pe_filehdr.Characteristics = do_debug ? 0x2102 : 0x230E; } else if (pe->type != PE_GUI) { pe_opthdr.Subsystem = 3; } if (!pe->reloc) pe_filehdr.Characteristics |= 1; if (pe->s1->noshare) pe_filehdr.Characteristics |= 0x4000; fseek(op, 0, SEEK_SET); fwrite(stub, 1, stub_size, op); fwrite(&pe_ntsig, 1, sizeof pe_ntsig, op); fwrite(&pe_filehdr, 1, sizeof pe_filehdr, op); fwrite(&pe_opthdr, 1, sizeof pe_opthdr, op); for (i = 0; i < pe->sec_count; ++i) { fwrite(&pe->sec_info[i].ish, 1, sizeof(IMAGE_SECTION_HEADER), op); } fclose(op); if (verbose == 2) { printf("------------------------------------\n"); } if (verbose) { printf("<- %s (%lu bytes)\n", pe->filename, file_offset); } tcc_free(stub); return 0; }
ST_FUNC int tcc_load_coff(TCCState * s1, int fd) { // tktk TokenSym *ts; FILE *f; unsigned int str_size; char *Coff_str_table, *name; int i, k; struct syment csym; char name2[9]; FILHDR file_hdr; /* FILE HEADER STRUCTURE */ f = fdopen(fd, "rb"); if (!f) { tcc_error("Unable to open .out file for input"); } if (fread(&file_hdr, FILHSZ, 1, f) != 1) tcc_error("error reading .out file for input"); if (fread(&o_filehdr, sizeof(o_filehdr), 1, f) != 1) tcc_error("error reading .out file for input"); // first read the string table if (fseek(f, file_hdr.f_symptr + file_hdr.f_nsyms * SYMESZ, SEEK_SET)) tcc_error("error reading .out file for input"); if (fread(&str_size, sizeof(int), 1, f) != 1) tcc_error("error reading .out file for input"); Coff_str_table = (char *) tcc_malloc(str_size); if (fread(Coff_str_table, str_size - 4, 1, f) != 1) tcc_error("error reading .out file for input"); // read/process all the symbols // seek back to symbols if (fseek(f, file_hdr.f_symptr, SEEK_SET)) tcc_error("error reading .out file for input"); for (i = 0; i < file_hdr.f_nsyms; i++) { if (fread(&csym, SYMESZ, 1, f) != 1) tcc_error("error reading .out file for input"); if (csym._n._n_n._n_zeroes == 0) { name = Coff_str_table + csym._n._n_n._n_offset - 4; } else { name = csym._n._n_name; if (name[7] != 0) { for (k = 0; k < 8; k++) name2[k] = name[k]; name2[8] = 0; name = name2; } } // if (strcmp("_DAC_Buffer",name)==0) // tktk // name[0]=0; if (((csym.n_type & 0x30) == 0x20 && csym.n_sclass == 0x2) || ((csym.n_type & 0x30) == 0x30 && csym.n_sclass == 0x2) || (csym.n_type == 0x4 && csym.n_sclass == 0x2) || (csym.n_type == 0x8 && csym.n_sclass == 0x2) || // structures (csym.n_type == 0x18 && csym.n_sclass == 0x2) || // pointer to structure (csym.n_type == 0x7 && csym.n_sclass == 0x2) || // doubles (csym.n_type == 0x6 && csym.n_sclass == 0x2)) // floats { // strip off any leading underscore (except for other main routine) if (name[0] == '_' && strcmp(name, "_main") != 0) name++; tcc_add_symbol(s1, name, (void*)(uplong)csym.n_value); } // skip any aux records if (csym.n_numaux == 1) { if (fread(&csym, SYMESZ, 1, f) != 1) tcc_error("error reading .out file for input"); i++; } } return 0; }
ST_FUNC int tcc_output_coff(TCCState *s1, FILE *f) { Section *tcc_sect; SCNHDR *coff_sec; int file_pointer; char *Coff_str_table, *pCoff_str_table; int CoffTextSectionNo, coff_nb_syms; FILHDR file_hdr; /* FILE HEADER STRUCTURE */ Section *stext, *sdata, *sbss; int i, NSectionsToOutput = 0; Coff_str_table = pCoff_str_table = NULL; stext = FindSection(s1, ".text"); sdata = FindSection(s1, ".data"); sbss = FindSection(s1, ".bss"); nb_syms = symtab_section->data_offset / sizeof(Elf32_Sym); coff_nb_syms = FindCoffSymbolIndex("XXXXXXXXXX1"); file_hdr.f_magic = COFF_C67_MAGIC; /* magic number */ file_hdr.f_timdat = 0; /* time & date stamp */ file_hdr.f_opthdr = sizeof(AOUTHDR); /* sizeof(optional hdr) */ file_hdr.f_flags = 0x1143; /* flags (copied from what code composer does) */ file_hdr.f_TargetID = 0x99; /* for C6x = 0x0099 */ o_filehdr.magic = 0x0108; /* see magic.h */ o_filehdr.vstamp = 0x0190; /* version stamp */ o_filehdr.tsize = stext->data_offset; /* text size in bytes, padded to FW bdry */ o_filehdr.dsize = sdata->data_offset; /* initialized data " " */ o_filehdr.bsize = sbss->data_offset; /* uninitialized data " " */ o_filehdr.entrypt = C67_main_entry_point; /* entry pt. */ o_filehdr.text_start = stext->sh_addr; /* base of text used for this file */ o_filehdr.data_start = sdata->sh_addr; /* base of data used for this file */ // create all the section headers file_pointer = FILHSZ + sizeof(AOUTHDR); CoffTextSectionNo = -1; for (i = 1; i < s1->nb_sections; i++) { coff_sec = §ion_header[i]; tcc_sect = s1->sections[i]; if (OutputTheSection(tcc_sect)) { NSectionsToOutput++; if (CoffTextSectionNo == -1 && tcc_sect == stext) CoffTextSectionNo = NSectionsToOutput; // rem which coff sect number the .text sect is strcpy(coff_sec->s_name, tcc_sect->name); /* section name */ coff_sec->s_paddr = tcc_sect->sh_addr; /* physical address */ coff_sec->s_vaddr = tcc_sect->sh_addr; /* virtual address */ coff_sec->s_size = tcc_sect->data_offset; /* section size */ coff_sec->s_scnptr = 0; /* file ptr to raw data for section */ coff_sec->s_relptr = 0; /* file ptr to relocation */ coff_sec->s_lnnoptr = 0; /* file ptr to line numbers */ coff_sec->s_nreloc = 0; /* number of relocation entries */ coff_sec->s_flags = GetCoffFlags(coff_sec->s_name); /* flags */ coff_sec->s_reserved = 0; /* reserved byte */ coff_sec->s_page = 0; /* memory page id */ file_pointer += sizeof(SCNHDR); } } file_hdr.f_nscns = NSectionsToOutput; /* number of sections */ // now loop through and determine file pointer locations // for the raw data for (i = 1; i < s1->nb_sections; i++) { coff_sec = §ion_header[i]; tcc_sect = s1->sections[i]; if (OutputTheSection(tcc_sect)) { // put raw data coff_sec->s_scnptr = file_pointer; /* file ptr to raw data for section */ file_pointer += coff_sec->s_size; } } // now loop through and determine file pointer locations // for the relocation data for (i = 1; i < s1->nb_sections; i++) { coff_sec = §ion_header[i]; tcc_sect = s1->sections[i]; if (OutputTheSection(tcc_sect)) { // put relocations data if (coff_sec->s_nreloc > 0) { coff_sec->s_relptr = file_pointer; /* file ptr to relocation */ file_pointer += coff_sec->s_nreloc * sizeof(struct reloc); } } } // now loop through and determine file pointer locations // for the line number data for (i = 1; i < s1->nb_sections; i++) { coff_sec = §ion_header[i]; tcc_sect = s1->sections[i]; coff_sec->s_nlnno = 0; coff_sec->s_lnnoptr = 0; if (s1->do_debug && tcc_sect == stext) { // count how many line nos data // also find association between source file name and function // so we can sort the symbol table Stab_Sym *sym, *sym_end; char func_name[MAX_FUNC_NAME_LENGTH], last_func_name[MAX_FUNC_NAME_LENGTH]; unsigned long func_addr, last_pc, pc; const char *incl_files[INCLUDE_STACK_SIZE]; int incl_index, len, last_line_num; const char *str, *p; coff_sec->s_lnnoptr = file_pointer; /* file ptr to linno */ func_name[0] = '\0'; func_addr = 0; incl_index = 0; last_func_name[0] = '\0'; last_pc = 0xffffffff; last_line_num = 1; sym = (Stab_Sym *) stab_section->data + 1; sym_end = (Stab_Sym *) (stab_section->data + stab_section->data_offset); nFuncs = 0; while (sym < sym_end) { switch (sym->n_type) { /* function start or end */ case N_FUN: if (sym->n_strx == 0) { // end of function coff_sec->s_nlnno++; file_pointer += LINESZ; pc = sym->n_value + func_addr; func_name[0] = '\0'; func_addr = 0; EndAddress[nFuncs] = pc; FuncEntries[nFuncs] = (file_pointer - LineNoFilePtr[nFuncs]) / LINESZ - 1; LastLineNo[nFuncs++] = last_line_num + 1; } else { // beginning of function LineNoFilePtr[nFuncs] = file_pointer; coff_sec->s_nlnno++; file_pointer += LINESZ; str = (const char *) stabstr_section->data + sym->n_strx; p = strchr(str, ':'); if (!p) { pstrcpy(func_name, sizeof(func_name), str); pstrcpy(Func[nFuncs], sizeof(func_name), str); } else { len = p - str; if (len > sizeof(func_name) - 1) len = sizeof(func_name) - 1; memcpy(func_name, str, len); memcpy(Func[nFuncs], str, len); func_name[len] = '\0'; } // save the file that it came in so we can sort later pstrcpy(AssociatedFile[nFuncs], sizeof(func_name), incl_files[incl_index - 1]); func_addr = sym->n_value; } break; /* line number info */ case N_SLINE: pc = sym->n_value + func_addr; last_pc = pc; last_line_num = sym->n_desc; /* XXX: slow! */ strcpy(last_func_name, func_name); coff_sec->s_nlnno++; file_pointer += LINESZ; break; /* include files */ case N_BINCL: str = (const char *) stabstr_section->data + sym->n_strx; add_incl: if (incl_index < INCLUDE_STACK_SIZE) { incl_files[incl_index++] = str; } break; case N_EINCL: if (incl_index > 1) incl_index--; break; case N_SO: if (sym->n_strx == 0) { incl_index = 0; /* end of translation unit */ } else { str = (const char *) stabstr_section->data + sym->n_strx; /* do not add path */ len = strlen(str); if (len > 0 && str[len - 1] != '/') goto add_incl; } break; } sym++; } } } file_hdr.f_symptr = file_pointer; /* file pointer to symtab */ if (s1->do_debug) file_hdr.f_nsyms = coff_nb_syms; /* number of symtab entries */ else file_hdr.f_nsyms = 0; file_pointer += file_hdr.f_nsyms * SYMNMLEN; // OK now we are all set to write the file fwrite(&file_hdr, FILHSZ, 1, f); fwrite(&o_filehdr, sizeof(o_filehdr), 1, f); // write section headers for (i = 1; i < s1->nb_sections; i++) { coff_sec = §ion_header[i]; tcc_sect = s1->sections[i]; if (OutputTheSection(tcc_sect)) { fwrite(coff_sec, sizeof(SCNHDR), 1, f); } } // write raw data for (i = 1; i < s1->nb_sections; i++) { coff_sec = §ion_header[i]; tcc_sect = s1->sections[i]; if (OutputTheSection(tcc_sect)) { fwrite(tcc_sect->data, tcc_sect->data_offset, 1, f); } } // write relocation data for (i = 1; i < s1->nb_sections; i++) { coff_sec = §ion_header[i]; tcc_sect = s1->sections[i]; if (OutputTheSection(tcc_sect)) { // put relocations data if (coff_sec->s_nreloc > 0) { fwrite(tcc_sect->reloc, coff_sec->s_nreloc * sizeof(struct reloc), 1, f); } } } // group the symbols in order of filename, func1, func2, etc // finally global symbols if (s1->do_debug) SortSymbolTable(); // write line no data for (i = 1; i < s1->nb_sections; i++) { coff_sec = §ion_header[i]; tcc_sect = s1->sections[i]; if (s1->do_debug && tcc_sect == stext) { // count how many line nos data Stab_Sym *sym, *sym_end; char func_name[128], last_func_name[128]; unsigned long func_addr, last_pc, pc; const char *incl_files[INCLUDE_STACK_SIZE]; int incl_index, len, last_line_num; const char *str, *p; LINENO CoffLineNo; func_name[0] = '\0'; func_addr = 0; incl_index = 0; last_func_name[0] = '\0'; last_pc = 0; last_line_num = 1; sym = (Stab_Sym *) stab_section->data + 1; sym_end = (Stab_Sym *) (stab_section->data + stab_section->data_offset); while (sym < sym_end) { switch (sym->n_type) { /* function start or end */ case N_FUN: if (sym->n_strx == 0) { // end of function CoffLineNo.l_addr.l_paddr = last_pc; CoffLineNo.l_lnno = last_line_num + 1; fwrite(&CoffLineNo, 6, 1, f); pc = sym->n_value + func_addr; func_name[0] = '\0'; func_addr = 0; } else { // beginning of function str = (const char *) stabstr_section->data + sym->n_strx; p = strchr(str, ':'); if (!p) { pstrcpy(func_name, sizeof(func_name), str); } else { len = p - str; if (len > sizeof(func_name) - 1) len = sizeof(func_name) - 1; memcpy(func_name, str, len); func_name[len] = '\0'; } func_addr = sym->n_value; last_pc = func_addr; last_line_num = -1; // output a function begin CoffLineNo.l_addr.l_symndx = FindCoffSymbolIndex(func_name); CoffLineNo.l_lnno = 0; fwrite(&CoffLineNo, 6, 1, f); } break; /* line number info */ case N_SLINE: pc = sym->n_value + func_addr; /* XXX: slow! */ strcpy(last_func_name, func_name); // output a line reference CoffLineNo.l_addr.l_paddr = last_pc; if (last_line_num == -1) { CoffLineNo.l_lnno = sym->n_desc; } else { CoffLineNo.l_lnno = last_line_num + 1; } fwrite(&CoffLineNo, 6, 1, f); last_pc = pc; last_line_num = sym->n_desc; break; /* include files */ case N_BINCL: str = (const char *) stabstr_section->data + sym->n_strx; add_incl2: if (incl_index < INCLUDE_STACK_SIZE) { incl_files[incl_index++] = str; } break; case N_EINCL: if (incl_index > 1) incl_index--; break; case N_SO: if (sym->n_strx == 0) { incl_index = 0; /* end of translation unit */ } else { str = (const char *) stabstr_section->data + sym->n_strx; /* do not add path */ len = strlen(str); if (len > 0 && str[len - 1] != '/') goto add_incl2; } break; } sym++; } } } // write symbol table if (s1->do_debug) { int k; struct syment csym; AUXFUNC auxfunc; AUXBF auxbf; AUXEF auxef; int i; Elf32_Sym *p; const char *name; int nstr; int n = 0; Coff_str_table = (char *) tcc_malloc(MAX_STR_TABLE); pCoff_str_table = Coff_str_table; nstr = 0; p = (Elf32_Sym *) symtab_section->data; for (i = 0; i < nb_syms; i++) { name = symtab_section->link->data + p->st_name; for (k = 0; k < 8; k++) csym._n._n_name[k] = 0; if (strlen(name) <= 8) { strcpy(csym._n._n_name, name); } else { if (pCoff_str_table - Coff_str_table + strlen(name) > MAX_STR_TABLE - 1) tcc_error("String table too large"); csym._n._n_n._n_zeroes = 0; csym._n._n_n._n_offset = pCoff_str_table - Coff_str_table + 4; strcpy(pCoff_str_table, name); pCoff_str_table += strlen(name) + 1; // skip over null nstr++; } if (p->st_info == 4) { // put a filename symbol csym.n_value = 33; // ????? csym.n_scnum = N_DEBUG; csym.n_type = 0; csym.n_sclass = C_FILE; csym.n_numaux = 0; fwrite(&csym, 18, 1, f); n++; } else if (p->st_info == 0x12) { // find the function data for (k = 0; k < nFuncs; k++) { if (strcmp(name, Func[k]) == 0) break; } if (k >= nFuncs) { tcc_error("debug info can't find function: %s", name); } // put a Function Name csym.n_value = p->st_value; // physical address csym.n_scnum = CoffTextSectionNo; csym.n_type = MKTYPE(T_INT, DT_FCN, 0, 0, 0, 0, 0); csym.n_sclass = C_EXT; csym.n_numaux = 1; fwrite(&csym, 18, 1, f); // now put aux info auxfunc.tag = 0; auxfunc.size = EndAddress[k] - p->st_value; auxfunc.fileptr = LineNoFilePtr[k]; auxfunc.nextsym = n + 6; // tktk auxfunc.dummy = 0; fwrite(&auxfunc, 18, 1, f); // put a .bf strcpy(csym._n._n_name, ".bf"); csym.n_value = p->st_value; // physical address csym.n_scnum = CoffTextSectionNo; csym.n_type = 0; csym.n_sclass = C_FCN; csym.n_numaux = 1; fwrite(&csym, 18, 1, f); // now put aux info auxbf.regmask = 0; auxbf.lineno = 0; auxbf.nentries = FuncEntries[k]; auxbf.localframe = 0; auxbf.nextentry = n + 6; auxbf.dummy = 0; fwrite(&auxbf, 18, 1, f); // put a .ef strcpy(csym._n._n_name, ".ef"); csym.n_value = EndAddress[k]; // physical address csym.n_scnum = CoffTextSectionNo; csym.n_type = 0; csym.n_sclass = C_FCN; csym.n_numaux = 1; fwrite(&csym, 18, 1, f); // now put aux info auxef.dummy = 0; auxef.lineno = LastLineNo[k]; auxef.dummy1 = 0; auxef.dummy2 = 0; auxef.dummy3 = 0; auxef.dummy4 = 0; fwrite(&auxef, 18, 1, f); n += 6; } else { // try an put some type info if ((p->st_other & VT_BTYPE) == VT_DOUBLE) { csym.n_type = T_DOUBLE; // int csym.n_sclass = C_EXT; } else if ((p->st_other & VT_BTYPE) == VT_FLOAT) { csym.n_type = T_FLOAT; csym.n_sclass = C_EXT; } else if ((p->st_other & VT_BTYPE) == VT_INT) { csym.n_type = T_INT; // int csym.n_sclass = C_EXT; } else if ((p->st_other & VT_BTYPE) == VT_SHORT) { csym.n_type = T_SHORT; csym.n_sclass = C_EXT; } else if ((p->st_other & VT_BTYPE) == VT_BYTE) { csym.n_type = T_CHAR; csym.n_sclass = C_EXT; } else { csym.n_type = T_INT; // just mark as a label csym.n_sclass = C_LABEL; } csym.n_value = p->st_value; csym.n_scnum = 2; csym.n_numaux = 1; fwrite(&csym, 18, 1, f); auxfunc.tag = 0; auxfunc.size = 0x20; auxfunc.fileptr = 0; auxfunc.nextsym = 0; auxfunc.dummy = 0; fwrite(&auxfunc, 18, 1, f); n++; n++; } p++; } } if (s1->do_debug) { // write string table // first write the size i = pCoff_str_table - Coff_str_table; fwrite(&i, 4, 1, f); // then write the strings fwrite(Coff_str_table, i, 1, f); tcc_free(Coff_str_table); } return 0; }
void SortSymbolTable(void) { int i, j, k, n = 0; Elf32_Sym *p, *p2, *NewTable; char *name, *name2; NewTable = (Elf32_Sym *) tcc_malloc(nb_syms * sizeof(Elf32_Sym)); p = (Elf32_Sym *) symtab_section->data; // find a file symbol, copy it over // then scan the whole symbol list and copy any function // symbols that match the file association for (i = 0; i < nb_syms; i++) { if (p->st_info == 4) { name = (char *) symtab_section->link->data + p->st_name; // this is a file symbol, copy it over NewTable[n++] = *p; p2 = (Elf32_Sym *) symtab_section->data; for (j = 0; j < nb_syms; j++) { if (p2->st_info == 0x12) { // this is a func symbol name2 = (char *) symtab_section->link->data + p2->st_name; // find the function data index for (k = 0; k < nFuncs; k++) { if (strcmp(name2, Func[k]) == 0) break; } if (k >= nFuncs) { tcc_error("debug (sort) info can't find function: %s", name2); } if (strcmp(AssociatedFile[k], name) == 0) { // yes they match copy it over NewTable[n++] = *p2; } } p2++; } } p++; } // now all the filename and func symbols should have been copied over // copy all the rest over (all except file and funcs) p = (Elf32_Sym *) symtab_section->data; for (i = 0; i < nb_syms; i++) { if (p->st_info != 4 && p->st_info != 0x12) { NewTable[n++] = *p; } p++; } if (n != nb_syms) tcc_error("Internal Compiler error, debug info"); // copy it all back p = (Elf32_Sym *) symtab_section->data; for (i = 0; i < nb_syms; i++) { *p++ = NewTable[i]; } tcc_free(NewTable); }
static int tcc_compile_and_run(char* filename) { console_printf("Compiling script %s...\n", filename); void* tcc = NULL; TCCState * script_state = NULL; void* script_buf = NULL; tcc = module_load("ML/MODULES/tcc.mo"); if (!tcc) { console_printf("Could not load TCC compiler.\n"); goto err; } script_state = (void*) module_exec(tcc, "tcc_new", 0); if (!script_state) { console_printf("Could not initialize TCC compiler.\n"); goto err; } module_exec(tcc, "tcc_set_options", 2, script_state, "-nostdlib"); module_exec(tcc, "tcc_set_options", 2, script_state, "-Wall"); module_exec(tcc, "tcc_set_options", 2, script_state, "-IML/scripts"); module_exec(tcc, "tcc_set_output_type", 2, script_state, TCC_OUTPUT_MEMORY); int ret_compile = module_exec(tcc, "tcc_add_file", 2, script_state, filename); if (ret_compile < 0) { console_printf("Compilation error.\n"); goto err; } script_load_symbols(tcc, script_state, "ML/modules/5D3_113.sym"); int size = module_exec(tcc, "tcc_relocate", 2, script_state, NULL); if (size <= 0) { console_printf("Linking error.\n"); goto err; } script_buf = (void*) tcc_malloc(size); if (!script_buf) { console_printf("Malloc error.\n"); goto err; } int ret_link = module_exec(tcc, "tcc_relocate", 2, script_state, script_buf); if (ret_link < 0) { console_printf("Relocate error.\n"); goto err; } void (*script_main)() = (void*) module_exec(tcc, "tcc_get_symbol", 2, script_state, "main"); if (!script_main) { console_printf("Your script should have a main function.\n"); goto err; } script_define_param_variables(tcc, script_state); module_exec(tcc, "tcc_delete", 1, script_state); script_state = NULL; module_unload(tcc); tcc = NULL; console_printf("Running script %s...\n", filename); /* http://repo.or.cz/w/tinycc.git/commit/6ed6a36a51065060bd5e9bb516b85ff796e05f30 */ sync_caches(); script_main(); tcc_free(script_buf); script_buf = NULL; return 0; err: if (script_buf) tcc_free(script_buf); if (script_state) module_exec(tcc, "tcc_delete", 1, script_state); if (tcc) module_unload(tcc); return 1; }
ST_FN int pe_assign_addresses (struct pe_info *pe) { int i, k, o, c; DWORD addr; int *section_order; struct section_info *si; Section *s; // pe->thunk = new_section(pe->s1, ".iedat", SHT_PROGBITS, SHF_ALLOC); section_order = tcc_malloc(pe->s1->nb_sections * sizeof (int)); for (o = k = 0 ; k < sec_last; ++k) { for (i = 1; i < pe->s1->nb_sections; ++i) { s = pe->s1->sections[i]; if (k == pe_section_class(s)) { // printf("%s %d\n", s->name, k); s->sh_addr = pe->imagebase; section_order[o++] = i; } } } pe->sec_info = tcc_mallocz(o * sizeof (struct section_info)); addr = pe->imagebase + 1; for (i = 0; i < o; ++i) { k = section_order[i]; s = pe->s1->sections[k]; c = pe_section_class(s); si = &pe->sec_info[pe->sec_count]; #ifdef PE_MERGE_DATA if (c == sec_bss && pe->sec_count && si[-1].cls == sec_data) { /* append .bss to .data */ s->sh_addr = addr = ((addr-1) | 15) + 1; addr += s->data_offset; si[-1].sh_size = addr - si[-1].sh_addr; continue; } #endif strcpy(si->name, s->name); si->cls = c; si->ord = k; si->sh_addr = s->sh_addr = addr = pe_virtual_align(addr); si->sh_flags = s->sh_flags; if (c == sec_data && NULL == pe->thunk) pe->thunk = s; if (s == pe->thunk) { pe_build_imports(pe); pe_build_exports(pe); } if (c == sec_reloc) pe_build_reloc (pe); if (s->data_offset) { if (s->sh_type != SHT_NOBITS) { si->data = s->data; si->data_size = s->data_offset; } addr += s->data_offset; si->sh_size = s->data_offset; ++pe->sec_count; } // printf("%08x %05x %s\n", si->sh_addr, si->sh_size, si->name); } #if 0 for (i = 1; i < pe->s1->nb_sections; ++i) { Section *s = pe->s1->sections[i]; int type = s->sh_type; int flags = s->sh_flags; printf("section %-16s %-10s %5x %s,%s,%s\n", s->name, type == SHT_PROGBITS ? "progbits" : type == SHT_NOBITS ? "nobits" : type == SHT_SYMTAB ? "symtab" : type == SHT_STRTAB ? "strtab" : type == SHT_REL ? "rel" : "???", s->data_offset, flags & SHF_ALLOC ? "alloc" : "", flags & SHF_WRITE ? "write" : "", flags & SHF_EXECINSTR ? "exec" : "" ); } pe->s1->verbose = 2; #endif tcc_free(section_order); return 0; }
char *tcc_strdup(const char *str) { char *ptr; ptr = tcc_malloc(strlen(str) + 1); strcpy(ptr, str); return ptr; }
void *tcc_mallocz(unsigned long size) { void *ptr; ptr = tcc_malloc(size); memset(ptr, 0, size); return ptr; }