Subversion Repositories Kolibri OS

/***********************************************************************

 *

 *  avra - Assembler for the Atmel AVR microcontroller series

 *

 *  Copyright (C) 1998-2004 Jon Anders Haugum, Tobias Weber

 *

 * coff.c - Common Object File Format (COFF) support

 *

 *	This file was developed for the avra assembler in order to produce COFF output files

 *  for use with the Atmel AVR Studio.  The Lean C Compiler (LCC) debugging stabs

 *	output was used as input to the assembler.  The information used to develop this file

 *  was obtained from various sources on the Internet, most notably, the Free Software Foundation,

 *  The "stabs" debug format, ??? Chapter 7: Common Object File Format (COFF),

 *

 *	This software has absolutely no warrantee!  The money you paid for this will be

 *  promptly refunded if not fully satisfied.

 *

 *	Beta release 1/20/2000 by Bob Harris

 *

 *	This software has not been fully tested and probably has a few software deficiencies.

 *  Some software support may be possible by sending a problem description report to

 *  rth@mclean.sparta.com

 *

 *  Made the recommended change in write_coff_program().

 *  Fixed an obvious typo in SkipPastDigits().  The if() statement was terminated

 *  with a semicolon, which terminated the if(); early.  JEG 4-01-03

 */

#include 

#include 

#include 

#include 

#include 

#include "misc.h"

#include "avra.h"

#include "args.h"

#include "coff.h"

#include "device.h"	/* device flash and eeprom size */

struct FundamentalType {

    char const *pString;

    int Type;

    int Size;

};

struct FundamentalType FundamentalTypes[] = {

    {"null", T_NULL, 0},

    {"void", T_VOID, 0},

    {"char", T_CHAR, 1},

    {"short", T_SHORT, 1},

    {"int", T_INT, 1},

    {"long", T_LONG, 2},

    {"float", T_FLOAT, 4},

    {"double", T_DOUBLE, 4},

    {"struct", T_STRUCT, 0},

    {"union", T_UNION, 0},

    {"enum",  T_ENUM, 0},

    {"moe", T_MOE, 0},

    {"unsigned char", T_UCHAR, 1},

    {"unsigned short", T_USHORT, 1},

    {"unsigned int", T_UINT, 1},

    {"unsigned long", T_ULONG, 2},

    {"long double", T_LNGDBL, 2},

    {"long long int", T_LONG, 2},

    {"long int", T_LONG, 2},

    {"unsigned long long", T_ULONG, 2},

    {"signed char", T_CHAR, 1},

    {0, 0}

};

struct coff_info *ci;

/****************************************************************************************/

FILE *open_coff_file(struct prog_info *pi, char *filename){

    int ok /*, i*/;

    FILE *fp;

    //unsigned long *pu4;

    char*p;

    ci = calloc( 1, sizeof(struct coff_info) );

    if ( !ci )

        return( 0 );

    ok = True;

    /* default values */

    ci->CurrentFileNumber = 0;

    ci->pRomMemory = 0;

    ci->pEEPRomMemory = 0;

    ci->MaxRomAddress = 0;

    ci->MaxEepromAddress = 0;

    ci->NeedLineNumberFixup = 0;

    ci->GlobalStartAddress = -1;

    ci->GlobalEndAddress = 0;

    /* Linked lists start out at zero */

    InitializeList( &ci->ListOfSectionHeaders );

    InitializeList( &ci->ListOfRawData );

    InitializeList( &ci->ListOfRelocations );

    InitializeList( &ci->ListOfLineNumbers );

    InitializeList( &ci->ListOfSymbols );

    InitializeList( &ci->ListOfGlobals );

    InitializeList( &ci->ListOfSpecials );

    InitializeList( &ci->ListOfUndefined );

    InitializeList( &ci->ListOfStrings );

    InitializeList( &ci->ListOfTypes );

    InitializeList( &ci->ListOfSplitLines );

    /* add two default sections to SectionHeaders */

    if (  !AllocateListObject( &ci->ListOfSectionHeaders, sizeof(struct external_scnhdr) ) ||

          !AllocateListObject( &ci->ListOfSectionHeaders, sizeof(struct external_scnhdr) ) ) {

        fprintf(stderr, "\nOut of memory allocating section headers!");

        return( 0 );

    }

    /* add to string table */

    p = (char *)AllocateListObject( &ci->ListOfStrings,  4 );

    if ( !p ) {

        fprintf(stderr, "\nOut of memory allocating string table space!");

        return( 0 );

    }

    /* Allocate space for binary output into ROM, and EEPROM memory buffers for COFF output */

    /* ASSUMES ci->device is accurate */

    if ( (ci->pRomMemory = AllocateListObject( &ci->ListOfRawData, pi->device->flash_size * 2 ) ) != 0) {

        if ( (ci->pEEPRomMemory = AllocateListObject( &ci->ListOfRawData, pi->device->eeprom_size )) != 0) {

            ok = True; /* only true if both buffers are properly allocated */

            /* now fill them with 0xff's to simulate flash erasure */

            memset( (void *)ci->pRomMemory, 0xff, pi->device->flash_size * 2 );

            memset(    (   void    *)ci->pEEPRomMemory,    0xff,    pi->device->eeprom_size    );

        }

    }

    if ( ok != True )

        return( 0 );

    fp = fopen(filename,"wb");

    if ( fp == NULL ) {

        fprintf(stderr,"Error: cannot write coff file\n");

        return( fp );

    }

    /* simulate void type .stabs void:t15=r1;*/

    stab_add_local_type( "void", "15=r1;0;0;" );

    return( fp );

}

/****************************************************************************************/

void write_coff_file(struct prog_info *pi){

    //FILE *fp;

    //struct label *label;

    char /* File[256],*/*p;

    struct external_scnhdr *pSectionHdr;

    struct syment *pEntry;

    union auxent *pAux;

    unsigned long *plong;

    int NumberOfSymbols, SymbolIndex, LastFileIndex, LastFunctionIndex, LastFunctionAddress;

    LISTNODE *pNode;

    int LinesOffset, SymbolsOffset, StringsOffset, RawOffset;

    struct lineno *pLine;

    /* add two special sections */

    /* one for .text */

    if (  ( pEntry = (struct syment*)AllocateTwoListObjects( &ci->ListOfSpecials, sizeof(struct syment) * 2 ) ) == 0 ) {

        fprintf(stderr, "\nOut of memory allocating special headers for .text!");

        return;

    }

    memset( pEntry->n_name, 0, 8 );

    strcpy( pEntry->n_name, ".text" );

    pEntry->n_value = 0;

    pEntry->n_scnum = 1;

    pEntry->n_type = 0;

    pEntry->n_sclass = C_STAT;

    pEntry->n_numaux = 1;

    pEntry++;

    pAux = (union auxent *)pEntry;

    pAux->x_scn.x_scnlen = ci->MaxRomAddress + 2;

    pAux->x_scn.x_nreloc = 0;

    pAux->x_scn.x_nlinno = ci->ListOfLineNumbers.TotalItems;

    /* one for .bss */

    if (  ( pEntry = (struct syment*)AllocateTwoListObjects( &ci->ListOfSpecials, sizeof(struct syment) * 2 ) ) == 0 ) {

        fprintf(stderr, "\nOut of memory allocating special header for .bss!");

        return;

    }

    memset( pEntry->n_name, 0, 8 );

    strcpy( pEntry->n_name, ".bss" );

    if ( ci->GlobalStartAddress == -1 ) {

        ci->GlobalEndAddress = ci->GlobalStartAddress = 0x60;

    }

    pEntry->n_value = ci->GlobalStartAddress;

    pEntry->n_scnum = 2;

    pEntry->n_type = 0;

    pEntry->n_sclass = C_STAT;

    pEntry->n_numaux = 1;

    pEntry++;

    pAux = (union auxent *)pEntry;

    pAux->x_scn.x_scnlen = 0; /* we don't store any data here */

    pAux->x_scn.x_nreloc = 0;

    pAux->x_scn.x_nlinno = 0;

    /* one more for .data - eeprom ??? */

    /* Calculate common offsets into the file */

    RawOffset = sizeof(struct external_filehdr) + ci->ListOfSectionHeaders.TotalBytes;

    LinesOffset = RawOffset + ci->MaxRomAddress + 2; /* ignore eeprom for now */

    SymbolsOffset = LinesOffset + ci->ListOfLineNumbers.TotalBytes;

    StringsOffset = SymbolsOffset + ci->ListOfSymbols.TotalBytes + ci->ListOfSpecials.TotalBytes + ci->ListOfGlobals.TotalBytes;

    /* Clean up loose ends in string table */

    if ( !(plong  = (unsigned long *)FindFirstListObject(&ci->ListOfStrings))  ) {

        fprintf(stderr,"\nInternal error in string table!");

        return;

    }

    *plong = ci->ListOfStrings.TotalBytes; /* Size of string table */

    /* Clean up loose ends in symbol table */

    /*	symbol table - Filename value - index to next .file or global symbol */

    /* The value of that symbol equals the symbol table entry index of the next .file symbol or .global */

    LastFunctionAddress = ci->MaxRomAddress;

    NumberOfSymbols = ci->ListOfSymbols.TotalItems + ci->ListOfSpecials.TotalItems + ci->ListOfGlobals.TotalItems;

    SymbolIndex = LastFileIndex = NumberOfSymbols;

    LastFunctionIndex = 0; /* set to zero on last function */

    for ( pEntry = (struct syment *)FindLastListObject(&ci->ListOfSymbols);

        pEntry != 0;

        pEntry = (struct syment *)FindNextLastListObject(&ci->ListOfSymbols) ) {

        /* Search for .file entries designated by C_FILE */

        if ( pEntry->n_sclass == C_FILE ) {

            pEntry->n_value = LastFileIndex;

            LastFileIndex = SymbolIndex; /* save current index */

        }

        /* Search for Function entries C_EXT */

        else if (  pEntry->n_sclass == C_EXT ) {

            pEntry++;

            pAux = (union auxent *)pEntry;

            pAux->x_sym.x_misc.x_fsize = LastFunctionAddress - pEntry->n_value; /* function updated size */

            pAux->x_sym.x_fcnary.x_fcn.x_lnnoptr += LinesOffset;

            LastFunctionAddress = pEntry->n_value;

            pAux->x_sym.x_fcnary.x_fcn.x_endndx = LastFunctionIndex; /* point to next function index */

            pAux->x_sym.x_tvndx = 0; /* ??? */

            LastFunctionIndex = SymbolIndex;

        } else if (  (pEntry->n_sclass == C_FCN ) || ( pEntry->n_sclass == C_BLOCK) ) {

            if ( pEntry->n_name[1] == 'b' ) {

                /* .bf and .bb */

                pEntry++;

                pAux = (union auxent *)pEntry;

                pAux->x_sym.x_fcnary.x_fcn.x_endndx = LastFunctionIndex;

            }

        }

        /* else do nothing */

        /* update current symbol index */

        pNode = GetCurrentNode( &ci->ListOfSymbols );

        SymbolIndex -= ( pNode->Size / sizeof(struct syment) );

    }

    // File Header

    ci->FileHeader.f_magic = MAGIC_NUMBER_AVR;

    ci->FileHeader.f_nscns = 2;

//    ci->FileHeader.f_timdat = time( (time_t *)&ci->FileHeader.f_timdat);

    ci->FileHeader.f_timdat = pi->time;

    ci->FileHeader.f_symptr = SymbolsOffset;

    ci->FileHeader.f_nsyms = NumberOfSymbols;

    ci->FileHeader.f_opthdr = 0;

    ci->FileHeader.f_flags = 0xff; /*F_RELFLG;*/ /* No relocation information available */

    /* write it out */

    if ( fwrite(&ci->FileHeader, 1, sizeof(struct external_filehdr), pi->coff_file ) !=  sizeof(struct external_filehdr) ) {

        fprintf(stderr,"\nFile error writing header ...(disk full?)");

        return;

    }

    // Optional Information

    // Section 1 Header

    pSectionHdr = (struct external_scnhdr *)FindFirstListObject(&ci->ListOfSectionHeaders);

    if ( !pSectionHdr ) {

        fprintf(stderr, "\nInternal Coff error - cannot find section header .text!");

        return;

    }

    memset( &pSectionHdr->s_name[0], 0, sizeof(struct external_scnhdr) );

    strcpy( &pSectionHdr->s_name[0], ".text");

    pSectionHdr->s_paddr = 0;

    pSectionHdr->s_vaddr = 0;

    pSectionHdr->s_size = ci->MaxRomAddress + 2; /* remember the last instruction */

    pSectionHdr->s_scnptr = RawOffset;

    pSectionHdr->s_relptr = 0;

    pSectionHdr->s_lnnoptr = LinesOffset;

    pSectionHdr->s_nreloc = 0;

    pSectionHdr->s_nlnno = ci->ListOfLineNumbers.TotalBytes/sizeof(struct lineno);

    pSectionHdr->s_flags = STYP_TEXT;

    /* write it out */

    if ( fwrite(&pSectionHdr->s_name[0], 1, sizeof(struct external_scnhdr), pi->coff_file ) !=  sizeof(struct external_scnhdr) ) {

        fprintf(stderr,"\nFile error writing section header ...(disk full?)");

        return;

    }

    // Section 2 Header

    pSectionHdr = (struct external_scnhdr *)FindNextListObject(&ci->ListOfSectionHeaders);

    if ( !pSectionHdr ) {

        fprintf(stderr, "\nInternal Coff error - cannot find section header .bss!");

        return;

    }

    memset( &pSectionHdr->s_name[0], 0, sizeof(struct external_scnhdr) );

    strcpy( &pSectionHdr->s_name[0], ".bss");

    /* later expansion */

    pSectionHdr->s_paddr = ci->GlobalStartAddress;

    pSectionHdr->s_vaddr = ci->GlobalStartAddress;

    pSectionHdr->s_flags = STYP_DATA; /* seems it should be STYP_BSS */

    /* write it out */

    if ( fwrite(&pSectionHdr->s_name[0], 1, sizeof(struct external_scnhdr), pi->coff_file ) !=  sizeof(struct external_scnhdr) ) {

        fprintf(stderr,"\nFile error writing section header ...(disk full?)");

        return;

    }

    /* Section N Header - .data or eeprom */

    // Raw Data for Section 1

    if ( (p = FindFirstListObject(&ci->ListOfRawData) ) == 0 ) {

        fprintf(stderr,"\nInternal error - unable to find binary data!");

        return;

    }

    /* write it out */

    if ( fwrite( p, 1, ci->MaxRomAddress + 2, pi->coff_file ) != (size_t)(ci->MaxRomAddress + 2) ) {

        fprintf(stderr,"\nFile error writing raw .text data ...(disk full?)");

        return;

    }

    // Raw data for section n

    // Relocation Info for section 1

    // Relocation info for section n

    // Line numbers for section 1

    for ( pLine = (struct lineno *)FindFirstListObject( &ci->ListOfLineNumbers );

        pLine != 0;

        pLine = (struct lineno *)FindNextListObject( &ci->ListOfLineNumbers ) ) {

        pNode = GetCurrentNode( &ci->ListOfLineNumbers );

        /* write it out */

        if ( fwrite( pLine, 1, pNode->Size, pi->coff_file ) != pNode->Size ) {

            fprintf(stderr,"\nFile error writing line numbers ...(disk full?)");

            return;

        }

    }

    // Line numbers for section n

    // Symbol table

    for ( pEntry = (struct syment *)FindFirstListObject( &ci->ListOfSymbols );

        pEntry != 0;

        pEntry = (struct syment *)FindNextListObject( &ci->ListOfSymbols ) ) {

        pNode = GetCurrentNode( &ci->ListOfSymbols );

        /* write it out */

        if ( fwrite( pEntry, 1, pNode->Size, pi->coff_file ) != pNode->Size ) {

            fprintf(stderr,"\nFile error writing symbol table ...(disk full?)");

            return;

        }

    }

    // Symbol table of Globals

    for ( pEntry = (struct syment *)FindFirstListObject( &ci->ListOfGlobals );

        pEntry != 0;

        pEntry = (struct syment *)FindNextListObject( &ci->ListOfGlobals ) ) {

        pNode = GetCurrentNode( &ci->ListOfGlobals );

        /* write it out */

        if ( fwrite( pEntry, 1, pNode->Size, pi->coff_file ) != pNode->Size ) {

            fprintf(stderr,"\nFile error writing global symbols ...(disk full?)");

            return;

        }

    }

    /* Specials .text, .bss, .data */

    for ( pEntry = (struct syment *)FindFirstListObject( &ci->ListOfSpecials );

        pEntry != 0;

        pEntry = (struct syment *)FindNextListObject( &ci->ListOfSpecials ) ) {

        pNode = GetCurrentNode( &ci->ListOfSpecials );

        /* write it out */

        if ( fwrite( pEntry, 1, pNode->Size, pi->coff_file ) != pNode->Size ) {

            fprintf(stderr,"\nFile error writing special symbols ...(disk full?)");

            return;

        }

    }

    // String Table

    for ( p = (char *)FindFirstListObject( &ci->ListOfStrings );

        p != 0;

        p = (char *)FindNextListObject( &ci->ListOfStrings ) ) {

        pNode = GetCurrentNode( &ci->ListOfStrings );

        /* write it out */

        if ( fwrite( p, 1, pNode->Size, pi->coff_file ) != pNode->Size ) {

            fprintf(stderr,"\nFile error writing strings data ...(disk full?)");

            return;

        }

    }

    return;

}

/****************************************************************************************/

void write_coff_eeprom( struct prog_info *pi, int address, unsigned char data){

    if ( !GET_ARG(pi->args, ARG_COFF) )

        return;

    /* Coff output keeps track of binary data in memory buffers */

    if ( ci->pEEPRomMemory ) {

        if ( address <= pi->device->eeprom_size ) {

            *(ci->pEEPRomMemory + address) = data;

            if ( address >= ci->MaxEepromAddress )

                ci->MaxEepromAddress = address;   /* keep high water mark */

        } else {

            pi->error_count++;

            fprintf(stderr, "Error: EEPROM address %d exceeds max range %d", address, pi->device->eeprom_size );

        }

    }

}

/****************************************************************************************/

void write_coff_program( struct prog_info *pi, int address, unsigned int data){

    unsigned char *pByte;

    if ( !GET_ARG(pi->args, ARG_COFF) )

        return;

    /* Coff output keeps track of binary data in memory buffers, address is in bytes not words */

    if ( ci->pRomMemory ) {

/* JEG	if ( address <= pi->device->flash_size ) {  */  /* JEG 4-23-03 */

		if ( address <= pi->device->flash_size*2 ) {

            pByte = (unsigned char *)(ci->pRomMemory + address); /* point to low byte in memory */

            *pByte++ = (data & 0xff);   /* low byte */

            *pByte = ((data >> 8) & 0xff); /* high byte */

            if ( address >= ci->MaxRomAddress )

                ci->MaxRomAddress = address;   /* keep high water mark */

        } else {

            pi->error_count++;

/* JEG		fprintf(stderr, "Error: FLASH address %d exceeds max range %d", address, pi->device->flash_size ); */

			fprintf(stderr, "Error: FLASH address %d exceeds max range %d", address, pi->device->flash_size*2 );

        }

    }

}

/****************************************************************************************/

void close_coff_file(struct prog_info *pi, FILE *fp){

    /* close the output file */

    fclose( fp );

    pi->coff_file = 0;

    /* free all the internal memory buffers used by ci */

    FreeList( &ci->ListOfSectionHeaders );

    FreeList( &ci->ListOfRawData );

    FreeList( &ci->ListOfRelocations );

    FreeList( &ci->ListOfLineNumbers );

    FreeList(    &ci->ListOfSymbols    );

    FreeList( &ci->ListOfGlobals );

    FreeList( &ci->ListOfUndefined );

    FreeList( &ci->ListOfStrings );

    FreeList( &ci->ListOfTypes );

    FreeList( &ci->ListOfSplitLines );

    /* now free ci */

    free( ci );

    ci = 0;

}

/****************************************************************************************/

int parse_stabs( struct prog_info *pi, char *p ){

    int ok = True;

    int TypeCode, n;

    char *pString, *p2, *p3, *p4, *p5, *pType, *pEnd, *pp, *pJoined;

    if ( !GET_ARG(pi->args, ARG_COFF) || ( pi->pass == PASS_1 ) )

        return(True);

    /* stabs debugging information is in the form:

    .stabs "symbolic info string", HexorDecimalTypecode, parm3, parm4, parm5

    parm1, parm2, parm3 depend on typecode

    N_LSYM	0x80		local sym: name,,0,type,offset

    N_OPT	0x3c		compiler options

    N_SO	0x64		source file name: name,,0,0,address

    N_SOL	0x84		#included file name: name,,0,0,address

    N_FUN	0x24		procedure: name,,0,linenumber,address

    N_GSYM	0x20		global symbol: name,,0,type,0

    N_LCSYM	0x28		.lcomm symbol: name,,0,type,address

    N_STSYM	0x26		static symbol: name,,0,type,address

    N_RSYM	0x40		register sym: name,,0,type,register

    N_PSYM	0xa0		parameter: name,,0,type,offset

    */

    /* Look for multiple commands per line */

    /* .stabs "linktag:T19=s46next:20=*19,0,16;last:20,16,16;a:21=ar1;0;2;22=ar1;0;3;1,32,96;\\",128,0,0,0 */

    /* .stabs "b:23=ar1;0;4;24=ar1;0;5;2,128,240;;",128,0,0,0 */

    /* Look for continuation lines per line */

    /* Get String information as a token */

    /* Parse the tokens in the stabn line buffer */

    pString = get_next_token(p, TERM_DOUBLEQUOTE );     /* zap first doublequote */

    p2 = get_next_token(pString, TERM_DOUBLEQUOTE );    /* zap last doublequote */

    p2 = get_next_token(p2, TERM_COMMA );               /* zap comma */

    p3 = get_next_token(p2, TERM_COMMA );

    p4 = get_next_token(p3, TERM_COMMA );

    p5 = get_next_token(p4, TERM_COMMA );

    pEnd = get_next_token(p5, TERM_END ); /* zap CR LF, make ASCIIZ */

    if ( !pString || !p2 || !p3 || !p4 || !p5 )

        return( False );

    /* Check for split lines */

    n = strlen( pString );

    if ( ( pString[n - 1] == '\\' ) && (pString[n - 2] == '\\') ) {

        /* We have a continuation string here */

        pString[n - 2] = 0;

        n -= 2;

        if ( !(pp = (char *)AllocateListObject( &ci->ListOfSplitLines, n + 1 ))  ) {

            fprintf(stderr, "\nOut of memory allocating continuation line!");

            return( False );

        }

        strcpy( pp, pString ); /* loose the continuation characters */

        return(True);

    }

    if ( ci->ListOfSplitLines.TotalItems > 0 ) {

        /* Join lines together and process */

        if ( !(pJoined = calloc( 1, n + ci->ListOfSplitLines.TotalBytes ) ) ) {

            fprintf(stderr, "\nOut of memory joining continuation lines!");

            return( False );

        }

        for ( pp = (char *)FindFirstListObject( &ci->ListOfSplitLines );

            pp != 0;

            pp = (char *)FindNextListObject( &ci->ListOfSplitLines ) ) {

            strcat( pJoined, pp ); /* connect the lines */

        }

        strcat( pJoined, pString );

        FreeList( &ci->ListOfSplitLines );

        if ( !AddListObject( &ci->ListOfSplitLines, pJoined, n + ci->ListOfSplitLines.TotalBytes )  ) {

            fprintf(stderr, "\nUnable to add joined continuation line");

            return( False );

        }

        pString = pJoined;

    }

    if ( *p2 == '0' )

        TypeCode = atox(p2);    /* presume to be hex 0x */

    else

        TypeCode = atoi(p2);

    switch ( TypeCode ) {

    case N_OPT:     /* compiler options */

        break;      /* nothing used here */

    case N_SO:      /* source file name: name,,0,0,address */

        ok = stab_add_filename( pString, p5 );

        break;

    case N_GSYM:    /* global symbol: name,,0,type,0 */

        pType = get_next_token(pString, TERM_COLON );   /* separate at colon */

        ok = stab_add_global( pi, pString, pType );

        break;

    case N_FUN:     /* procedure: name,,0,linenumber,address */

        ok = stab_add_function( pi, pString, p5 );

        break;

    case N_LSYM:    /* local sym: name,,0,type,offset */

        /* pString, p2 = TypeCode, p3 = 0, p4 = 0, p5 = offset */

        pType = get_next_token(pString, TERM_COLON );   /* pType = symbol descriptor (character after the colon) */

        if ( *pType == 't')

            ok = stab_add_local_type( pString, ++pType );

        else if (*pType == 'T')

            ok = stab_add_tag_type( pString, ++pType );

        else

            ok = stab_add_local( pi, pString, pType, p5 );

        break;

    case N_RSYM:    /* Symbol:[P|r]type,0,size,register */

        pType = get_next_token(pString, TERM_COLON );   /* separate at colon */

        ok = stab_add_local_register( pi, pString, pType, p5 );

        break;

    case N_LCSYM:   /* .lcomm symbol: name,,0,type,address */

        ok = True;

        break;  /* ignore constants */

    case N_STSYM:   /* static symbol: name,,0,type,address */

        pType = get_next_token(pString, TERM_COLON );   /* separate at colon */

        ok = stab_add_static_symbol( pi, pString, pType, p5 );

        break;

    case N_PSYM:    /* parameter: name,,0,type,offset */

        pType = get_next_token(pString, TERM_COLON );   /* separate at colon */

        ok = stab_add_parameter_symbol( pi, pString, pType, p5 );

        break;

    case N_SOL:     /* #included file name: name,,0,0,address */

        ok = True;

        break;  /* ignore include files */

    default:

        ok = False;

    }

    if ( ci->ListOfSplitLines.TotalItems > 0 )

        FreeList( &ci->ListOfSplitLines );

    return( ok );

}

/****************************************************************************************/

int parse_stabn( struct prog_info *pi, char *p ){

    int ok = True;

    int TypeCode /* , LineNumber */, Level;

    char *p1, *p2, *p3, *p4, *pLabel, *pFunction, *pEnd;

    /* stabn debugging information is in the form:

    .stabn TypeCode, 0, parm1, parm2

    parm1 is level

    parm2 is Label-Function

    compiler currently produces the following TypeCodes:

    N_LBRAC	0xc0		left bracket: 0,,0,nesting level,address

    N_RBRAC	0xe0		right bracket: 0,,0,nesting level,address

    N_SLINE	0x44		src line: 0,,0,linenumber,address

    */

    if ( !GET_ARG(pi->args, ARG_COFF) || ( pi->pass == PASS_1 ) )

        return(True);

    /* Parse the tokens in the stabn line buffer */

    p1 = get_next_token(p, TERM_SPACE );

    p2 = get_next_token(p1, TERM_COMMA );

    p3 = get_next_token(p2, TERM_COMMA );

    p4 = get_next_token(p3, TERM_COMMA );

    pEnd = get_next_token(p4, TERM_END ); /* zap CR LF, make ASCIIZ */

    if ( !p1 || !p2 || !p3 || !p4 )

        return( False );

    /* first convert TypeCode to binary */

    if ( *p1 == '0' )

        TypeCode = atox(p1);    /* presume to be hex 0x */

    else

        TypeCode = atoi(p1);

    Level = atoi(p3);   /* line number or level */

    pLabel = p4;                /* Assembly label */

    pFunction = get_next_token( pLabel, TERM_DASH ); /* Function */

    switch ( TypeCode ) {

    case N_SLINE:           /* src line: 0,,0,linenumber,address */

        ok = stab_add_lineno( pi, Level, pLabel, pFunction );

        break;

    case N_LBRAC:           /* left bracket: 0,,0,nesting level,address */

        ok = stab_add_lbracket( pi, Level, pLabel, pFunction );

        break;

    case N_RBRAC:           /* right bracket: 0,,0,nesting level,address */

        ok = stab_add_rbracket( pi, Level, pLabel, pFunction );

        break;

    default:

        fprintf(stderr, "\nUnknown .stabn TypeCode = 0x%x", TypeCode );

        ok = False;

    }

    return( ok );

}

/****************************************************************************************/

int stab_add_lineno(  struct prog_info *pi, int LineNumber, char *pLabel, char *pFunction ){

    int Address;

    struct lineno *pln;

    struct syment *pEntry;

    union auxent *pAux;

    /* Allocate LineNumber Table entry and fill it in */

    pln = (struct lineno *)AllocateListObject(&ci->ListOfLineNumbers, sizeof(struct lineno)  );

    if ( !pln ) {

        fprintf(stderr, "\nOut of memory allocating lineno table for function %s", pFunction );

        return( False );

    }

    /* set value field to be address of label in bytes */

    if ( !get_symbol(pi, pLabel, &Address) ) {

        fprintf(stderr, "\nUnable to locate label %s", pLabel );

        return( False );

    }

    pln->l_addr.l_paddr = Address * 2; /* need byte quanities */

    /* Line number is relative to beginning of function, starts at 1 */

    if ( ci->FunctionStartLine == 0 ) {

        /* This line number is that same as the function start */

        ci->FunctionStartLine = LineNumber;

    }

    pln->l_lnno = LineNumber - ci->FunctionStartLine + 1;

    ci->CurrentSourceLine = LineNumber; /* keep track of source line for .eb .ef arrays */

    if ( ci->NeedLineNumberFixup ) {

        /* need to go into symbol table and fix last NeedLineNumberFixup entries */

        for ( pEntry = (struct syment *)FindLastListObject(&ci->ListOfSymbols);

            (pEntry != 0) && ( ci->NeedLineNumberFixup != 0);

            pEntry = (struct syment *)FindNextLastListObject(&ci->ListOfSymbols) ) {

            /* Fix up line number entries */

            if ( (pEntry->n_sclass == C_FCN ) || ( pEntry->n_sclass == C_BLOCK ) || ( pEntry->n_sclass == C_EXT) ) {

                pEntry++;

                pAux = (union auxent *)pEntry;

                pAux->x_sym.x_misc.x_lnsz.x_lnno = LineNumber;

                ci->NeedLineNumberFixup--;

            }

        }

    }

    return(True);

}

/****************************************************************************************/

int stab_add_lbracket( struct prog_info *pi, int Level, char *pLabel, char *pFunction ){

    int Address;

    struct syment *pEntry;

    union auxent *pAux;

    //char *p;

    //struct lineno *pln;

    if ( !get_symbol(pi, pLabel, &Address) ) {

        fprintf(stderr, "\nUnable to locate label %s", pLabel );

        return( False );

    }

    /* Now create a .bb symbol table entry and aux entry too */

    pEntry = (struct syment *)AllocateTwoListObjects( &ci->ListOfSymbols,  sizeof(struct syment) * 2 );

    if ( !pEntry ) {

        fprintf(stderr, "\nOut of memory allocating symbol table entry for .bb %s", pLabel );

        return( False );

    }

    /* n_name */

    memset( pEntry->n_name, 0, 8 );

    strcpy( pEntry->n_name, ".bb" );

    pEntry->n_value = Address * 2;  /* bytes not words */

    pEntry->n_scnum = 1;    /* .text */

    pEntry->n_type = 0;

    pEntry->n_sclass = C_BLOCK;

    pEntry->n_numaux = 1;

    pEntry++;   /* point to aux entry */

    pAux = (union auxent *)pEntry;

    pAux->x_sym.x_misc.x_lnsz.x_lnno = 0;   /* UNKNOWN - post process */

    pAux->x_sym.x_misc.x_lnsz.x_size = 0;   /* UNKNOWN - post process */

    ci->NeedLineNumberFixup++; /* once for .bb block */

    return(True);

}

/****************************************************************************************/

int stab_add_rbracket( struct prog_info *pi, int Level, char *pLabel, char *pFunction ){

    int Address;

    struct syment *pEntry;

    union auxent *pAux;

    //char *p;

    //struct lineno *pln;

    if ( !get_symbol(pi, pLabel, &Address) ) {

        fprintf(stderr, "\nUnable to locate label %s", pLabel );

        return( False );

    }

    /* Now create a .eb symbol table entry */

    pEntry = (struct syment *)AllocateTwoListObjects( &ci->ListOfSymbols,  sizeof(struct syment) * 2 );

    if ( !pEntry ) {

        fprintf(stderr, "\nOut of memory allocating symbol table entry for .eb %s", pLabel );

        return( False );

    }

    /* n_name */

    memset( pEntry->n_name, 0, 8 );

    strcpy( pEntry->n_name, ".eb" );

    pEntry->n_sclass = C_BLOCK;

    pEntry->n_value = Address * 2;  /* bytes not words */

    pEntry->n_scnum = 1;    /* .text */

    pEntry->n_type = 0;

    pEntry->n_numaux = 1;

    pEntry++;   /* point to aux entry */

    pAux = (union auxent *)pEntry;

    pAux->x_sym.x_misc.x_lnsz.x_lnno = ci->CurrentSourceLine;

    /* create an .ef if at level 0 */

    if ( Level == 0 ) {

        /* Now create a .ef symbol table entry */

        pEntry = (struct syment *)AllocateTwoListObjects( &ci->ListOfSymbols,  sizeof(struct syment) * 2 );

        if ( !pEntry ) {

            fprintf(stderr, "\nOut of memory allocating symbol table entry for .ef %s", pLabel );

            return( False );

        }

        /* n_name */

        memset( pEntry->n_name, 0, 8 );

        strcpy( pEntry->n_name, ".ef" );

        pEntry->n_sclass = C_FCN;

        pEntry->n_value = Address * 2;  /* bytes not words */

        pEntry->n_scnum = 1;    /* .text */

        pEntry->n_type = 0;

        pEntry->n_numaux = 1;

        pEntry++;   /* point to aux entry */

        pAux = (union auxent *)pEntry;

        pAux->x_sym.x_misc.x_lnsz.x_lnno = ci->CurrentSourceLine;

    }

    return(True);

}

/****************************************************************************************/

int stab_add_filename( char *pName, char *pLabel ){

    int ok, n;

    struct syment *pEntry;

    union auxent *pAux;

    char *p;

    /* if( pLabel == "Ltext0" ) then beginning of .text, pName = cwd, next pName = file */

    /* if( pLabel == "Letext" ) then end of .text , pName == NULL */

    /* we only need the one not ending in Slash */

    ok = True;

    n = strlen(pName);

    if ( n > 0 ) {

        if ( ( pName[ n - 1] == '\\') || (pName[ n - 1] == '/') )

            return(True); /* ignore */

    } else

        return(True);

    /* allocate entry in symbol table list */

    pEntry = (struct syment *)AllocateTwoListObjects(

                                                    &ci->ListOfSymbols,  sizeof(struct syment) * 2 ); /* aux entry too */

    if ( !pEntry ) {

        fprintf(stderr, "\nOut of memory allocating symbol table entry for global %s", pName );

        return( False );

    }

    /* n_name */

    memset( pEntry->n_name, 0, 8 );

    strcpy( pEntry->n_name, ".file" );

    /* n_value is determined after processing done UNKNOWN - post process */

    /* The value of that symbol equals the symbol table entry index of the next .file symbol or .global */

    /* post process */

    pEntry->n_scnum = N_DEBUG;

    pEntry->n_sclass = C_FILE;

    pEntry->n_numaux = 1;

    pEntry++;   /* point to aux entry */

    pAux = (union auxent *)pEntry;

    /* Add Label name to symbol table */

    if ( n <= FILNMLEN ) {

        /* inline filename */

        memset( pAux->x_file.x_fname, 0, FILNMLEN );

        strncpy( pAux->x_file.x_fname, pName, n ); /* might not be zero terminated */

    } else {

        pAux->x_file.x_n.x_zeroes = 0;  /* symbol name is in string table */

        pAux->x_file.x_n.x_offset = ci->ListOfStrings.TotalBytes;

        /* add to string table */

        p = (char *)AllocateListObject( &ci->ListOfStrings,  n + 1 );

        if ( !p ) {

            fprintf(stderr, "\nOut of memory allocating string table space!");

            return( False );

        }

        strcpy( p, pName );

    }

    return( ok );

}

/****************************************************************************************/

int stab_add_function( struct prog_info *pi, char *pName, char *pLabel ){

    int n, Address;

    unsigned short CoffType, Type;

    struct syment *pEntry;

    char *pType;

    struct lineno *pln;

    union auxent *pAux;

    int SymbolIndex;

    pType = get_next_token(pName, TERM_COLON ); /* pType = symbol descriptor (character after the colon) */

    Type = atoi(pType + 1);     /* skip past F, predefined variable type */

    if ( (CoffType = GetCoffType( Type )) == 0 ) {

        fprintf(stderr, "\nUnrecognized return type found for function %s = %d", pName, Type );

        return(False);

    }

    /* Get Current Symbol Index, Allocate Symbol Table entry and fill it in */

    SymbolIndex = ci->ListOfSymbols.TotalItems;

    pEntry = (struct syment *)AllocateTwoListObjects( &ci->ListOfSymbols, sizeof(struct syment) * 2 );

    if ( !pEntry ) {

        fprintf(stderr, "\nOut of memory allocating symbol table entry for function %s", pName );

        return( False );

    }

    if ( (n = AddNameToEntry( pName, pEntry )) == 0 ) {

        fprintf(stderr,"\nOut of memory adding local %s to string table", pName );

    }

    if ( !get_symbol(pi, pLabel, &Address) ) {

        fprintf(stderr, "\nUnable to locate function %s", pName );

        return( False );

    }

    pEntry->n_value = Address * 2;  /* convert words to bytes */

    pEntry->n_scnum = 2;    /* .bss */

    if ( (CoffType = GetCoffType( Type )) == 0 ) {

        fprintf(stderr, "\nUnrecognized type found for function %s = %d", pName, Type );

        return(False);

    }

    pEntry->n_type = (unsigned short)(CoffType | (DT_FCN << 4));

    pEntry->n_sclass = C_EXT;

    pEntry->n_numaux = 1;

    pEntry++;   /* point to aux entry */

    pAux = (union auxent *)pEntry;

    pAux->x_sym.x_tagndx = SymbolIndex + 1; /* point to the .bf entry index */

    // wrong!

    //	pAux->x_sym.x_misc.x_lnsz.x_lnno = ci->ListOfLineNumbers.TotalBytes; /* Relative Fixup point to where line numbers start */

    //	pAux->x_sym.x_misc.x_lnsz.x_size = 0; /* UNKNOWN till next function called */

    pAux->x_sym.x_misc.x_fsize = 0; /* unknown till end */

    pAux->x_sym.x_fcnary.x_fcn.x_lnnoptr = ci->ListOfLineNumbers.TotalBytes; /* relative offset to line number entry */

    pAux->x_sym.x_fcnary.x_fcn.x_endndx = 0; /* index to next entry */

    /* Now add function entry into the line number table */

    /* Allocate Symbol Table entry and fill it in */

    pln = (struct lineno *)AllocateListObject(&ci->ListOfLineNumbers, sizeof(struct lineno)  );

    if ( !pln ) {

        fprintf(stderr, "\nOut of memory allocating lineno table for function %s", pName );

        return( False );

    }

    pln->l_lnno = 0;

    pln->l_addr.l_symndx = SymbolIndex;

    /* Initialize the FunctionStartLine from the beginning of the function */

    ci->FunctionStartLine = 0;

    /* Allocate Symbol Table entry and fill it in */

    pEntry = (struct syment *)AllocateTwoListObjects( &ci->ListOfSymbols, sizeof(struct syment) * 2 );

    if ( !pEntry ) {

        fprintf(stderr, "\nOut of memory allocating symbol table entry .bf for function %s", pName );

        return( False );

    }

    memset( pEntry->n_name, 0, 8 );

    strcpy( pEntry->n_name, ".bf" );

    pEntry->n_value = Address * 2;  /* bytes not words */

    pEntry->n_scnum = 1;    /* .text */

    pEntry->n_type = 0;

    pEntry->n_sclass = C_FCN;

    pEntry->n_numaux = 1;

    pEntry++;   /* point to aux entry */

    pAux = (union auxent *)pEntry;

    pAux->x_sym.x_misc.x_lnsz.x_lnno = 0;   /* UNKNOWN - post process */

    pAux->x_sym.x_misc.x_lnsz.x_size = 0;   /* UNKNOWN - post process */

    ci->NeedLineNumberFixup++; /* once for function C_EXT symbol */

    ci->NeedLineNumberFixup++; /* once for .bf block */

    return( True );

}

/****************************************************************************************/

int stab_add_global( struct prog_info *pi, char *pName, char *pType ){

    int n, Address, IsArray, SymbolIndex;

    unsigned short CoffType, Type;

    struct syment *pEntry;

    char *p;

    STABCOFFMAP *pMap;

    n = strlen( pName );    /* see if it's 8 bytes or less */

    Type = atoi(pType + 1);     /* skip past G, predefined variable type */

    if ( (CoffType = GetCoffType( Type )) == 0 ) {

        fprintf(stderr, "\nUnrecognized type found for global %s = %d", pName, Type );

        return(False);

    }

    pMap = (STABCOFFMAP *)GetCurrentListObject( &ci->ListOfTypes );

    SymbolIndex = ci->ListOfSymbols.TotalItems;

    /* Allocate Symbol Table entry and fill it in, Auxiliary table if its an array */

    if ( IsTypeArray( CoffType ) == True ) {

        IsArray = True;

        pEntry = (struct syment *)AllocateTwoListObjects( &ci->ListOfGlobals, sizeof(struct syment) * 2 );

    } else {

        IsArray = False;

        pEntry = (struct syment *)AllocateListObject( &ci->ListOfGlobals, sizeof(struct syment) );

    }

    if ( (n = AddNameToEntry( pName, pEntry )) == 0 ) {

        fprintf(stderr,"\nOut of memory adding local %s to string table", pName );

    }

    /* set value field to be address of label in bytes */

    /* add underscore to lookup label */

    if ( (p = calloc( 1, n + 2)) == 0 ) {

        fprintf(stderr,"\nOut of memory adding global %s", pName );

        return(False);

    }

    *p = '_';

    strcpy( p + 1, pName );

    if ( !get_symbol(pi, p, &Address) ) {

        fprintf(stderr, "\nUnable to locate global %s", p );

        free( p );

        return( False );

    }

    free( p );

    pEntry->n_value = Address;  /* already in bytes */

    if ( ci->GlobalStartAddress == -1 ) {

        ci->GlobalStartAddress = Address;

    }

    if ( Address < ci->GlobalStartAddress )

        ci->GlobalStartAddress = Address;

    if ( Address > ci->GlobalEndAddress )

        ci->GlobalEndAddress = Address;

    pEntry->n_scnum = 2;    /* .bss */

    pEntry->n_type = CoffType;

    pEntry->n_sclass = C_STAT;

    if ( IsArray == False )

        pEntry->n_numaux = 0;

    else {

        pEntry->n_numaux = 1;

        pEntry++;

        AddArrayAuxInfo( (union auxent *)pEntry, (unsigned short)SymbolIndex, pMap );

    }

    return( True );

}

/****************************************************************************************/

int stab_add_local(  struct prog_info *pi, char *pName, char *pType, char *pOffset  ){

    int n, Offset, IsArray;

    unsigned short CoffType, Type, SymbolIndex;

    struct syment *pEntry;

    STABCOFFMAP *pMap;

    n = strlen( pName );    /* see if it's 8 bytes or less */

    Type = atoi(pType);     /* predefined variable type */

    Offset = atoi(pOffset); /* offset in stack frame */

    if ( (CoffType = GetCoffType( Type )) == 0 ) {

        fprintf(stderr, "\nUnrecognized type found for local %s = %d", pName, Type );

        return(False);

    }

    pMap = (STABCOFFMAP *)GetCurrentListObject( &ci->ListOfTypes );

    SymbolIndex = ci->ListOfSymbols.TotalItems;

    /* Allocate Symbol Table entry and fill it in, Auxiliary table if its an array */

    if ( IsTypeArray( CoffType ) == True ) {

        IsArray = True;

        pEntry = (struct syment *)AllocateTwoListObjects( &ci->ListOfGlobals, sizeof(struct syment) * 2 );

    } else {

        IsArray = False;

        pEntry = (struct syment *)AllocateListObject( &ci->ListOfSymbols, sizeof(struct syment) );

    }

    if ( (n = AddNameToEntry( pName, pEntry )) == 0 ) {

        fprintf(stderr,"\nOut of memory adding local %s to string table", pName );

    }

    pEntry->n_type = CoffType;

    pEntry->n_sclass = C_AUTO;

    pEntry->n_scnum = N_ABS;

    pEntry->n_value = Offset + 1; /* Silly avr studio is set in its ways */

    if ( IsArray == False )

        pEntry->n_numaux = 0;

    else {

        pEntry->n_numaux = 1;

        pEntry++;

        AddArrayAuxInfo( (union auxent *)pEntry, SymbolIndex, pMap );

    }

    return( True );

}

/****************************************************************************************/

int stab_add_parameter_symbol( struct prog_info *pi, char *pName, char *pType, char *pOffset  ){

    int n, Offset;

    unsigned short CoffType, Type;

    struct syment *pEntry;

    n = strlen( pName );    /* see if it's 8 bytes or less */

    Type = atoi(pType);     /* predefined variable type */

    Offset = atoi(pOffset); /* offset in stack frame */

    if ( (CoffType = GetCoffType( Type )) == 0 ) {

        fprintf(stderr, "\nUnrecognized type found for %s = %d", pName, Type );

        return(False);

    }

    /* Allocate Symbol Table entry and fill it in */

    pEntry = (struct syment *)AllocateListObject( &ci->ListOfSymbols, sizeof(struct syment) );

    if ( (n = AddNameToEntry( pName, pEntry )) == 0 ) {

        fprintf(stderr,"\nOut of memory adding local %s to string table", pName );

    }

    pEntry->n_type = CoffType;

    pEntry->n_sclass = C_ARG;

    pEntry->n_scnum = N_ABS;

    pEntry->n_value = Offset;

    pEntry->n_numaux = 0;

    return( True );

}

/****************************************************************************************/