Subversion Repositories thor

// ============================================================================

//        __

//   \\__/ o\    (C) 2014-2017  Robert Finch, Waterloo

//    \  __ /    All rights reserved.

//     \/_//     robfinch<remove>@finitron.ca

//       ||

//

// A64 - Assembler

//  - 64 bit CPU

//

// This source file 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 3 of the License, or     

// (at your option) any later version.                                      

//                                                                          

// This source file 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 General Public License for more details.                             

//                                                                          

// You should have received a copy of the GNU General Public License        

// along with this program.  If not, see <http://www.gnu.org/licenses/>.    

//                                                                          

// ============================================================================

//

#include "stdafx.h"

extern FILE *ofp;

extern int pass;

int numsym = 0;

void ShellSort(void *, int, int, int (*)());   // Does a shellsort - like bsort()

SHashVal HashFnc(void *def);

int icmp (const void *n1, const void *n2);

int ncmp (char *n1, const void *n2);

SHashTbl HashInfo = { HashFnc, icmp, ncmp, 0, sizeof(SYM), NULL };

SHashVal HashFnc(void *d)

{

   SYM *def = (SYM *)d;

   return htSymHash(&HashInfo, nmTable.GetName(def->name));

}

int icmp (const void *m1, const void *m2)

{

    SYM *n1; SYM *n2;

    n1 = (SYM *)m1;

    n2 = (SYM *)m2;

        if (n1->name==NULL) return 1;

        if (n2->name==NULL) return -1;

  return (strcmp(nmTable.GetName(n1->name), nmTable.GetName(n2->name)));

}

int ncmp (char *m1, const void *m2)

{

    SYM *n2;

    n2 = (SYM *)m2;

        if (m1==NULL) return 1;

        if (n2->name==NULL) return -1;

  return (strcmp(m1, nmTable.GetName(n2->name)));

}

void SymbolInit()

{

   HashInfo.size = 65536;

   HashInfo.width = sizeof(SYM);

   if ((HashInfo.table = calloc(HashInfo.size, sizeof(SYM))) == NULL) {

      exit (1);

   }

}

// ----------------------------------------------------------------------------

// ----------------------------------------------------------------------------

char *segname(int seg)

{

     switch(seg) {

     case codeseg: return "code";

     case dataseg: return "data";

     case bssseg: return "bss";

     case tlsseg: return "tls";

     case rodataseg: return "rodata";

     case constseg: return "const";

     default: return "???";

     }

}

// ----------------------------------------------------------------------------

// Do a binary search to find the symbol.

// ----------------------------------------------------------------------------

SYM *find_symbol(char *name)

{

    SYM *p;

    p = (SYM *)htFind2(&HashInfo, name);

    return p;

}

// ----------------------------------------------------------------------------

// ----------------------------------------------------------------------------

SYM *insert_symbol(SYM *sym)

{

    SYM *p;

    if (!(p=(SYM *)htInsert(&HashInfo, sym)))

       printf("failed to insert symbol\r\n");

    if (p)

       p->ord = p-(SYM *)(HashInfo.table);

    return p;

}

// ----------------------------------------------------------------------------

// When the symbol is first setup we force the value to be a large one in

// order to force the assembler to generate a maximum size prefix in case the

// symbol ends up being unresolved.

// ----------------------------------------------------------------------------

SYM *new_symbol(char *name)

{

    SYM *p;

    SYM ts;

    if (p = find_symbol(name)) {

        printf("Symbol already in table.\r\n");

        return p;

    }

    if (numsym > 65525) {

        printf("Too many symbols.\r\n");

        return (SYM *)NULL;

    }

    if (pass > 5) {

        //printf("%s: added\r\n", name);

    }

     ts.name = nmTable.AddName(name);

//     strncpy(syms[numsym].name, name, sizeof(syms[numsym].name)/sizeof(char)-1);

//     syms[numsym].name[199] = '\0';

     ts.value.low = 0x8000000000000000LL | numsym;

         ts.value.high = 0;

     ts.defined = 0;

     ts.segment = segment;

     ts.scope = ' ';

     ts.isExtern = 0;

     p = insert_symbol(&ts);

     numsym++;

     return p;

}

// ----------------------------------------------------------------------------

// ----------------------------------------------------------------------------

void DumpSymbols()

{

    int nn,ii,blnk,count;

    SYM *dp, *pt;

   pt = (SYM *)HashInfo.table;

   // Pack any 'holes' in the table

   for(blnk= ii = count = 0; count < HashInfo.size; count++, ii++) {

      dp = &pt[ii];

      if (dp->name) {

         if (blnk > 0)

            memmove(&pt[ii-blnk], &pt[ii], (HashInfo.size - count) * sizeof(SYM));

         ii -= blnk;

         blnk = 0;

      }

      else

         blnk++;

   }

   // Sort the table

   qsort(pt, ii, sizeof(SYM), icmp);

    fprintf(ofp, "%d symbols\n", numsym);

    fprintf(ofp, "  Symbol Name                              seg     address bits\n");

    for (nn = 0; nn < ii; nn++) {

//        qq = symorder[nn];

        dp = &pt[nn];

        if (dp->name)

        fprintf(ofp, "%c %-40s %6s  %06llx %d\n", dp->phaserr, nmTable.GetName(dp->name), segname(dp->segment), dp->value.low, dp->bits);

    }

}