projects / unix-history / blob
? search:
summary | tags | clone url | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
BSD 3 development
[unix-history] / usr / src / cmd / ld.c
char LD[] = "@(#)ld.c 1.10 78/12/07 15:34:58"; /* sccs ident */
/*
* link editor for VAX
*/
/* layout of a.out file:
*
* header of 8 words magic number 0410:
data starts at 1st (PAGSIZ)
boundary above text
magic number 0407:
data starts immediately after
text
* text size )
* data size ) in bytes
* bss size )
* symbol table size
* entry point
* size of text relocation info
* size of data relocation info
*
* 'segment' origin comments
* header: 0
* text: 32 0 padded to multiple of 4 bytes
* data: 32+textsize 0 padded to multiple of 4 bytes
* text relocation: 32+textsize+datasize
* data relocation: 32+textsize+datasize+textrelocationsize
* symbol table: 32+textsize+datasize+textrelocationsize+datarelocationsize
*
*/
#include <signal.h>
#include <stdio.h>
#include <ar.h>
#include <a.out.h>
#include <pagsiz.h>
struct {short hiword; short loword;}; /* stupid fp-11 */
fixl(p) register long *p;{
register short t;
t=p->hiword; p->hiword=p->loword; p->loword=t;
}
writel(p,n,f) long *p; FILE *f; {
#ifdef vax
fwrite(p,sizeof(*p),n,f);
#else
while (n--) {
fwrite(&(*p).loword,2,1,f);
fwrite(&(*p).hiword,2,1,f);
p++;
}
#endif
}
long htoi(p) register char *p; {/* hex to integer conversion */
register long n = 0;
while (*p) {
n <<= 4;
if (*p<='9' && *p>='0') n += *p - '0';
else if (*p<='f' && *p>='a') n += *p -'a' +10;
else if (*p<='F' && *p>='A') n += *p -'A' +10;
p++;
}
return(n);
}
typedef char *STRING;
typedef int BOOL;
#define TRUE 1
#define FALSE 0
#define OMAGIC 0407
#define NMAGIC 0410
/*
* Symbol types
*/
#define UNDEF 0x0
#define ABS 0x2
#define TEXT 0x4
#define DATA 0x6
#define BSS 0x8
#define DATAO 0xA
#define BSSO 0xC
#define TEXTO 0xE
#define ABSO 0x10
#define COMM 0x12 /* for internal use only */
#define EXTERN 0x1
#define TYPE 0x1E
#define STABTYPS 0xE0
/*
* address reference types
*/
#define PCREL 1
#define LEN1 0
#define LEN2 2
#define LEN4 4
#define HW 01
#define FW 03
#define DW 07
#define TYPMASK 0x1E
#define TYMASK (0x1E)
#define TMASK 0x1F
#define RABS (ABS)
#define RTEXT TEXT
#define RDATA DATA
#define RBSS BSS
#define RDATAO DATAO
#define RBSSO BSSO
#define RTEXTO TEXTO
#define RABSO ABSO
#define REXT (01<<3)
#define ROFF (02<<3)
#define REFMASK 0x7
#define NOVLY 1
#define RELFLG 01
#define NROUT 256
#define NSYM 1103
#define NSYMPR 500
char premeof[] = "Premature EOF";
typedef struct {
long loc;
} LIBLIST;
/* overlay management */
int vindex;
typedef struct {
int argsav;
int symsav;
LIBLIST *libsav;
STRING vname;
long ctsav, cdsav, cbsav;
long offt, offd, offb, offtr, offdr, offs;
} OVERLAY;
OVERLAY vnodes[NOVLY];
/* input management */
typedef struct {
short *fakeptr;
int bno;
int nibuf;
int nuser;
char buff[BSIZE];
} PAGE;
PAGE page[2];
struct {
short *fakeptr;
int bno;
int nibuf;
int nuser;
} fpage;
typedef struct {
char *ptr;
int bno;
int nibuf;
long size;
long pos;
PAGE *pno;
} STREAM;
STREAM text;
STREAM reloc;
struct ar_hdr archdr;
struct exec filhdr;
/* one entry for each archive member referenced;
* set in first pass; needs restoring for overlays
*/
LIBLIST liblist[NROUT];
LIBLIST *libp = liblist;
/* symbol management */
typedef struct {
char sname[8];
char stype;
char spare;
short symhash; /* index of hash table entry pointing to this symbol */
long svalue;
} SYMBOL;
typedef struct {
int locindex; /* index to symbol in file */
SYMBOL *locsymbol; /* ptr to symbol table */
} LOCAL;
SYMBOL cursym; /* current symbol */
SYMBOL *symtab; /* actual symbols */
SYMBOL *lastsym; /* last symbol entered */
SYMBOL *nextsym; /* next available symbol table entry */
int nsym; /* number of symbols allocated in symtab */
SYMBOL *hshtab[NSYM+2]; /* hash table for symbols */
LOCAL *local;
/* internal symbols */
SYMBOL *p_data;
SYMBOL *p_etext;
SYMBOL *p_edata;
SYMBOL *p_end;
SYMBOL *entrypt;
int trace;
/* flags */
int xflag; /* discard local symbols */
int Xflag; /* discard locals starting with 'L' */
int Sflag; /* discard all except locals and globals*/
int rflag; /* preserve relocation bits, don't define common */
int arflag; /* original copy of rflag */
int sflag; /* discard all symbols */
int nflag = 1; /* pure procedure */
int dflag; /* define common even with rflag */
int iflag; /* I/D space separated */
BOOL vflag; /* overlays used */
int zflag;
int ofilfnd;
char *ofilename = "l.out";
int infil;
char *filname;
long textbase;
/* cumulative sizes set in pass 1 */
long tsize;
long dsize;
long bsize;
long trsize;
long drsize;
long ssize;
/* symbol relocation; both passes */
long ctrel;
long cdrel;
long cbrel;
long ctorel;
long cdorel;
long cborel;
int errlev;
int delarg = 4;
FILE *tout;
FILE *dout;
char *doutn = "";
FILE *trout;
char *troutn = "";
FILE *drout;
char *droutn = "";
FILE *sout;
char *soutn = "";
char *mktemp();
char get();
char getb();
short gets();
long get3();
long getl();
SYMBOL **lookup();
FILE *tcreat();
long round();
SYMBOL **slookup();
SYMBOL *lookloc();
symwrite(sp,n,f) SYMBOL *sp; FILE *f; {
#ifdef vax
fwrite(sp,sizeof(*symtab),n,f);
#else
while (n--) {
fwrite(sp,sizeof(*symtab)-sizeof(sp->svalue),1,f);
writel(&(sp->svalue),1,f); sp++;
}
#endif
}
delexit()
{
unlink("l.out");
unlink(doutn);
unlink(troutn);
unlink(droutn);
unlink(soutn);
if (delarg==0)
chmod(ofilename, 0777 &~ umask(0));
exit(delarg);
}
main(argc, argv)
char **argv;
{
register int c, i;
int num;
register char *ap, **p;
BOOL found;
int vscan;
char save;
if (signal(SIGINT, SIG_IGN) != SIG_IGN)
signal(SIGINT, delexit);
if (argc == 1)
exit(4);
p = argv+1;
nextsym=symtab=sbrk(0); nsym=0;
/* scan files once to find symdefs */
for (c=1; c<argc; c++) {
if (trace) printf("%s:\n", *p);
filname = 0;
ap = *p++;
if (*ap == '-') {
for (i=1; ap[i]; i++) {
switch (ap[i]) {
case 'o':
if (++c >= argc)
error(1, "Bad output file");
ofilename = *p++;
ofilfnd++;
continue;
case 'u':
case 'e':
if (++c >= argc)
error(1, "Bad 'use' or 'entry'");
enter(slookup(*p++));
if (ap[i]=='e')
entrypt = lastsym;
continue;
case 'v':
if (++c >= argc)
error(1, "-v: arg missing");
vflag=TRUE;
vscan = vindex;
found=FALSE;
while (--vscan>=0 && found==FALSE)
found = eq(vnodes[vscan].vname, *p);
if (found) {
endload(c, argv);
restore(vscan);
} else
record(c, *p);
p++;
continue;
case 'D':
if (++c >= argc)
error(1, "-D: arg missing");
num = htoi(*p++);
if (dsize>num)
error(1, "-D: too small");
dsize = num;
continue;
case 'T':
if (++c >= argc)
error(1, "-T: arg missing");
if (tsize!=0)
error(1, "-T: too late, some text already loaded");
textbase = htoi(*p++);
continue;
case 'l':
save = ap[--i];
ap[i]='-';
load1arg(&ap[i]);
ap[i]=save;
break;
case 'x':
xflag++;
continue;
case 'X':
Xflag++;
continue;
case 'S':
Sflag++;
continue;
case 'r':
rflag++;
arflag++;
continue;
case 's':
sflag++;
xflag++;
continue;
case 'n':
nflag++;
continue;
case 'N':
nflag = 0;
continue;
case 'd':
dflag++;
continue;
case 'i':
iflag++;
continue;
case 't':
trace++;
continue;
case 'z':
zflag++;
continue;
default:
error(1, "bad flag");
} /*endsw*/
break;
} /*endfor*/
} else
load1arg(ap);
}
endload(argc, argv);
exit(0);
}
/* used after pass 1 */
long torigin;
long dorigin;
long borigin;
long database;
endload(argc, argv)
int argc;
char **argv;
{
register int c, i;
long dnum;
register char *ap, **p;
brk(nextsym);
filname = 0;
middle();
setupout();
if (-1==(local=sbrk(NSYMPR*sizeof(*local)))) error(1,"Memory overflow");
p = argv+1;
libp = liblist;
for (c=1; c<argc; c++) {
ap = *p++;
if (trace) printf("%s:\n", ap);
if (*ap == '-') {
for (i=1; ap[i]; i++) {
switch (ap[i]) {
case 'D':
for (dnum = htoi(*p); dorigin<dnum; dorigin++) putc(0, dout);
case 'T':
case 'u':
case 'e':
case 'o':
case 'v':
++c;
++p;
default:
continue;
case 'l':
ap[--i]='-';
load2arg(&ap[i]);
break;
} /*endsw*/
break;
} /*endfor*/
} else
load2arg(ap);
}
finishout();
}
record(c, nam)
int c;
STRING nam;
{
register OVERLAY *v;
v = &vnodes[vindex++];
v->argsav = c;
v->symsav = nextsym-symtab;
v->libsav = libp;
v->vname = nam;
v->offt = tsize;
v->offd = dsize;
v->offb = bsize;
v->offtr = trsize;
v->offdr = drsize;
v->offs = ssize;
v->ctsav = ctrel;
v->cdsav = cdrel;
v->cbsav = cbrel;
}
restore(vscan)
int vscan;
{
register OVERLAY *v;
register SYMBOL *saved,*sp;
v = &vnodes[vscan];
vindex = vscan+1;
libp = v->libsav;
ctrel = v->ctsav;
cdrel = v->cdsav;
cbrel = v->cbsav;
tsize = v->offt;
dsize = v->offd;
bsize = v->offb;
trsize = v->offtr;
drsize = v->offdr;
ssize = v->offs;
saved = symtab + v->symsav;
sp = nextsym;
while (sp>saved)
hshtab[(--sp)->symhash]=0;
nextsym = saved;
}
/* scan file to find defined symbols */
load1arg(cp)
register char *cp;
{
long loc;
if (getfile(cp)==0)
load1(0, 0L);
else {
loc = sizeof(int);
for (;;) {
dseek(&text, loc, (long)sizeof(archdr));
if (text.size <= 0) {
libp->loc = -1;
if( ++libp >= liblist + NROUT)
error(1,"liblist overflow");
/* thanks to Dennis Wasley */
return;
}
mget((short *)&archdr, sizeof archdr, &text);
if (load1(1, loc+sizeof(archdr))) {
libp->loc = loc;
libp++;
}
#ifndef vax
if (archdr.ar_size.loword==0) fixl(&archdr.ar_size);
#endif
loc += round(archdr.ar_size, 1) + sizeof(archdr);
}
}
close(infil);
}
/* single file or archive member */
load1(libflg, loc)
long loc;
{
register SYMBOL *sp;
SYMBOL *savnext;
int ndef, nlocal, type;
readhdr(loc);
ctrel = tsize;
cdrel += dsize;
cbrel += bsize;
ndef = 0;
nlocal = sizeof(cursym);
savnext = nextsym;
/* if (filhdr.a_trsize+filhdr.a_drsize==0) {
/* error(0, "No relocation bits");
/* return(0);
/* }
*/
loc += filhdr.a_text + filhdr.a_data +
filhdr.a_trsize + filhdr.a_drsize + sizeof(filhdr);
dseek(&text, loc, filhdr.a_syms);
while (text.size > 0) {
symget(&cursym, &text);
type = cursym.stype;
if ((type&EXTERN)==0) {
if (Xflag==0 || cursym.sname[0]!='L' || type & STABTYPS)
nlocal += sizeof cursym;
continue;
}
symreloc();
if (enter(lookup()))
continue;
if ((sp = lastsym)->stype != EXTERN+UNDEF)
continue;
if (cursym.stype == EXTERN+UNDEF) {
if (cursym.svalue > sp->svalue)
sp->svalue = cursym.svalue;
continue;
}
if (sp->svalue != 0 && cursym.stype == EXTERN+TEXT)
continue;
ndef++;
sp->stype = cursym.stype;
sp->svalue = cursym.svalue;
}
if (libflg==0 || ndef) {
tsize += filhdr.a_text;
dsize += round(filhdr.a_data, FW);
bsize += round(filhdr.a_bss, FW);
ssize += nlocal;
trsize += filhdr.a_trsize;
drsize += filhdr.a_drsize;
return(1);
}
/*
* No symbols defined by this library member.
* Rip out the hash table entries and reset the symbol table.
*/
while (nextsym>savnext)
hshtab[(--nextsym)->symhash]=0;
return(0);
}
middle()
{
register SYMBOL *sp, *symp;
long csize, t, corigin, ocsize;
int nund, rnd;
char s;
torigin = 0;
dorigin = 0;
borigin = 0;
p_data = *slookup("_data");
p_etext = *slookup("_etext");
p_edata = *slookup("_edata");
p_end = *slookup("_end");
/*
* If there are any undefined symbols, save the relocation bits.
*/
symp = nextsym;
if (rflag==0) {
for (sp = symtab; sp<symp; sp++)
if (sp->stype==EXTERN+UNDEF && sp->svalue==0
&& sp!=p_end && sp!=p_edata && sp!=p_etext
&& sp!=p_data) {
rflag++;
dflag = 0;
break;
}
}
if (rflag)
sflag = iflag = 0;
/*
* Assign common locations.
*/
csize = 0;
database = round(tsize+textbase, (nflag? PAGRND:FW));
if (dflag || rflag==0) {
ldrsym(p_data, (long)0 , EXTERN+DATA);
ldrsym(p_etext, tsize, EXTERN+TEXT);
ldrsym(p_edata, dsize, EXTERN+DATA);
ldrsym(p_end, bsize, EXTERN+BSS);
for (sp = symtab; sp<symp; sp++) {
if ((s=sp->stype)==EXTERN+UNDEF && (t = sp->svalue)!=0) {
if (t>DW)
rnd = DW;
else if (t>FW)
rnd = FW;
else
rnd = HW;
csize = round(csize, rnd);
sp->svalue = csize;
sp->stype = EXTERN+COMM;
ocsize = csize;
csize += t;
}
if (((s&TMASK) == EXTERN+UNDEF) && (s & STABTYPS)) {
sp->svalue = ocsize;
sp->stype = (s & STABTYPS) | (EXTERN+COMM);
}
}
}
/*
* Now set symbols to their final value
*/
csize = round(csize, FW);
torigin = textbase;
dorigin = database;
corigin = dorigin + dsize;
borigin = corigin + csize;
/*
if (zflag)
borigin = round(borigin, PAGRND);
*/
cdorel = 0;
cborel = dsize+csize;
nund = 0;
for (sp = symtab; sp<symp; sp++) switch (sp->stype & TMASK) {
case EXTERN+UNDEF:
errlev |= 01;
if ((arflag==0 || dflag) && sp->svalue==0) {
if (nund==0)
printf("Undefined:\n");
nund++;
printf("%.8s\n", sp->sname);
}
continue;
case EXTERN+ABS:
default:
continue;
case EXTERN+TEXT:
sp->svalue += torigin;
continue;
case EXTERN+DATA:
sp->svalue += dorigin;
continue;
case EXTERN+BSS:
sp->svalue += borigin;
continue;
case EXTERN+COMM:
sp->stype = (sp->stype & STABTYPS) | (EXTERN+BSS);
sp->svalue += corigin;
continue;
}
if (sflag || xflag)
ssize = 0;
bsize += csize;
nsym = ssize / (sizeof cursym);
}
ldrsym(asp, val, type)
long val;
SYMBOL *asp;
{
register SYMBOL *sp;
if ((sp = asp) == 0)
return;
if (sp->stype != EXTERN+UNDEF || sp->svalue) {
printf("%.8s: ", sp->sname);
error(0, "Multiply defined (internal)");
return;
}
sp->stype = type;
sp->svalue = val;
}
extern char _sibuf[BUFSIZ]; /* the space is forced upon us; might as well use it */
setupout()
{
int bss;
tout = fopen(ofilename, "w");
if (tout==NULL)
error(1, "cannot create output");
setbuf(tout,_sibuf);
dout = tcreat(&doutn, "/tmp/ldaaXXXXX");
if (sflag==0 || xflag==0)
sout = tcreat(&soutn, "/tmp/ldbaXXXXX");
if (rflag) {
trout = tcreat(&troutn, "/tmp/ldcaXXXXX");
drout = tcreat(&droutn, "/tmp/lddaXXXXX");
}
filhdr.a_magic = nflag? NMAGIC:OMAGIC;
if (zflag)
filhdr.a_magic = nflag?0413:0412;
filhdr.a_text = nflag? tsize:round(tsize, FW);
if (zflag)
filhdr.a_text = round(tsize, PAGRND);
filhdr.a_data = dsize;
if (zflag)
filhdr.a_data = round(dsize, PAGRND);
bss = bsize - (filhdr.a_data - dsize);
if (bss < 0)
bss = 0;
filhdr.a_bss = bss;
filhdr.a_trsize = trsize;
filhdr.a_drsize = drsize;
filhdr.a_syms = sflag? 0: (ssize + (sizeof cursym)*(nextsym-symtab));
if (entrypt) {
if (entrypt->stype!=EXTERN+TEXT)
error(0, "Entry point not in text");
else
filhdr.a_entry = entrypt->svalue;
} else
filhdr.a_entry=0;
filhdr.a_trsize = (rflag ? trsize:0);
filhdr.a_drsize = (rflag ? drsize:0);
writel(&filhdr,8,tout);
if (zflag)
fseek(tout, PAGSIZ, 0);
}
FILE *
tcreat(namep, name)
char **namep, *name;
{
register FILE *fp;
register char *tnm;
tnm = mktemp(name);
if ((fp = fopen(tnm, "w")) == NULL)
error(1, "Cannot create temp file");
chmod(tnm, 0600);
*namep = tnm;
return(fp);
}
load2arg(acp)
char *acp;
{
register char *cp;
register LIBLIST *lp;
cp = acp;
if (getfile(cp) == 0) {
while (*cp)
cp++;
while (cp >= acp && *--cp != '/');
mkfsym(++cp);
load2(0L);
} else { /* scan archive members referenced */
for (lp = libp; lp->loc != -1; lp++) {
dseek(&text, lp->loc, (long)sizeof(archdr));
mget((short *)&archdr, sizeof(archdr), &text);
mkfsym(archdr.ar_name);
load2(lp->loc + (long)sizeof(archdr));
}
libp = ++lp;
}
close(infil);
}
load2(loc)
long loc;
{
register SYMBOL *sp;
register LOCAL *lp;
register int symno;
int type;
readhdr(loc);
ctrel = torigin;
cdrel += dorigin;
cbrel += borigin;
/*
* Reread the symbol table, recording the numbering
* of symbols for fixing external references.
*/
lp = local;
symno = -1;
loc += sizeof(filhdr);
dseek(&text, loc+filhdr.a_text+filhdr.a_data+
filhdr.a_trsize+filhdr.a_drsize, filhdr.a_syms);
while (text.size > 0) {
symno++;
symget(&cursym, &text);
symreloc();
type = cursym.stype;
if ((type&EXTERN) == 0) {
if (!sflag&&!xflag&&
(!Xflag||cursym.sname[0]!='L'||type&STABTYPS))
symwrite(&cursym, 1, sout);
continue;
}
if ((sp = *lookup()) == 0)
error(1, "internal error: symbol not found");
if (cursym.stype == EXTERN+UNDEF) {
if (lp >= local+NSYMPR)
error(1, "Local symbol overflow");
lp->locindex = symno;
lp++->locsymbol = sp;
continue;
}
if(cursym.stype & STABTYPS) continue;
if (cursym.stype!=sp->stype || cursym.svalue!=sp->svalue) {
printf("%.8s: ", cursym.sname);
error(0, "Multiply defined");
}
}
dseek(&text, loc, filhdr.a_text);
dseek(&reloc, loc+filhdr.a_text+filhdr.a_data, filhdr.a_trsize);
load2td(lp, ctrel, tout, trout);
dseek(&text, loc+filhdr.a_text, filhdr.a_data);
dseek(&reloc, loc+filhdr.a_text+filhdr.a_data+filhdr.a_trsize, filhdr.a_drsize);
load2td(lp, cdrel, dout, drout);
while (filhdr.a_data&FW) {
putc(0, dout); filhdr.a_data++;
}
torigin += filhdr.a_text;
dorigin += filhdr.a_data;
borigin += filhdr.a_bss;
cdorel += filhdr.a_data;
cborel += filhdr.a_bss;
}
load2td(lp, creloc, b1, b2)
LOCAL *lp;
long creloc;
FILE *b1, *b2;
{
register r1;
register char r2;
register long t;
register SYMBOL *sp;
long tw,u,l;
for (;;) {
if (reloc.size==0) {while (text.size) putc(get(&text),b1); break;}
t=getl(&reloc); /* position of relocatable stuff */
if (rflag) putl(t+creloc,b2); /* remember for subsequent link editing */
while (text.pos<t) putc(get(&text),b1); /* advance to proper position */
r1=get3(&reloc); /* kind of relocation */
r2 = getb(&reloc);
switch (r2&06) {/* read raw datum according to its length */
case LEN1: tw=get(&text); break;
case LEN2: tw=gets(&text); break;
case LEN4: tw=getl(&text); break;
}
if (r2&REXT) {
sp=lookloc(lp,r1); /* find the symbol */
if (sp->stype==EXTERN+UNDEF) { /* still undefined */
r2=(r2&(REFMASK+REXT+ROFF));
r1 = nsym+(sp-symtab); /* new reloc */
}
else {
if (sp->stype==EXTERN+DATA && r2&ROFF) {
r1=RDATAO;
r2&=REFMASK;
}
else if (sp->stype==EXTERN+BSS && r2&ROFF) {
r1=RBSSO;
r2&=REFMASK;
}
else if (sp->stype==EXTERN+ABS && r2&ROFF) {
r1=RABSO;
r2&=REFMASK;
}
else if (sp->stype==EXTERN+TEXT && r2&ROFF) {
r1=RTEXTO;
r2&=REFMASK;
}
else {if (r2&ROFF) {if (rflag) {error(0,"!-r; see JFR"); rflag=0;}}
else tw += database;
r1=sp->stype&TYPE;
r2&=REFMASK;
}
tw += sp->svalue - database;
}
} else switch (r1&TYMASK) {
case RTEXT: tw += ctrel; break;
case RTEXTO:tw += round(filhdr.a_text,PAGRND)+ctrel-database; break;
case RDATA: tw += cdrel; break;
case RDATAO:tw += cdorel; break;
case RBSS: tw += cbrel; break;
case RBSSO: tw += cborel-filhdr.a_data; break;
case RABSO: tw += round(filhdr.a_text,PAGRND)-database; break;
}
if (rflag) { /* remember for subsequent link editing */
put3(r1,b2);
putb(r2,b2);
}
if (r2&PCREL) tw -= creloc; /* assembler already subtracted text.pos */
switch (r2&06) {/* output relocated datum according to its length */
case LEN1: l= -128; u=127; putc((char)tw,b1); break;
case LEN2: l= -32768; u=32767; puts((short)tw,b1); break;
case LEN4: l=0x80000000; u=0x7FFFFFFF; putl(tw,b1); break;
}
if (tw<l || u<tw) error(0,"Displacement overflow");
}
}
finishout()
{
if (!nflag)
while (tsize&FW) {
putc(0, tout); tsize++;
}
if (zflag) {
while (tsize&PAGRND) {
putc(0, tout); tsize++;
}
while (dsize&PAGRND) {
putc(0, dout); dsize++;
}
}
fclose(dout);
copy(doutn);
if (rflag) {
fclose(trout);
copy(troutn);
fclose(drout);
copy(droutn);
}
if (sflag==0) {
if (xflag==0) {
fclose(sout);
copy(soutn);
}
symwrite(symtab, nextsym-symtab, tout);
}
fclose(tout);
if (!ofilfnd) {
unlink("a.out");
link("l.out", "a.out");
ofilename = "a.out";
}
delarg = errlev;
delexit();
}
copy(np)
char *np;
{
register c;
register FILE *fp;
if ((fp = fopen(np, "r")) == NULL)
error(1, "cannot recopy output");
while ((c = getc(fp)) != EOF)
putc(c, tout);
fclose(fp);
}
mkfsym(s)
char *s;
{
if (sflag || xflag)
return;
cp8c(s, cursym.sname);
cursym.stype = TEXT;
cursym.svalue = torigin;
symwrite(&cursym, 1, sout);
}
mget(loc, n, sp)
register STREAM *sp;
register char *loc;
{
register char *p;
if ((sp->nibuf -= n) >= 0) {
if ((sp->size -= n) > 0) {
p = sp->ptr;
sp->pos += n;
do
*loc++ = *p++;
while (--n);
sp->ptr = p;
return;
} else
sp->size += n;
}
sp->nibuf += n;
do {
*loc++ = get(sp);
} while (--n);
}
short
gets(sp) STREAM *sp; {
short t; mget(&t,2,sp); return(t);
}
char
getb(sp) STREAM *sp; {
char t; mget(&t,1,sp); return(t);
}
long
get3(sp) STREAM *sp; {
long t; t=0; mget(&t,3,sp); return(t);
}
long
getl(sp) STREAM *sp; {
long t; mget(&t,4,sp);
#ifndef vax
fixl(&t);
#endif
return(t);
}
symget(sp,f) SYMBOL *sp; STREAM *f; {
mget(sp,sizeof(*sp),f);
#ifndef vax
fixl(&sp->svalue);
#endif
}
dseek(sp, loc, s)
register STREAM *sp;
long loc, s;
{
register PAGE *p;
register b, o;
int n;
b = loc>>BSHIFT;
o = loc&BMASK;
if (o&01)
error(1, "loader error; odd offset");
--sp->pno->nuser;
if ((p = &page[0])->bno!=b && (p = &page[1])->bno!=b)
if (p->nuser==0 || (p = &page[0])->nuser==0) {
if (page[0].nuser==0 && page[1].nuser==0)
if (page[0].bno < page[1].bno)
p = &page[0];
p->bno = b;
lseek(infil, loc & ~(long)BMASK, 0);
if ((n = read(infil, p->buff, sizeof(p->buff))) < 0)
n = 0;
p->nibuf = n;
} else
error(1, "No pages");
++p->nuser;
sp->bno = b;
sp->pno = p;
if (s != -1) {sp->size = s; sp->pos = 0;}
sp->ptr = (short *)(p->buff + o);
if ((sp->nibuf = p->nibuf-o) <= 0)
sp->size = 0;
}
char
get(asp)
STREAM *asp;
{
register STREAM *sp;
sp = asp;
if ((sp->nibuf -= sizeof(char)) < 0) {
dseek(sp, ((long)(sp->bno+1)<<BSHIFT), (long)-1);
sp->nibuf -= sizeof(char);
}
if ((sp->size -= sizeof(char)) <= 0) {
if (sp->size < 0)
error(1, premeof);
++fpage.nuser;
--sp->pno->nuser;
sp->pno = &fpage;
}
sp->pos += sizeof(char);
return(*sp->ptr++);
}
getfile(acp)
STRING acp;
{
register STRING cp;
register int c;
int arcmag;
cp = acp;
infil = -1;
archdr.ar_name[0] = '\0';
filname = cp;
if (cp[0]=='-' && cp[1]=='l') {
char *locfilname = "/usr/local/lib/libxxxxxxxxxxxxxxx";
if(cp[2] == '\0')
cp = "-la";
filname = "/usr/lib/libxxxxxxxxxxxxxxx";
for(c=0; cp[c+2]; c++) {
filname[c+12] = cp[c+2];
locfilname[c+18] = cp[c+2];
}
filname[c+12] = locfilname[c+18] = '.';
filname[c+13] = locfilname[c+19] = 'a';
filname[c+14] = locfilname[c+20] = '\0';
if ((infil = open(filname+4, 0)) >= 0) {
filname += 4;
} else if ((infil = open(filname, 0)) < 0) {
filname = locfilname;
}
}
if (infil == -1 && (infil = open(filname, 0)) < 0)
error(1, "cannot open");
page[0].bno = page[1].bno = -1;
page[0].nuser = page[1].nuser = 0;
text.pno = reloc.pno = &fpage;
fpage.nuser = 2;
dseek(&text, 0L, (long)sizeof(int));
if (text.size <= 0)
error(1, premeof);
mget(&arcmag, sizeof(arcmag), &text);
return(arcmag==ARMAG);
}
SYMBOL **lookup()
{
int i;
BOOL clash;
register SYMBOL **hp;
register char *cp, *cp1;
i = 0;
for (cp = cursym.sname; cp < &cursym.sname[8];)
i = (i<<1) + *cp++;
for (hp = &hshtab[(i&077777)%NSYM+2]; *hp!=0;) {
cp1 = (*hp)->sname;
clash=FALSE;
for (cp = cursym.sname; cp < &cursym.sname[8];)
if (*cp++ != *cp1++) {
clash=TRUE;
break;
}
if (clash) {
if (++hp >= &hshtab[NSYM+2])
hp = hshtab;
} else
break;
}
return(hp);
}
SYMBOL **slookup(s)
char *s;
{
cp8c(s, cursym.sname);
cursym.stype = EXTERN+UNDEF;
cursym.svalue = 0;
return(lookup());
}
enter(hp)
register SYMBOL **hp;
{
register SYMBOL *sp;
if (*hp==0) {
if ((nextsym-symtab)>=NSYM)
error(1, "Symbol table overflow");
if ((nextsym-symtab)>=nsym) {
if (-1==sbrk(NSYM/5 * sizeof(*symtab))) error(1,"Memory overflow");
nsym += NSYM/5;
}
*hp = lastsym = sp = nextsym++;
cp8c(cursym.sname, sp->sname);
sp->stype = cursym.stype;
sp->symhash = hp-hshtab;
sp->svalue = cursym.svalue;
return(1);
} else {
lastsym = *hp;
return(0);
}
}
symreloc()
{
switch (cursym.stype & 017) {
case TEXT:
case EXTERN+TEXT:
cursym.svalue += ctrel;
return;
case DATA:
case EXTERN+DATA:
cursym.svalue += cdrel;
return;
case BSS:
case EXTERN+BSS:
cursym.svalue += cbrel;
return;
case EXTERN+UNDEF:
return;
}
if (cursym.stype&EXTERN)
cursym.stype = EXTERN+ABS;
}
error(n, s)
char *s;
{
if (errlev==0)
printf("ld:");
if (filname) {
printf("%s", filname);
if (archdr.ar_name[0])
printf("(%.14s)", archdr.ar_name);
printf(": ");
}
printf("%s\n", s);
if (n)
delexit();
errlev = 2;
}
SYMBOL *
lookloc(lp, r)
register LOCAL *lp;
{
register LOCAL *clp;
register sn;
sn = r;
for (clp = local; clp<lp; clp++)
if (clp->locindex == sn)
return(clp->locsymbol);
error(1, "Local symbol botch");
}
readhdr(loc)
long loc;
{
long *p; int i;
dseek(&text, loc, (long)sizeof(filhdr));
mget((short *)&filhdr, sizeof(filhdr), &text);
#ifndef vax
for (p= &filhdr,i=8;--i>=0;) fixl(p++);
#endif
if (filhdr.a_magic!=A_MAGIC1 && filhdr.a_magic!=A_MAGIC2 &&
filhdr.a_magic!=A_MAGIC3 && filhdr.a_magic!=A_MAGIC4)
error(1,"Bad magic number");
if (filhdr.a_text&01 || filhdr.a_data&01) {
printf("tsize=%X dsize=%X\n",filhdr.a_text,filhdr.a_data);
error(1, "Text/data size odd");
}
filhdr.a_bss = round(filhdr.a_bss, FW);
if (filhdr.a_magic == NMAGIC) {
cdrel = -round(filhdr.a_text, PAGRND);
cbrel = cdrel - filhdr.a_data;
} else if (filhdr.a_magic == OMAGIC) {
cdrel = -filhdr.a_text;
cbrel = cdrel - filhdr.a_data;
} else
error(1, "Bad format");
}
cp8c(from, to)
char *from, *to;
{
register char *f, *t, *te;
f = from;
t = to;
te = t+8;
while ((*t++ = *f++) && t<te);
while (t<te)
*t++ = 0;
}
eq(s1, s2)
STRING s1;
STRING s2;
{
while (*s1==*s2++)
if ((*s1++)==0)
return(TRUE);
return(FALSE);
}
long
round(v, r)
long v;
unsigned r;
{
v += r;
v &= ~(long)r;
return(v);
}
puts(w, f)
FILE *f; short w; {
fwrite(&w,sizeof(short),1,f);
}
putb(w, f)
FILE *f; char w; {
fwrite(&w,sizeof(char),1,f);
}
put3(w, f)
FILE *f; long w; {
fwrite(&w,3,1,f);
}
putl(w, f)
FILE *f; long w; {
#ifndef vax
fixl(&w);
#endif
fwrite(&w,sizeof(long),1,f);
}
Continuous source code history from original PDP-7 UNIX to FreeBSD 2, the first fully unencumbered FreeBSD release.