src/tcccoff.c

   1 /*
   2  *  COFF file handling for TCC
   3  *
   4  *  Copyright (c) 2003, 2004 TK
   5  *  Copyright (c) 2004 Fabrice Bellard
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  20  */
  21
  22 #include "tcc.h"
  23
  24 #define MAXNSCNS 255 /* MAXIMUM NUMBER OF SECTIONS         */
  25 #define MAX_STR_TABLE 1000000
  26 AOUTHDR o_filehdr; /* OPTIONAL (A.OUT) FILE HEADER       */
  27
  28 SCNHDR section_header[MAXNSCNS];
  29
  30 #define MAX_FUNCS 1000
  31 #define MAX_FUNC_NAME_LENGTH 128
  32
  33 int nFuncs;
  34 char Func[MAX_FUNCS][MAX_FUNC_NAME_LENGTH];
  35 char AssociatedFile[MAX_FUNCS][MAX_FUNC_NAME_LENGTH];
  36 int LineNoFilePtr[MAX_FUNCS];
  37 int EndAddress[MAX_FUNCS];
  38 int LastLineNo[MAX_FUNCS];
  39 int FuncEntries[MAX_FUNCS];
  40
  41 int OutputTheSection(Section* sect);
  42 short int GetCoffFlags(const char* s);
  43 void SortSymbolTable(void);
  44 Section* FindSection(TCCState* s1, const char* sname);
  45
  46 int C67_main_entry_point;
  47
  48 int FindCoffSymbolIndex(const char* func_name);
  49 int nb_syms;
  50
  51 typedef struct {
  52     long tag;
  53     long size;
  54     long fileptr;
  55     long nextsym;
  56     short int dummy;
  57 } AUXFUNC;
  58
  59 typedef struct {
  60     long regmask;
  61     unsigned short lineno;
  62     unsigned short nentries;
  63     int localframe;
  64     int nextentry;
  65     short int dummy;
  66 } AUXBF;
  67
  68 typedef struct {
  69     long dummy;
  70     unsigned short lineno;
  71     unsigned short dummy1;
  72     int dummy2;
  73     int dummy3;
  74     unsigned short dummy4;
  75 } AUXEF;
  76
  77 ST_FUNC int tcc_output_coff(TCCState* s1, FILE* f)
  78 {
  79     Section* tcc_sect;
  80     SCNHDR* coff_sec;
  81     int file_pointer;
  82     char* Coff_str_table, *pCoff_str_table;
  83     int CoffTextSectionNo, coff_nb_syms;
  84     FILHDR file_hdr; /* FILE HEADER STRUCTURE              */
  85     Section* stext, *sdata, *sbss;
  86     int i, NSectionsToOutput = 0;
  87
  88     Coff_str_table = pCoff_str_table = NULL;
  89
  90     stext = FindSection(s1, ".text");
  91     sdata = FindSection(s1, ".data");
  92     sbss = FindSection(s1, ".bss");
  93
  94     nb_syms = symtab_section->data_offset / sizeof(Elf32_Sym);
  95     coff_nb_syms = FindCoffSymbolIndex("XXXXXXXXXX1");
  96
  97     file_hdr.f_magic = COFF_C67_MAGIC;   /* magic number */
  98     file_hdr.f_timdat = 0;               /* time & date stamp */
  99     file_hdr.f_opthdr = sizeof(AOUTHDR); /* sizeof(optional hdr) */
 100     file_hdr.f_flags = 0x1143; /* flags (copied from what code composer does) */
 101     file_hdr.f_TargetID = 0x99; /* for C6x = 0x0099 */
 102
 103     o_filehdr.magic = 0x0108;  /* see magic.h                          */
 104     o_filehdr.vstamp = 0x0190; /* version stamp                        */
 105     o_filehdr.tsize =
 106         stext->data_offset; /* text size in bytes, padded to FW bdry */
 107     o_filehdr.dsize = sdata->data_offset; /* initialized data "  " */
 108     o_filehdr.bsize = sbss->data_offset; /* uninitialized data "   " */
 109     o_filehdr.entrypt = C67_main_entry_point; /* entry pt. */
 110     o_filehdr.text_start = stext->sh_addr; /* base of text used for this file */
 111     o_filehdr.data_start = sdata->sh_addr; /* base of data used for this file */
 112
 113     // create all the section headers
 114
 115     file_pointer = FILHSZ + sizeof(AOUTHDR);
 116
 117     CoffTextSectionNo = -1;
 118
 119     for (i = 1; i < s1->nb_sections; i++) {
 120         coff_sec = &section_header[i];
 121         tcc_sect = s1->sections[i];
 122
 123         if (OutputTheSection(tcc_sect)) {
 124             NSectionsToOutput++;
 125
 126             if (CoffTextSectionNo == -1 && tcc_sect == stext)
 127                 CoffTextSectionNo = NSectionsToOutput; // rem which coff sect
 128                                                        // number the .text sect
 129                                                        // is
 130
 131             strcpy(coff_sec->s_name, tcc_sect->name); /* section name */
 132
 133             coff_sec->s_paddr = tcc_sect->sh_addr;    /* physical address */
 134             coff_sec->s_vaddr = tcc_sect->sh_addr;    /* virtual address */
 135             coff_sec->s_size = tcc_sect->data_offset; /* section size */
 136             coff_sec->s_scnptr = 0;  /* file ptr to raw data for section */
 137             coff_sec->s_relptr = 0;  /* file ptr to relocation */
 138             coff_sec->s_lnnoptr = 0; /* file ptr to line numbers */
 139             coff_sec->s_nreloc = 0;  /* number of relocation entries */
 140             coff_sec->s_flags = GetCoffFlags(coff_sec->s_name); /* flags */
 141             coff_sec->s_reserved = 0; /* reserved byte */
 142             coff_sec->s_page = 0;     /* memory page id */
 143
 144             file_pointer += sizeof(SCNHDR);
 145         }
 146     }
 147
 148     file_hdr.f_nscns = NSectionsToOutput; /* number of sections */
 149
 150     // now loop through and determine file pointer locations
 151     // for the raw data
 152
 153     for (i = 1; i < s1->nb_sections; i++) {
 154         coff_sec = &section_header[i];
 155         tcc_sect = s1->sections[i];
 156
 157         if (OutputTheSection(tcc_sect)) {
 158             // put raw data
 159             coff_sec->s_scnptr =
 160                 file_pointer; /* file ptr to raw data for section */
 161             file_pointer += coff_sec->s_size;
 162         }
 163     }
 164
 165     // now loop through and determine file pointer locations
 166     // for the relocation data
 167
 168     for (i = 1; i < s1->nb_sections; i++) {
 169         coff_sec = &section_header[i];
 170         tcc_sect = s1->sections[i];
 171
 172         if (OutputTheSection(tcc_sect)) {
 173             // put relocations data
 174             if (coff_sec->s_nreloc > 0) {
 175                 coff_sec->s_relptr = file_pointer; /* file ptr to relocation */
 176                 file_pointer += coff_sec->s_nreloc * sizeof(struct reloc);
 177             }
 178         }
 179     }
 180
 181     // now loop through and determine file pointer locations
 182     // for the line number data
 183
 184     for (i = 1; i < s1->nb_sections; i++) {
 185         coff_sec = &section_header[i];
 186         tcc_sect = s1->sections[i];
 187
 188         coff_sec->s_nlnno = 0;
 189         coff_sec->s_lnnoptr = 0;
 190
 191         if (s1->do_debug && tcc_sect == stext) {
 192             // count how many line nos data
 193
 194             // also find association between source file name and function
 195             // so we can sort the symbol table
 196
 197             Stab_Sym* sym, *sym_end;
 198             char func_name[MAX_FUNC_NAME_LENGTH],
 199                 last_func_name[MAX_FUNC_NAME_LENGTH];
 200             unsigned long func_addr, last_pc, pc;
 201             const char* incl_files[INCLUDE_STACK_SIZE];
 202             int incl_index, len, last_line_num;
 203             const char* str, *p;
 204
 205             coff_sec->s_lnnoptr = file_pointer; /* file ptr to linno */
 206
 207             func_name[0] = '\0';
 208             func_addr = 0;
 209             incl_index = 0;
 210             last_func_name[0] = '\0';
 211             last_pc = 0xffffffff;
 212             last_line_num = 1;
 213             sym = (Stab_Sym*)stab_section->data + 1;
 214             sym_end =
 215                 (Stab_Sym*)(stab_section->data + stab_section->data_offset);
 216
 217             nFuncs = 0;
 218             while (sym < sym_end) {
 219                 switch (sym->n_type) {
 220                 /* function start or end */
 221                 case N_FUN:
 222                     if (sym->n_strx == 0) {
 223                         // end of function
 224
 225                         coff_sec->s_nlnno++;
 226                         file_pointer += LINESZ;
 227
 228                         pc = sym->n_value + func_addr;
 229                         func_name[0] = '\0';
 230                         func_addr = 0;
 231                         EndAddress[nFuncs] = pc;
 232                         FuncEntries[nFuncs] =
 233                             (file_pointer - LineNoFilePtr[nFuncs]) / LINESZ - 1;
 234                         LastLineNo[nFuncs++] = last_line_num + 1;
 235                     } else {
 236                         // beginning of function
 237
 238                         LineNoFilePtr[nFuncs] = file_pointer;
 239                         coff_sec->s_nlnno++;
 240                         file_pointer += LINESZ;
 241
 242                         str = (const char*)stabstr_section->data + sym->n_strx;
 243
 244                         p = strchr(str, ':');
 245                         if (!p) {
 246                             pstrcpy(func_name, sizeof(func_name), str);
 247                             pstrcpy(Func[nFuncs], sizeof(func_name), str);
 248                         } else {
 249                             len = p - str;
 250                             if (len > sizeof(func_name) - 1)
 251                                 len = sizeof(func_name) - 1;
 252                             memcpy(func_name, str, len);
 253                             memcpy(Func[nFuncs], str, len);
 254                             func_name[len] = '\0';
 255                         }
 256
 257                         // save the file that it came in so we can sort later
 258                         pstrcpy(AssociatedFile[nFuncs], sizeof(func_name),
 259                                 incl_files[incl_index - 1]);
 260
 261                         func_addr = sym->n_value;
 262                     }
 263                     break;
 264
 265                 /* line number info */
 266                 case N_SLINE:
 267                     pc = sym->n_value + func_addr;
 268
 269                     last_pc = pc;
 270                     last_line_num = sym->n_desc;
 271
 272                     /* XXX: slow! */
 273                     strcpy(last_func_name, func_name);
 274
 275                     coff_sec->s_nlnno++;
 276                     file_pointer += LINESZ;
 277                     break;
 278                 /* include files */
 279                 case N_BINCL:
 280                     str = (const char*)stabstr_section->data + sym->n_strx;
 281                 add_incl:
 282                     if (incl_index < INCLUDE_STACK_SIZE) {
 283                         incl_files[incl_index++] = str;
 284                     }
 285                     break;
 286                 case N_EINCL:
 287                     if (incl_index > 1)
 288                         incl_index--;
 289                     break;
 290                 case N_SO:
 291                     if (sym->n_strx == 0) {
 292                         incl_index = 0; /* end of translation unit */
 293                     } else {
 294                         str = (const char*)stabstr_section->data + sym->n_strx;
 295                         /* do not add path */
 296                         len = strlen(str);
 297                         if (len > 0 && str[len - 1] != '/')
 298                             goto add_incl;
 299                     }
 300                     break;
 301                 }
 302                 sym++;
 303             }
 304         }
 305     }
 306
 307     file_hdr.f_symptr = file_pointer; /* file pointer to symtab */
 308
 309     if (s1->do_debug)
 310         file_hdr.f_nsyms = coff_nb_syms; /* number of symtab entries */
 311     else
 312         file_hdr.f_nsyms = 0;
 313
 314     file_pointer += file_hdr.f_nsyms * SYMNMLEN;
 315
 316     // OK now we are all set to write the file
 317
 318     fwrite(&file_hdr, FILHSZ, 1, f);
 319     fwrite(&o_filehdr, sizeof(o_filehdr), 1, f);
 320
 321     // write section headers
 322     for (i = 1; i < s1->nb_sections; i++) {
 323         coff_sec = &section_header[i];
 324         tcc_sect = s1->sections[i];
 325
 326         if (OutputTheSection(tcc_sect)) {
 327             fwrite(coff_sec, sizeof(SCNHDR), 1, f);
 328         }
 329     }
 330
 331     // write raw data
 332     for (i = 1; i < s1->nb_sections; i++) {
 333         coff_sec = &section_header[i];
 334         tcc_sect = s1->sections[i];
 335
 336         if (OutputTheSection(tcc_sect)) {
 337             fwrite(tcc_sect->data, tcc_sect->data_offset, 1, f);
 338         }
 339     }
 340
 341     // write relocation data
 342     for (i = 1; i < s1->nb_sections; i++) {
 343         coff_sec = &section_header[i];
 344         tcc_sect = s1->sections[i];
 345
 346         if (OutputTheSection(tcc_sect)) {
 347             // put relocations data
 348             if (coff_sec->s_nreloc > 0) {
 349                 fwrite(tcc_sect->reloc,
 350                        coff_sec->s_nreloc * sizeof(struct reloc), 1, f);
 351             }
 352         }
 353     }
 354
 355     // group the symbols in order of filename, func1, func2, etc
 356     // finally global symbols
 357
 358     if (s1->do_debug)
 359         SortSymbolTable();
 360
 361     // write line no data
 362
 363     for (i = 1; i < s1->nb_sections; i++) {
 364         coff_sec = &section_header[i];
 365         tcc_sect = s1->sections[i];
 366
 367         if (s1->do_debug && tcc_sect == stext) {
 368             // count how many line nos data
 369
 370             Stab_Sym* sym, *sym_end;
 371             char func_name[128], last_func_name[128];
 372             unsigned long func_addr, last_pc, pc;
 373             const char* incl_files[INCLUDE_STACK_SIZE];
 374             int incl_index, len, last_line_num;
 375             const char* str, *p;
 376
 377             LINENO CoffLineNo;
 378
 379             func_name[0] = '\0';
 380             func_addr = 0;
 381             incl_index = 0;
 382             last_func_name[0] = '\0';
 383             last_pc = 0;
 384             last_line_num = 1;
 385             sym = (Stab_Sym*)stab_section->data + 1;
 386             sym_end =
 387                 (Stab_Sym*)(stab_section->data + stab_section->data_offset);
 388
 389             while (sym < sym_end) {
 390                 switch (sym->n_type) {
 391                 /* function start or end */
 392                 case N_FUN:
 393                     if (sym->n_strx == 0) {
 394                         // end of function
 395
 396                         CoffLineNo.l_addr.l_paddr = last_pc;
 397                         CoffLineNo.l_lnno = last_line_num + 1;
 398                         fwrite(&CoffLineNo, 6, 1, f);
 399
 400                         pc = sym->n_value + func_addr;
 401                         func_name[0] = '\0';
 402                         func_addr = 0;
 403                     } else {
 404                         // beginning of function
 405
 406                         str = (const char*)stabstr_section->data + sym->n_strx;
 407
 408                         p = strchr(str, ':');
 409                         if (!p) {
 410                             pstrcpy(func_name, sizeof(func_name), str);
 411                         } else {
 412                             len = p - str;
 413                             if (len > sizeof(func_name) - 1)
 414                                 len = sizeof(func_name) - 1;
 415                             memcpy(func_name, str, len);
 416                             func_name[len] = '\0';
 417                         }
 418                         func_addr = sym->n_value;
 419                         last_pc = func_addr;
 420                         last_line_num = -1;
 421
 422                         // output a function begin
 423
 424                         CoffLineNo.l_addr.l_symndx =
 425                             FindCoffSymbolIndex(func_name);
 426                         CoffLineNo.l_lnno = 0;
 427
 428                         fwrite(&CoffLineNo, 6, 1, f);
 429                     }
 430                     break;
 431
 432                 /* line number info */
 433                 case N_SLINE:
 434                     pc = sym->n_value + func_addr;
 435
 436                     /* XXX: slow! */
 437                     strcpy(last_func_name, func_name);
 438
 439                     // output a line reference
 440
 441                     CoffLineNo.l_addr.l_paddr = last_pc;
 442
 443                     if (last_line_num == -1) {
 444                         CoffLineNo.l_lnno = sym->n_desc;
 445                     } else {
 446                         CoffLineNo.l_lnno = last_line_num + 1;
 447                     }
 448
 449                     fwrite(&CoffLineNo, 6, 1, f);
 450
 451                     last_pc = pc;
 452                     last_line_num = sym->n_desc;
 453
 454                     break;
 455
 456                 /* include files */
 457                 case N_BINCL:
 458                     str = (const char*)stabstr_section->data + sym->n_strx;
 459                 add_incl2:
 460                     if (incl_index < INCLUDE_STACK_SIZE) {
 461                         incl_files[incl_index++] = str;
 462                     }
 463                     break;
 464                 case N_EINCL:
 465                     if (incl_index > 1)
 466                         incl_index--;
 467                     break;
 468                 case N_SO:
 469                     if (sym->n_strx == 0) {
 470                         incl_index = 0; /* end of translation unit */
 471                     } else {
 472                         str = (const char*)stabstr_section->data + sym->n_strx;
 473                         /* do not add path */
 474                         len = strlen(str);
 475                         if (len > 0 && str[len - 1] != '/')
 476                             goto add_incl2;
 477                     }
 478                     break;
 479                 }
 480                 sym++;
 481             }
 482         }
 483     }
 484
 485     // write symbol table
 486     if (s1->do_debug) {
 487         int k;
 488         struct syment csym;
 489         AUXFUNC auxfunc;
 490         AUXBF auxbf;
 491         AUXEF auxef;
 492         int i;
 493         Elf32_Sym* p;
 494         const char* name;
 495         int nstr;
 496         int n = 0;
 497
 498         Coff_str_table = (char*)tcc_malloc(MAX_STR_TABLE);
 499         pCoff_str_table = Coff_str_table;
 500         nstr = 0;
 501
 502         p = (Elf32_Sym*)symtab_section->data;
 503
 504         for (i = 0; i < nb_syms; i++) {
 505
 506             name = symtab_section->link->data + p->st_name;
 507
 508             for (k = 0; k < 8; k++)
 509                 csym._n._n_name[k] = 0;
 510
 511             if (strlen(name) <= 8) {
 512                 strcpy(csym._n._n_name, name);
 513             } else {
 514                 if (pCoff_str_table - Coff_str_table + strlen(name) >
 515                     MAX_STR_TABLE - 1)
 516                     tcc_error("String table too large");
 517
 518                 csym._n._n_n._n_zeroes = 0;
 519                 csym._n._n_n._n_offset = pCoff_str_table - Coff_str_table + 4;
 520
 521                 strcpy(pCoff_str_table, name);
 522                 pCoff_str_table += strlen(name) + 1; // skip over null
 523                 nstr++;
 524             }
 525
 526             if (p->st_info == 4) {
 527                 // put a filename symbol
 528                 csym.n_value = 33; // ?????
 529                 csym.n_scnum = N_DEBUG;
 530                 csym.n_type = 0;
 531                 csym.n_sclass = C_FILE;
 532                 csym.n_numaux = 0;
 533                 fwrite(&csym, 18, 1, f);
 534                 n++;
 535
 536             } else if (p->st_info == 0x12) {
 537                 // find the function data
 538
 539                 for (k = 0; k < nFuncs; k++) {
 540                     if (strcmp(name, Func[k]) == 0)
 541                         break;
 542                 }
 543
 544                 if (k >= nFuncs) {
 545                     tcc_error("debug info can't find function: %s", name);
 546                 }
 547                 // put a Function Name
 548
 549                 csym.n_value = p->st_value; // physical address
 550                 csym.n_scnum = CoffTextSectionNo;
 551                 csym.n_type = MKTYPE(T_INT, DT_FCN, 0, 0, 0, 0, 0);
 552                 csym.n_sclass = C_EXT;
 553                 csym.n_numaux = 1;
 554                 fwrite(&csym, 18, 1, f);
 555
 556                 // now put aux info
 557
 558                 auxfunc.tag = 0;
 559                 auxfunc.size = EndAddress[k] - p->st_value;
 560                 auxfunc.fileptr = LineNoFilePtr[k];
 561                 auxfunc.nextsym = n + 6; // tktk
 562                 auxfunc.dummy = 0;
 563                 fwrite(&auxfunc, 18, 1, f);
 564
 565                 // put a .bf
 566
 567                 strcpy(csym._n._n_name, ".bf");
 568                 csym.n_value = p->st_value; // physical address
 569                 csym.n_scnum = CoffTextSectionNo;
 570                 csym.n_type = 0;
 571                 csym.n_sclass = C_FCN;
 572                 csym.n_numaux = 1;
 573                 fwrite(&csym, 18, 1, f);
 574
 575                 // now put aux info
 576
 577                 auxbf.regmask = 0;
 578                 auxbf.lineno = 0;
 579                 auxbf.nentries = FuncEntries[k];
 580                 auxbf.localframe = 0;
 581                 auxbf.nextentry = n + 6;
 582                 auxbf.dummy = 0;
 583                 fwrite(&auxbf, 18, 1, f);
 584
 585                 // put a .ef
 586
 587                 strcpy(csym._n._n_name, ".ef");
 588                 csym.n_value = EndAddress[k]; // physical address
 589                 csym.n_scnum = CoffTextSectionNo;
 590                 csym.n_type = 0;
 591                 csym.n_sclass = C_FCN;
 592                 csym.n_numaux = 1;
 593                 fwrite(&csym, 18, 1, f);
 594
 595                 // now put aux info
 596
 597                 auxef.dummy = 0;
 598                 auxef.lineno = LastLineNo[k];
 599                 auxef.dummy1 = 0;
 600                 auxef.dummy2 = 0;
 601                 auxef.dummy3 = 0;
 602                 auxef.dummy4 = 0;
 603                 fwrite(&auxef, 18, 1, f);
 604
 605                 n += 6;
 606
 607             } else {
 608                 // try an put some type info
 609
 610                 if ((p->st_other & VT_BTYPE) == VT_DOUBLE) {
 611                     csym.n_type = T_DOUBLE; // int
 612                     csym.n_sclass = C_EXT;
 613                 } else if ((p->st_other & VT_BTYPE) == VT_FLOAT) {
 614                     csym.n_type = T_FLOAT;
 615                     csym.n_sclass = C_EXT;
 616                 } else if ((p->st_other & VT_BTYPE) == VT_INT) {
 617                     csym.n_type = T_INT; // int
 618                     csym.n_sclass = C_EXT;
 619                 } else if ((p->st_other & VT_BTYPE) == VT_SHORT) {
 620                     csym.n_type = T_SHORT;
 621                     csym.n_sclass = C_EXT;
 622                 } else if ((p->st_other & VT_BTYPE) == VT_BYTE) {
 623                     csym.n_type = T_CHAR;
 624                     csym.n_sclass = C_EXT;
 625                 } else {
 626                     csym.n_type = T_INT; // just mark as a label
 627                     csym.n_sclass = C_LABEL;
 628                 }
 629
 630                 csym.n_value = p->st_value;
 631                 csym.n_scnum = 2;
 632                 csym.n_numaux = 1;
 633                 fwrite(&csym, 18, 1, f);
 634
 635                 auxfunc.tag = 0;
 636                 auxfunc.size = 0x20;
 637                 auxfunc.fileptr = 0;
 638                 auxfunc.nextsym = 0;
 639                 auxfunc.dummy = 0;
 640                 fwrite(&auxfunc, 18, 1, f);
 641                 n++;
 642                 n++;
 643             }
 644
 645             p++;
 646         }
 647     }
 648
 649     if (s1->do_debug) {
 650         // write string table
 651
 652         // first write the size
 653         i = pCoff_str_table - Coff_str_table;
 654         fwrite(&i, 4, 1, f);
 655
 656         // then write the strings
 657         fwrite(Coff_str_table, i, 1, f);
 658
 659         tcc_free(Coff_str_table);
 660     }
 661
 662     return 0;
 663 }
 664
 665 // group the symbols in order of filename, func1, func2, etc
 666 // finally global symbols
 667
 668 void SortSymbolTable(void)
 669 {
 670     int i, j, k, n = 0;
 671     Elf32_Sym* p, *p2, *NewTable;
 672     char* name, *name2;
 673
 674     NewTable = (Elf32_Sym*)tcc_malloc(nb_syms * sizeof(Elf32_Sym));
 675
 676     p = (Elf32_Sym*)symtab_section->data;
 677
 678     // find a file symbol, copy it over
 679     // then scan the whole symbol list and copy any function
 680     // symbols that match the file association
 681
 682     for (i = 0; i < nb_syms; i++) {
 683         if (p->st_info == 4) {
 684             name = (char*)symtab_section->link->data + p->st_name;
 685
 686             // this is a file symbol, copy it over
 687
 688             NewTable[n++] = *p;
 689
 690             p2 = (Elf32_Sym*)symtab_section->data;
 691
 692             for (j = 0; j < nb_syms; j++) {
 693                 if (p2->st_info == 0x12) {
 694                     // this is a func symbol
 695
 696                     name2 = (char*)symtab_section->link->data + p2->st_name;
 697
 698                     // find the function data index
 699
 700                     for (k = 0; k < nFuncs; k++) {
 701                         if (strcmp(name2, Func[k]) == 0)
 702                             break;
 703                     }
 704
 705                     if (k >= nFuncs) {
 706                         tcc_error("debug (sort) info can't find function: %s",
 707                                   name2);
 708                     }
 709
 710                     if (strcmp(AssociatedFile[k], name) == 0) {
 711                         // yes they match copy it over
 712
 713                         NewTable[n++] = *p2;
 714                     }
 715                 }
 716                 p2++;
 717             }
 718         }
 719         p++;
 720     }
 721
 722     // now all the filename and func symbols should have been copied over
 723     // copy all the rest over (all except file and funcs)
 724
 725     p = (Elf32_Sym*)symtab_section->data;
 726     for (i = 0; i < nb_syms; i++) {
 727         if (p->st_info != 4 && p->st_info != 0x12) {
 728             NewTable[n++] = *p;
 729         }
 730         p++;
 731     }
 732
 733     if (n != nb_syms)
 734         tcc_error("Internal Compiler error, debug info");
 735
 736     // copy it all back
 737
 738     p = (Elf32_Sym*)symtab_section->data;
 739     for (i = 0; i < nb_syms; i++) {
 740         *p++ = NewTable[i];
 741     }
 742
 743     tcc_free(NewTable);
 744 }
 745
 746 int FindCoffSymbolIndex(const char* func_name)
 747 {
 748     int i, n = 0;
 749     Elf32_Sym* p;
 750     char* name;
 751
 752     p = (Elf32_Sym*)symtab_section->data;
 753
 754     for (i = 0; i < nb_syms; i++) {
 755
 756         name = (char*)symtab_section->link->data + p->st_name;
 757
 758         if (p->st_info == 4) {
 759             // put a filename symbol
 760             n++;
 761         } else if (p->st_info == 0x12) {
 762
 763             if (strcmp(func_name, name) == 0)
 764                 return n;
 765
 766             n += 6;
 767
 768             // put a Function Name
 769
 770             // now put aux info
 771
 772             // put a .bf
 773
 774             // now put aux info
 775
 776             // put a .ef
 777
 778             // now put aux info
 779
 780         } else {
 781             n += 2;
 782         }
 783
 784         p++;
 785     }
 786
 787     return n; // total number of symbols
 788 }
 789
 790 int OutputTheSection(Section* sect)
 791 {
 792     const char* s = sect->name;
 793
 794     if (!strcmp(s, ".text"))
 795         return 1;
 796     else if (!strcmp(s, ".data"))
 797         return 1;
 798     else
 799         return 0;
 800 }
 801
 802 short int GetCoffFlags(const char* s)
 803 {
 804     if (!strcmp(s, ".text"))
 805         return STYP_TEXT | STYP_DATA | STYP_ALIGN | 0x400;
 806     else if (!strcmp(s, ".data"))
 807         return STYP_DATA;
 808     else if (!strcmp(s, ".bss"))
 809         return STYP_BSS;
 810     else if (!strcmp(s, ".stack"))
 811         return STYP_BSS | STYP_ALIGN | 0x200;
 812     else if (!strcmp(s, ".cinit"))
 813         return STYP_COPY | STYP_DATA | STYP_ALIGN | 0x200;
 814     else
 815         return 0;
 816 }
 817
 818 Section* FindSection(TCCState* s1, const char* sname)
 819 {
 820     Section* s;
 821     int i;
 822
 823     for (i = 1; i < s1->nb_sections; i++) {
 824         s = s1->sections[i];
 825
 826         if (!strcmp(sname, s->name))
 827             return s;
 828     }
 829
 830     tcc_error("could not find section %s", sname);
 831     return 0;
 832 }
 833
 834 ST_FUNC int tcc_load_coff(TCCState* s1, int fd)
 835 {
 836     // tktk TokenSym *ts;
 837
 838     FILE* f;
 839     unsigned int str_size;
 840     char* Coff_str_table, *name;
 841     int i, k;
 842     struct syment csym;
 843     char name2[9];
 844     FILHDR file_hdr; /* FILE HEADER STRUCTURE              */
 845
 846     f = fdopen(fd, "rb");
 847     if (!f) {
 848         tcc_error("Unable to open .out file for input");
 849     }
 850
 851     if (fread(&file_hdr, FILHSZ, 1, f) != 1)
 852         tcc_error("error reading .out file for input");
 853
 854     if (fread(&o_filehdr, sizeof(o_filehdr), 1, f) != 1)
 855         tcc_error("error reading .out file for input");
 856
 857     // first read the string table
 858
 859     if (fseek(f, file_hdr.f_symptr + file_hdr.f_nsyms * SYMESZ, SEEK_SET))
 860         tcc_error("error reading .out file for input");
 861
 862     if (fread(&str_size, sizeof(int), 1, f) != 1)
 863         tcc_error("error reading .out file for input");
 864
 865     Coff_str_table = (char*)tcc_malloc(str_size);
 866
 867     if (fread(Coff_str_table, str_size - 4, 1, f) != 1)
 868         tcc_error("error reading .out file for input");
 869
 870     // read/process all the symbols
 871
 872     // seek back to symbols
 873
 874     if (fseek(f, file_hdr.f_symptr, SEEK_SET))
 875         tcc_error("error reading .out file for input");
 876
 877     for (i = 0; i < file_hdr.f_nsyms; i++) {
 878         if (fread(&csym, SYMESZ, 1, f) != 1)
 879             tcc_error("error reading .out file for input");
 880
 881         if (csym._n._n_n._n_zeroes == 0) {
 882             name = Coff_str_table + csym._n._n_n._n_offset - 4;
 883         } else {
 884             name = csym._n._n_name;
 885
 886             if (name[7] != 0) {
 887                 for (k = 0; k < 8; k++)
 888                     name2[k] = name[k];
 889
 890                 name2[8] = 0;
 891
 892                 name = name2;
 893             }
 894         }
 895         //              if (strcmp("_DAC_Buffer",name)==0)  // tktk
 896         //                      name[0]=0;
 897
 898         if (((csym.n_type & 0x30) == 0x20 && csym.n_sclass == 0x2) ||
 899             ((csym.n_type & 0x30) == 0x30 && csym.n_sclass == 0x2) ||
 900             (csym.n_type == 0x4 && csym.n_sclass == 0x2) ||
 901             (csym.n_type == 0x8 && csym.n_sclass == 0x2) || // structures
 902             (csym.n_type == 0x18 &&
 903              csym.n_sclass == 0x2) || // pointer to structure
 904             (csym.n_type == 0x7 && csym.n_sclass == 0x2) || // doubles
 905             (csym.n_type == 0x6 && csym.n_sclass == 0x2))   // floats
 906         {
 907             // strip off any leading underscore (except for other main routine)
 908
 909             if (name[0] == '_' && strcmp(name, "_main") != 0)
 910                 name++;
 911
 912             tcc_add_symbol(s1, name, (void*)(uintptr_t)csym.n_value);
 913         }
 914         // skip any aux records
 915
 916         if (csym.n_numaux == 1) {
 917             if (fread(&csym, SYMESZ, 1, f) != 1)
 918                 tcc_error("error reading .out file for input");
 919             i++;
 920         }
 921     }
 922
 923     return 0;
 924 }