0,0 → 1,955 |
/* |
* COFF file handling for TCC |
* |
* Copyright (c) 2003, 2004 TK |
* Copyright (c) 2004 Fabrice Bellard |
* |
* 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 |
*/ |
#include "coff.h" |
|
#define MAXNSCNS 255 /* MAXIMUM NUMBER OF SECTIONS */ |
#define MAX_STR_TABLE 1000000 |
AOUTHDR o_filehdr; /* OPTIONAL (A.OUT) FILE HEADER */ |
|
SCNHDR section_header[MAXNSCNS]; |
|
#define MAX_FUNCS 1000 |
#define MAX_FUNC_NAME_LENGTH 128 |
|
int nFuncs; |
char Func[MAX_FUNCS][MAX_FUNC_NAME_LENGTH]; |
char AssociatedFile[MAX_FUNCS][MAX_FUNC_NAME_LENGTH]; |
int LineNoFilePtr[MAX_FUNCS]; |
int EndAddress[MAX_FUNCS]; |
int LastLineNo[MAX_FUNCS]; |
int FuncEntries[MAX_FUNCS]; |
|
BOOL OutputTheSection(Section * sect); |
short int GetCoffFlags(const char *s); |
void SortSymbolTable(void); |
Section *FindSection(TCCState * s1, const char *sname); |
|
int C67_main_entry_point; |
|
int FindCoffSymbolIndex(const char *func_name); |
int nb_syms; |
|
typedef struct { |
long tag; |
long size; |
long fileptr; |
long nextsym; |
short int dummy; |
} AUXFUNC; |
|
typedef struct { |
long regmask; |
unsigned short lineno; |
unsigned short nentries; |
int localframe; |
int nextentry; |
short int dummy; |
} AUXBF; |
|
typedef struct { |
long dummy; |
unsigned short lineno; |
unsigned short dummy1; |
int dummy2; |
int dummy3; |
unsigned short dummy4; |
} AUXEF; |
|
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; |
|
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 (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 (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 (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 (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 (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) |
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) { |
char s[256]; |
|
sprintf(s, "debug info can't find function: %s", name); |
|
error(s); |
} |
// 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 (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; |
} |
|
|
|
// group the symbols in order of filename, func1, func2, etc |
// finally global symbols |
|
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) { |
char s[256]; |
|
sprintf(s, |
"debug (sort) info can't find function: %s", |
name2); |
|
error(s); |
} |
|
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) |
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); |
} |
|
|
int FindCoffSymbolIndex(const char *func_name) |
{ |
int i, n = 0; |
Elf32_Sym *p; |
char *name; |
|
p = (Elf32_Sym *) symtab_section->data; |
|
for (i = 0; i < nb_syms; i++) { |
|
name = (char *) symtab_section->link->data + p->st_name; |
|
if (p->st_info == 4) { |
// put a filename symbol |
n++; |
} else if (p->st_info == 0x12) { |
|
if (strcmp(func_name, name) == 0) |
return n; |
|
n += 6; |
|
// put a Function Name |
|
// now put aux info |
|
// put a .bf |
|
// now put aux info |
|
// put a .ef |
|
// now put aux info |
|
} else { |
n += 2; |
} |
|
p++; |
} |
|
return n; // total number of symbols |
} |
|
BOOL OutputTheSection(Section * sect) |
{ |
const char *s = sect->name; |
|
if (!strcmp(s, ".text")) |
return true; |
else if (!strcmp(s, ".data")) |
return true; |
else |
return 0; |
} |
|
short int GetCoffFlags(const char *s) |
{ |
if (!strcmp(s, ".text")) |
return STYP_TEXT | STYP_DATA | STYP_ALIGN | 0x400; |
else if (!strcmp(s, ".data")) |
return STYP_DATA; |
else if (!strcmp(s, ".bss")) |
return STYP_BSS; |
else if (!strcmp(s, ".stack")) |
return STYP_BSS | STYP_ALIGN | 0x200; |
else if (!strcmp(s, ".cinit")) |
return STYP_COPY | STYP_DATA | STYP_ALIGN | 0x200; |
else |
return 0; |
} |
|
Section *FindSection(TCCState * s1, const char *sname) |
{ |
Section *s; |
int i; |
|
for (i = 1; i < s1->nb_sections; i++) { |
s = s1->sections[i]; |
|
if (!strcmp(sname, s->name)) |
return s; |
} |
|
error("could not find section %s", sname); |
return 0; |
} |
|
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) { |
error("Unable to open .out file for input"); |
} |
|
if (fread(&file_hdr, FILHSZ, 1, f) != 1) |
error("error reading .out file for input"); |
|
if (fread(&o_filehdr, sizeof(o_filehdr), 1, f) != 1) |
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)) |
error("error reading .out file for input"); |
|
if (fread(&str_size, sizeof(int), 1, f) != 1) |
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) |
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)) |
error("error reading .out file for input"); |
|
for (i = 0; i < file_hdr.f_nsyms; i++) { |
if (fread(&csym, SYMESZ, 1, f) != 1) |
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, csym.n_value); |
} |
// skip any aux records |
|
if (csym.n_numaux == 1) { |
if (fread(&csym, SYMESZ, 1, f) != 1) |
error("error reading .out file for input"); |
i++; |
} |
} |
|
return 0; |
} |