void BurnLibs( void )
/**************************/
/* let dict memory know it's no longer needed */
{
file_list *temp;
dict_entry *dict;
for( temp = ObjLibFiles; temp != NULL; temp = temp->next_file ) {
if( temp->status & STAT_AR_LIB ) {
CacheFree( temp, temp->strtab );
temp->strtab = NULL;
}
dict = temp->u.dict;
if( dict == NULL )
continue;
if( temp->status & STAT_AR_LIB ) {
CacheFree( temp, dict->a.filepostab - 1 );
_LnkFree( dict->a.symbtab );
} else {
if( dict->o.cache != NULL ) {
FreeDictCache( dict->o.cache, ( dict->o.pages / PAGES_IN_CACHE ) + 1 );
}
}
_LnkFree( dict );
temp->u.dict = NULL;
FreeObjCache( temp );
}
}
bool ProcCopyright( void )
/************************/
{
struct tm *currtime;
time_t thetime;
unsigned year;
char *copy_year;
if( !GetToken( SEP_EQUALS, TOK_INCLUDE_DOT ) && !GetToken( SEP_NO, TOK_INCLUDE_DOT ) ) {
if( FmtData.u.nov.copyright != NULL ) {
_LnkFree( FmtData.u.nov.copyright ); // assume second is correct.
}
_ChkAlloc( FmtData.u.nov.copyright, DEFAULT_COPYRIGHT_LENGTH + 1 );
memcpy(FmtData.u.nov.copyright,DEFAULT_COPYRIGHT,DEFAULT_COPYRIGHT_LENGTH+1);
copy_year = FmtData.u.nov.copyright + YEAR_OFFSET;
thetime = time( NULL );
currtime = localtime( &thetime );
for( year = currtime->tm_year + 1900; year > 0; year /= 10 ) {
*copy_year = '0' + (year % 10);
copy_year--;
}
} else {
if( Token.len > MAX_COPYRIGHT_LENGTH ) {
LnkMsg( LOC+LINE+WRN+MSG_VALUE_TOO_LARGE, "s", "copyright" );
} else {
if( FmtData.u.nov.copyright != NULL ) {
_LnkFree( FmtData.u.nov.copyright ); // assume second is correct.
}
FmtData.u.nov.copyright = tostring();
}
}
return( true );
}
void FreePharFmt( void )
/*****************************/
{
_LnkFree( FmtData.u.phar.breaksym );
_LnkFree( FmtData.u.phar.params );
_LnkFree( FmtData.u.phar.stub );
}
static void FreeDictCache( void **cache, unsigned buckets )
/*********************************************************/
{
while( buckets-- > 0 ) {
_LnkFree( cache[buckets] );
}
_LnkFree( cache );
}
static void BurnNodeArray( nodearray *list )
/******************************************/
{
int index;
for( index = 0; index <= list->arraymax; index++ ) {
_LnkFree( list->array[index] );
}
_LnkFree( list );
}
unsigned long ObjPass1( void )
/****************************/
/* Pass 1 of 8086 linker. */
{
unsigned long loc;
char *savename;
DEBUG(( DBG_BASE, "1 : file = %s, module = %s", CurrMod->f.source->file->name, CurrMod->name ));
CurrMod->modinfo |= MOD_DONE_PASS_1;
SymModStart();
DBIInitModule( CurrMod );
RelocStartMod();
P1Start();
loc = CallPass1[ GET_FMT_IDX( ObjFormat ) ]();
CollapseLazyExtdefs();
SymModEnd();
if( !(CurrMod->modinfo & MOD_GOT_NAME) ) {
savename = CurrMod->name;
CurrMod->name = AddStringStringTable( &PermStrings, savename );
_LnkFree( savename );
CurrMod->modinfo |= MOD_GOT_NAME;
}
DBIP1ModuleScanned();
ReleaseNames();
PermEndMod( CurrMod );
FreeObjInfo();
ObjFormat = 0; //clear flags for processing obj file
return( loc );
}
void MakeSymAlias( char *name, size_t namelen, char *target, size_t targetlen )
/*****************************************************************************/
/* make a symbol table alias */
{
symbol *sym;
symbol *targ;
if( namelen == targetlen && (*CmpRtn)( name, target, namelen ) == 0 ) {
char *buff;
buff = alloca( targetlen + 1 );
memcpy( buff, target, targetlen );
buff[ targetlen ] = '\0';
LnkMsg( WRN+MSG_CIRCULAR_ALIAS_FOUND, "s", buff );
return; // <--------- NOTE: premature return!!!!
}
sym = SymOp( ST_CREATE | ST_NOALIAS, name, namelen );
if( IS_SYM_ALIAS( sym ) ) {
LnkMsg( WRN+MSG_MULTIPLE_ALIASES, "S", sym );
if( sym->info & SYM_FREE_ALIAS ) {
_LnkFree( sym->p.alias );
}
} else if( sym->info & SYM_DEFINED ) {
return; // <--------- NOTE: premature return!!!!
}
sym->info |= SYM_FREE_ALIAS;
/*
* need to defined aliased symbol as well, so aliases in .obj files can be
* hauled in from libraries
*/
targ = SymOp( ST_CREATE, target, targetlen );
SetSymAlias( sym, targ->name, targetlen );
}
static bool DumpFileCache( infilelist *file, bool nuke )
/******************************************************/
{
unsigned num;
unsigned savenum;
unsigned index;
char ** blocklist;
bool blockfreed;
blockfreed = FALSE;
if( nuke ) {
savenum = UINT_MAX;
} else {
savenum = file->currpos / CACHE_PAGE_SIZE;
}
if( file->cache != NULL ) {
num = NumCacheBlocks( file->len );
blocklist = file->cache;
for( index = 0; index < num; index++ ) {
if( index != savenum && *blocklist != NULL ) {
_LnkFree( *blocklist );
*blocklist = NULL;
blockfreed = TRUE;
}
blocklist++;
}
}
return( blockfreed );
}
static void CleanSubSystems( void )
/*********************************/
{
if( MapFile != NIL_HANDLE ) {
QClose( MapFile, MapFName );
MapFile = NIL_HANDLE;
}
FreeOutFiles();
_LnkFree( MapFName );
BurnSystemList();
FreeList( LibPath );
CloseSpillFile();
CleanTraces();
FreePaths();
FreeUndefs();
FreeLocalImports();
CleanLoadFile();
CleanLinkStruct();
FreeFormatStuff();
FreeObjInfo();
FreeVirtMem();
CleanToc();
CleanSym();
CleanPermData();
}
void ConvertLazyRefs( void )
/*********************************/
/* go through all symbols, & turn lazy refs to aliases to default sym. */
{
symbol * defsym;
symbol * sym;
for( sym = HeadSym; sym != NULL; sym = sym->link ) {
if( IS_SYM_A_REF(sym) ) {
if( IS_SYM_VF_REF(sym) ) {
defsym = *(sym->e.vfdata);
_LnkFree( sym->e.vfdata );
} else {
defsym = sym->e.def;
if( sym->info & SYM_VF_MARKED ) {
DefStripSym( sym, AllocSegData() ); // see note 1 below.
}
}
WeldSyms( sym, defsym );
sym->info |= SYM_WAS_LAZY;
if( LinkFlags & SHOW_DEAD ) {
LnkMsg( MAP+MSG_SYMBOL_DEAD, "S", sym );
}
}
}
}
void CacheFree( file_list *list, void *mem )
/*************************************************/
// used for disposing things allocated by CachePermRead
{
if( list->file->flags & INSTAT_PAGE_CACHE ) {
_LnkFree( mem );
}
}
void FreeTokBuffs( void )
/******************************/
{
if( TokBuff != NULL ) {
_LnkFree( TokBuff );
TokBuff = NULL;
}
}
void CarveDestroy( carve_t cv )
/*****************************/
{
blk_t *cur;
blk_t *next;
if( cv != NULL ) {
if( cv->blk_map != NULL ) {
_LnkFree( cv->blk_map );
}
for( cur = cv->blk_list; cur != NULL; cur = next ) {
next = cur->next;
_LnkFree( cur );
}
_LnkFree( cv );
}
}
static void BadLibrary( file_list *list )
/***************************************/
{
list->file->flags |= INSTAT_IOERR;
_LnkFree( list->u.dict );
list->u.dict = NULL;
Locator( list->file->name, NULL, 0 );
LnkMsg( ERR+MSG_LIB_FILE_ATTR, NULL );
}
void FiniELFLoadFile( void )
/*********************************/
{
ElfHdr hdr;
SetHeaders( &hdr );
#if 0
if( (LinkState & HAVE_PPC_CODE) && (FmtData.type & MK_OS2) ) {
// Development temporarly on hold
// BuildOS2Imports(); // Build .got section
}
#endif
WriteELFGroups( &hdr ); // Write out all groups
WriteRelocsSections( &hdr ); // Relocations
if( INJECT_DEBUG ) { // Debug info
hdr.curr_off = DwarfWriteElf( hdr.curr_off, &hdr.secstrtab,
hdr.sh+hdr.i.dbgbegin );
}
if( ElfSymTab != NULL ) { // Symbol tables
WriteElfSymTable( ElfSymTab, &hdr, hdr.i.symhash, hdr.i.symtab,
hdr.i.symstr);
ZapElfSymTable( ElfSymTab );
}
if( hdr.i.symstr != 0 ) { // String sections
WriteSHStrings( &hdr, hdr.i.symstr, &SymStrTab );
}
WriteSHStrings( &hdr, hdr.i.secstr, &hdr.secstrtab );
hdr.eh.e_shoff = hdr.curr_off;
WriteLoad( hdr.sh, hdr.sh_size );
hdr.curr_off += hdr.sh_size;
if( !INJECT_DEBUG ) {
DBIWrite();
}
SeekLoad( 0 );
WriteLoad( &hdr.eh, sizeof(Elf32_Ehdr) );
WriteLoad( hdr.ph, hdr.ph_size );
_LnkFree( hdr.sh );
_LnkFree( hdr.ph );
FiniStringTable( &hdr.secstrtab );
FiniStringTable( &SymStrTab );
SeekLoad( hdr.curr_off );
}
static void WipeSym( symbol *sym )
/********************************/
{
if( IS_SYM_IMPORTED(sym) && !(FmtData.type & MK_ELF) ) {
if( FmtData.type & MK_NOVELL ) {
if( sym->p.import != DUMMY_IMPORT_PTR ) {
_LnkFree( sym->p.import );
}
} else {
FreeImport( sym->p.import );
}
sym->p.import = NULL;
} else if( IS_SYM_ALIAS(sym) ) {
if( sym->info & SYM_FREE_ALIAS ) {
_LnkFree( sym->p.alias );
}
sym->u.aliaslen = 0; // make sure this is nulled again
}
}
static void FiniFile( orl_file_handle filehdl, file_list *list )
/**************************************************************/
{
ORLFileFini( filehdl );
ClearCachedData( list );
if( ImpModName != NULL ) {
_LnkFree( ImpModName );
ImpModName = NULL;
}
}
static void FreeCDatPiece( void * piec )
/**************************************/
{
comdat_piece *piece = piec;
if( piece->free_data ) {
_LnkFree( piece->data );
}
piece->next = FreedPieces;
FreedPieces = piece;
}
void FreeObjCache( file_list *list )
/*****************************************/
{
if( list == NULL ) return;
if( list->file->flags & INSTAT_FULL_CACHE ) {
_LnkFree( list->file->cache );
} else {
DumpFileCache( list->file, TRUE );
}
list->file->cache = NULL;
}
void ClearRefInfo( symbol *sym )
/*************************************/
{
symbol * save;
if( !(sym->info & SYM_EXPORTED) ) {
save = *(sym->e.vfdata);
_LnkFree( sym->e.vfdata );
sym->e.def = save;
}
}
void CloseSpillFile( void )
/*************************/
/* Close temporary file. */
{
if( TempFile != NIL_FHANDLE ) {
RestoreBreak();
QClose( TempFile, TFileName );
QDelete( TFileName );
_LnkFree( TFileName );
TFileName = NULL;
TempFile = NIL_FHANDLE;
}
}
static void ClearCachedData( file_list *list )
/********************************************/
{
readcache *cache;
readcache *next;
for( cache = ReadCacheList; cache != NULL; cache = next ) {
next = cache->next;
CacheFree( list, cache->data );
_LnkFree( cache );
}
ReadCacheList = NULL;
}
char *GetNextLink( void )
/***********************/
{
char *cmd;
cmd = NULL;
_LnkFree( PrevCommand );
if( LinkCommands != NULL ) {
PrevCommand = LinkCommands;
LinkCommands = LinkCommands->next;
cmd = PrevCommand->commands;
}
return( cmd );
}
bool ProcScreenName( void )
/*************************/
{
if( !GetToken( SEP_NO, TOK_INCLUDE_DOT ) ) {
return( false );
}
if( Token.len > MAX_SCREEN_NAME_LENGTH ) {
LnkMsg( LOC+LINE+WRN+MSG_VALUE_TOO_LARGE, "s", "screenname" );
} else {
if( FmtData.u.nov.screenname != NULL ) {
_LnkFree( FmtData.u.nov.screenname ); // assume second is correct.
}
FmtData.u.nov.screenname = tostring();
}
return( true );
}
void ConvertVFSym( symbol * sym )
/**************************************/
/* convert the symbol from a virtual function def. record to either a extdef
* or a lazy reference*/
{
symbol * defsym;
defsym = *(sym->e.vfdata);
_LnkFree( sym->e.vfdata );
sym->e.def = defsym;
if( IS_SYM_PURE_REF( sym ) ) {
SET_SYM_TYPE( sym, SYM_LAZY_REF );
} else {
SET_SYM_TYPE( sym, SYM_REGULAR );
}
sym->info &= ~SYM_CHECKED;
}
static void WriteQNXResource( void )
/**********************************/
{
unsigned long len;
lmf_record rec;
f_handle file;
lmf_resource resource;
void * buf;
if( FmtData.resource != NULL ) {
rec.reserved = 0;
rec.spare = 0;
rec.rec_type = LMF_RESOURCE_REC;
memset( &resource, 0, sizeof( lmf_resource ) );
if( FmtData.res_name_only ) {
file = QObjOpen( FmtData.resource );
if( file == NIL_FHANDLE ) {
PrintIOError( WRN+MSG_CANT_OPEN_NO_REASON, "s",
FmtData.resource );
return;
}
len = QFileSize( file );
if( len + sizeof(lmf_resource) > QNX_MAX_REC_SIZE ) {
LnkMsg( WRN+MSG_RESOURCE_TOO_BIG, "s", FmtData.resource );
return;
}
_ChkAlloc( buf, len );
rec.data_nbytes = len + sizeof( lmf_resource );
WriteLoad( &rec, sizeof( lmf_record ) );
WriteLoad( &resource, sizeof( lmf_resource ) );
QRead( file, buf, len, FmtData.resource );
WriteLoad( buf, len );
_LnkFree( buf );
QClose( file, FmtData.resource );
} else {
len = strlen( FmtData.resource );
FmtData.resource[len] = '\n';
len++;
rec.data_nbytes = len + sizeof( lmf_resource );
WriteLoad( &rec, sizeof( lmf_record ) );
WriteLoad( &resource, sizeof( lmf_resource ) );
WriteLoad( FmtData.resource, len );
}
}
}
static void PrepSymbol( void *_sym, void *info )
/**********************************************/
{
symbol *sym = _sym;
char *save;
symbol *mainsym;
if( sym->info & SYM_IS_FREE ) {
*((unsigned_32 *)sym) = CARVE_INVALID_INDEX;
return;
}
sym->hash = CarveGetIndex( CarveSymbol, sym->hash );
sym->link = CarveGetIndex( CarveSymbol, sym->link );
sym->publink = CarveGetIndex( CarveSymbol, sym->publink );
if( sym->info & SYM_IS_ALTDEF ) {
mainsym = sym->e.mainsym;
if( !(mainsym->info & SYM_NAME_XLATED) ) {
mainsym->name = GetString( info, mainsym->name );
mainsym->info |= SYM_NAME_XLATED;
}
sym->name = mainsym->name;
} else if( !(sym->info & SYM_NAME_XLATED) ) {
sym->name = GetString( info, sym->name );
sym->info |= SYM_NAME_XLATED;
}
sym->mod = CarveGetIndex( CarveModEntry, sym->mod );
if( IS_SYM_ALIAS( sym ) ) {
save = sym->p.alias;
sym->p.alias = GetString( info, sym->p.alias );
if( sym->info & SYM_FREE_ALIAS ) {
_LnkFree( save );
}
} else if( IS_SYM_IMPORTED(sym) ) {
if( FmtData.type & (MK_OS2 | MK_PE) ) {
sym->p.import = CarveGetIndex( CarveDLLInfo, sym->p.import );
}
} else if( !(sym->info & SYM_IS_ALTDEF) || IS_SYM_COMDAT(sym) ) {
sym->p.seg = CarveGetIndex( CarveSegData, sym->p.seg );
sym->u.altdefs = CarveGetIndex( CarveSymbol, sym->u.altdefs );
}
if( sym->info & SYM_EXPORTED ) {
if( FmtData.type & (MK_OS2 | MK_PE | MK_WIN_VXD) ) {
sym->e.export = CarveGetIndex( CarveExportInfo, sym->e.export );
}
} else if( sym->e.def != NULL ) {
static bool ReadARDict( file_list *list, unsigned long *loc, bool makedict )
/**************************************************************************/
{
ar_header *ar_hdr;
unsigned long size;
int numdicts;
numdicts = 0;
if( makedict ) {
if( list->u.dict == NULL ) {
_ChkAlloc( list->u.dict, sizeof( dict_entry ) );
}
}
for( ;; ) {
ar_hdr = CacheRead( list, *loc, sizeof( ar_header ) );
size = GetARValue( ar_hdr->size, AR_SIZE_LEN );
if( ar_hdr->name[0] == '/' && ar_hdr->name[1] == ' ' ) {
++numdicts;
*loc += sizeof( ar_header );
if( makedict )
ReadARDictData( list, loc, size, numdicts );
*loc += MAKE_EVEN( size );
} else if( ar_hdr->name[0] == '/' && ar_hdr->name[1] == '/' ) {
*loc += sizeof( ar_header );
ReadARStringTable( list, loc, size );
*loc += MAKE_EVEN( size );
} else {
break; // found an actual object file
}
}
if( makedict ) {
if( numdicts == 0 ) {
Locator( list->file->name, NULL, 0 );
LnkMsg( ERR+MSG_NO_DICT_FOUND, NULL );
_LnkFree( list->u.dict );
list->u.dict = NULL;
return( FALSE );
}
if( !(LinkFlags & CASE_FLAG) || numdicts == 1 ) {
SortARDict( &list->u.dict->a );
}
}
return( TRUE );
}
bool SetCurrentPrefix(const char * pszPrefix, size_t nLen)
{
const char * pStart = pszPrefix;
char * pFix;
unsigned nIntLen = nLen;
char *newbuff = NULL;
/*
// Always delete
*/
if( CmdFile->symprefix ) {
_LnkFree( CmdFile->symprefix );
CmdFile->symprefix = NULL;
}
if( (NULL == pStart) || (nLen == 0) ) {
return TRUE;
}
pStart++; /* skip opening parentheses */
nIntLen--; /* and record that */
while( (0 != *pStart) && IS_WHITESPACE(pStart) )
pStart++, nIntLen--;
if( (0 == *pStart) || (0 == nLen) )
return FALSE;
/* convert to C string */
_LnkAlloc( newbuff, nIntLen + 1 );
memcpy( newbuff, pStart, nIntLen - 1 );
newbuff[nIntLen-1] = '\0';
CmdFile->symprefix = newbuff;
pFix = newbuff;
while( (0 != *pFix) && !IS_WHITESPACE(pFix) )
pFix++;
*pFix = '\0';
return( 0 != strlen( newbuff ));
}
symbol *SymOp( sym_flags op, char *symname, size_t length )
/*********************************************************/
/* search for symbols, handling aliases */
{
symbol * sym;
sym = DoSymOp( op, symname, length );
if( !(op & ST_NOALIAS) ) {
sym = UnaliasSym( op, sym );
}
if( sym != NULL ) {
if( op & ST_DEFINE ) {
if( IS_SYM_ALIAS( sym ) && sym->info & SYM_FREE_ALIAS ) {
_LnkFree( sym->p.alias );
sym->info &= ~SYM_FREE_ALIAS;
}
sym->info |= SYM_DEFINED;
}
if( op & ST_REFERENCE ) {
sym->info |= SYM_REFERENCED;
}
}
return( sym );
}
