2009-01-06 10:41:38 -07:00
|
|
|
// Inferno utils/8l/obj.c
|
|
|
|
// http://code.google.com/p/inferno-os/source/browse/utils/8l/obj.c
|
|
|
|
//
|
|
|
|
// Copyright © 1994-1999 Lucent Technologies Inc. All rights reserved.
|
|
|
|
// Portions Copyright © 1995-1997 C H Forsyth (forsyth@terzarima.net)
|
|
|
|
// Portions Copyright © 1997-1999 Vita Nuova Limited
|
|
|
|
// Portions Copyright © 2000-2007 Vita Nuova Holdings Limited (www.vitanuova.com)
|
|
|
|
// Portions Copyright © 2004,2006 Bruce Ellis
|
|
|
|
// Portions Copyright © 2005-2007 C H Forsyth (forsyth@terzarima.net)
|
|
|
|
// Revisions Copyright © 2000-2007 Lucent Technologies Inc. and others
|
|
|
|
// Portions Copyright © 2009 The Go Authors. All rights reserved.
|
|
|
|
//
|
|
|
|
// Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
|
|
// of this software and associated documentation files (the "Software"), to deal
|
|
|
|
// in the Software without restriction, including without limitation the rights
|
|
|
|
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
|
|
// copies of the Software, and to permit persons to whom the Software is
|
|
|
|
// furnished to do so, subject to the following conditions:
|
|
|
|
//
|
|
|
|
// The above copyright notice and this permission notice shall be included in
|
|
|
|
// all copies or substantial portions of the Software.
|
|
|
|
//
|
|
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
|
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
|
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
|
|
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
|
|
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
|
|
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
|
|
// THE SOFTWARE.
|
|
|
|
|
|
|
|
#define EXTERN
|
|
|
|
#include "l.h"
|
2009-09-24 13:53:35 -06:00
|
|
|
#include "../ld/elf.h"
|
2009-01-06 10:41:38 -07:00
|
|
|
#include <ar.h>
|
|
|
|
|
|
|
|
#ifndef DEFAULT
|
|
|
|
#define DEFAULT '9'
|
|
|
|
#endif
|
|
|
|
|
|
|
|
char *noname = "<none>";
|
|
|
|
char symname[] = SYMDEF;
|
|
|
|
char thechar = '8';
|
|
|
|
char *thestring = "386";
|
|
|
|
|
|
|
|
/*
|
|
|
|
* -H0 -T0x40004C -D0x10000000 is garbage unix
|
|
|
|
* -H1 -T0xd0 -R4 is unix coff
|
|
|
|
* -H2 -T4128 -R4096 is plan9 format
|
|
|
|
* -H3 -Tx -Rx is MS-DOS .COM
|
|
|
|
* -H4 -Tx -Rx is fake MS-DOS .EXE
|
|
|
|
*/
|
|
|
|
|
|
|
|
static int
|
|
|
|
isobjfile(char *f)
|
|
|
|
{
|
|
|
|
int n, v;
|
|
|
|
Biobuf *b;
|
|
|
|
char buf1[5], buf2[SARMAG];
|
|
|
|
|
|
|
|
b = Bopen(f, OREAD);
|
|
|
|
if(b == nil)
|
|
|
|
return 0;
|
|
|
|
n = Bread(b, buf1, 5);
|
|
|
|
if(n == 5 && (buf1[2] == 1 && buf1[3] == '<' || buf1[3] == 1 && buf1[4] == '<'))
|
|
|
|
v = 1; /* good enough for our purposes */
|
|
|
|
else{
|
|
|
|
Bseek(b, 0, 0);
|
|
|
|
n = Bread(b, buf2, SARMAG);
|
|
|
|
v = n == SARMAG && strncmp(buf2, ARMAG, SARMAG) == 0;
|
|
|
|
}
|
|
|
|
Bterm(b);
|
|
|
|
return v;
|
|
|
|
}
|
|
|
|
|
2009-06-02 23:33:21 -06:00
|
|
|
void
|
|
|
|
usage(void)
|
|
|
|
{
|
|
|
|
fprint(2, "usage: 8l [-options] [-E entry] [-H head] [-L dir] [-T text] [-R rnd] [-o out] files...\n");
|
|
|
|
exits("usage");
|
|
|
|
}
|
|
|
|
|
2009-01-06 10:41:38 -07:00
|
|
|
void
|
|
|
|
main(int argc, char *argv[])
|
|
|
|
{
|
|
|
|
int i, c;
|
|
|
|
char *a;
|
|
|
|
|
|
|
|
Binit(&bso, 1, OWRITE);
|
|
|
|
cout = -1;
|
|
|
|
listinit();
|
|
|
|
memset(debug, 0, sizeof(debug));
|
|
|
|
nerrors = 0;
|
|
|
|
outfile = "8.out";
|
|
|
|
HEADTYPE = -1;
|
|
|
|
INITTEXT = -1;
|
|
|
|
INITDAT = -1;
|
|
|
|
INITRND = -1;
|
|
|
|
INITENTRY = 0;
|
|
|
|
ARGBEGIN {
|
|
|
|
default:
|
|
|
|
c = ARGC();
|
|
|
|
if(c >= 0 && c < sizeof(debug))
|
|
|
|
debug[c]++;
|
|
|
|
break;
|
|
|
|
case 'o': /* output to (next arg) */
|
2009-06-02 23:33:21 -06:00
|
|
|
outfile = EARGF(usage());
|
2009-01-06 10:41:38 -07:00
|
|
|
break;
|
|
|
|
case 'E':
|
2009-06-02 23:33:21 -06:00
|
|
|
INITENTRY = EARGF(usage());
|
2009-01-06 10:41:38 -07:00
|
|
|
break;
|
|
|
|
case 'H':
|
2009-06-02 23:33:21 -06:00
|
|
|
HEADTYPE = atolwhex(EARGF(usage()));
|
|
|
|
break;
|
|
|
|
case 'L':
|
|
|
|
LIBDIR = EARGF(usage());
|
2009-01-06 10:41:38 -07:00
|
|
|
break;
|
|
|
|
case 'T':
|
2009-06-02 23:33:21 -06:00
|
|
|
INITTEXT = atolwhex(EARGF(usage()));
|
2009-01-06 10:41:38 -07:00
|
|
|
break;
|
|
|
|
case 'D':
|
2009-06-02 23:33:21 -06:00
|
|
|
INITDAT = atolwhex(EARGF(usage()));
|
2009-01-06 10:41:38 -07:00
|
|
|
break;
|
|
|
|
case 'R':
|
2009-06-02 23:33:21 -06:00
|
|
|
INITRND = atolwhex(EARGF(usage()));
|
|
|
|
break;
|
2009-01-06 10:41:38 -07:00
|
|
|
break;
|
|
|
|
case 'x': /* produce export table */
|
|
|
|
doexp = 1;
|
|
|
|
if(argv[1] != nil && argv[1][0] != '-' && !isobjfile(argv[1]))
|
|
|
|
readundefs(ARGF(), SEXPORT);
|
|
|
|
break;
|
|
|
|
case 'u': /* produce dynamically loadable module */
|
|
|
|
dlm = 1;
|
|
|
|
debug['l']++;
|
|
|
|
if(argv[1] != nil && argv[1][0] != '-' && !isobjfile(argv[1]))
|
|
|
|
readundefs(ARGF(), SIMPORT);
|
|
|
|
break;
|
|
|
|
} ARGEND
|
|
|
|
USED(argc);
|
2009-06-02 23:33:21 -06:00
|
|
|
if(*argv == 0)
|
|
|
|
usage();
|
2009-03-20 15:22:59 -06:00
|
|
|
|
|
|
|
whatsys(); // get goroot, goarch, goos
|
|
|
|
if(strcmp(goarch, thestring) != 0)
|
|
|
|
print("goarch is not known: %s\n", goarch);
|
|
|
|
|
2009-01-06 10:41:38 -07:00
|
|
|
if(HEADTYPE == -1) {
|
2009-03-20 15:22:59 -06:00
|
|
|
HEADTYPE = 2;
|
|
|
|
if(strcmp(goos, "linux") == 0)
|
|
|
|
HEADTYPE = 7;
|
|
|
|
else
|
|
|
|
if(strcmp(goos, "darwin") == 0)
|
|
|
|
HEADTYPE = 6;
|
2009-09-18 19:57:15 -06:00
|
|
|
else
|
|
|
|
if(strcmp(goos, "nacl") == 0)
|
|
|
|
HEADTYPE = 8;
|
2009-03-20 15:22:59 -06:00
|
|
|
else
|
|
|
|
print("goos is not known: %sn", goos);
|
2009-01-06 10:41:38 -07:00
|
|
|
}
|
2009-03-20 15:22:59 -06:00
|
|
|
|
2009-01-06 10:41:38 -07:00
|
|
|
switch(HEADTYPE) {
|
|
|
|
default:
|
|
|
|
diag("unknown -H option");
|
|
|
|
errorexit();
|
|
|
|
|
|
|
|
case 0: /* this is garbage */
|
|
|
|
HEADR = 20L+56L;
|
|
|
|
if(INITTEXT == -1)
|
|
|
|
INITTEXT = 0x40004CL;
|
|
|
|
if(INITDAT == -1)
|
|
|
|
INITDAT = 0x10000000L;
|
|
|
|
if(INITRND == -1)
|
|
|
|
INITRND = 0;
|
|
|
|
break;
|
|
|
|
case 1: /* is unix coff */
|
|
|
|
HEADR = 0xd0L;
|
|
|
|
if(INITTEXT == -1)
|
|
|
|
INITTEXT = 0xd0;
|
|
|
|
if(INITDAT == -1)
|
|
|
|
INITDAT = 0x400000;
|
|
|
|
if(INITRND == -1)
|
|
|
|
INITRND = 0;
|
|
|
|
break;
|
|
|
|
case 2: /* plan 9 */
|
|
|
|
HEADR = 32L;
|
|
|
|
if(INITTEXT == -1)
|
|
|
|
INITTEXT = 4096+32;
|
|
|
|
if(INITDAT == -1)
|
|
|
|
INITDAT = 0;
|
|
|
|
if(INITRND == -1)
|
|
|
|
INITRND = 4096;
|
|
|
|
break;
|
|
|
|
case 3: /* MS-DOS .COM */
|
|
|
|
HEADR = 0;
|
|
|
|
if(INITTEXT == -1)
|
|
|
|
INITTEXT = 0x0100;
|
|
|
|
if(INITDAT == -1)
|
|
|
|
INITDAT = 0;
|
|
|
|
if(INITRND == -1)
|
|
|
|
INITRND = 4;
|
|
|
|
break;
|
|
|
|
case 4: /* fake MS-DOS .EXE */
|
|
|
|
HEADR = 0x200;
|
|
|
|
if(INITTEXT == -1)
|
|
|
|
INITTEXT = 0x0100;
|
|
|
|
if(INITDAT == -1)
|
|
|
|
INITDAT = 0;
|
|
|
|
if(INITRND == -1)
|
|
|
|
INITRND = 4;
|
|
|
|
HEADR += (INITTEXT & 0xFFFF);
|
|
|
|
if(debug['v'])
|
|
|
|
Bprint(&bso, "HEADR = 0x%ld\n", HEADR);
|
|
|
|
break;
|
2009-03-20 15:22:59 -06:00
|
|
|
case 6: /* apple MACH */
|
|
|
|
HEADR = machheadr();
|
|
|
|
if(INITTEXT == -1)
|
|
|
|
INITTEXT = 4096+HEADR;
|
|
|
|
if(INITDAT == -1)
|
|
|
|
INITDAT = 0;
|
|
|
|
if(INITRND == -1)
|
|
|
|
INITRND = 4096;
|
|
|
|
break;
|
|
|
|
case 7: /* elf32 executable */
|
2009-09-24 13:53:35 -06:00
|
|
|
elfinit();
|
|
|
|
HEADR = ELFRESERVE;
|
2009-03-20 15:22:59 -06:00
|
|
|
if(INITTEXT == -1)
|
|
|
|
INITTEXT = 0x08048000+HEADR;
|
|
|
|
if(INITDAT == -1)
|
|
|
|
INITDAT = 0;
|
|
|
|
if(INITRND == -1)
|
|
|
|
INITRND = 4096;
|
|
|
|
break;
|
2009-09-18 19:57:15 -06:00
|
|
|
case 8: /* native client elf32 executable */
|
2009-09-24 13:53:35 -06:00
|
|
|
elfinit();
|
2009-09-18 19:57:15 -06:00
|
|
|
HEADR = 4096;
|
|
|
|
if(INITTEXT == -1)
|
|
|
|
INITTEXT = 0x20000;
|
|
|
|
if(INITDAT == -1)
|
|
|
|
INITDAT = 0;
|
|
|
|
if(INITRND == -1)
|
|
|
|
INITRND = 4096;
|
|
|
|
break;
|
2009-01-06 10:41:38 -07:00
|
|
|
}
|
|
|
|
if(INITDAT != 0 && INITRND != 0)
|
|
|
|
print("warning: -D0x%lux is ignored because of -R0x%lux\n",
|
|
|
|
INITDAT, INITRND);
|
|
|
|
if(debug['v'])
|
|
|
|
Bprint(&bso, "HEADER = -H0x%ld -T0x%lux -D0x%lux -R0x%lux\n",
|
|
|
|
HEADTYPE, INITTEXT, INITDAT, INITRND);
|
|
|
|
Bflush(&bso);
|
|
|
|
for(i=1; optab[i].as; i++)
|
|
|
|
if(i != optab[i].as) {
|
|
|
|
diag("phase error in optab: %d", i);
|
|
|
|
errorexit();
|
|
|
|
}
|
|
|
|
maxop = i;
|
|
|
|
|
|
|
|
for(i=0; i<Ymax; i++)
|
|
|
|
ycover[i*Ymax + i] = 1;
|
|
|
|
|
|
|
|
ycover[Yi0*Ymax + Yi8] = 1;
|
|
|
|
ycover[Yi1*Ymax + Yi8] = 1;
|
|
|
|
|
|
|
|
ycover[Yi0*Ymax + Yi32] = 1;
|
|
|
|
ycover[Yi1*Ymax + Yi32] = 1;
|
|
|
|
ycover[Yi8*Ymax + Yi32] = 1;
|
|
|
|
|
|
|
|
ycover[Yal*Ymax + Yrb] = 1;
|
|
|
|
ycover[Ycl*Ymax + Yrb] = 1;
|
|
|
|
ycover[Yax*Ymax + Yrb] = 1;
|
|
|
|
ycover[Ycx*Ymax + Yrb] = 1;
|
|
|
|
ycover[Yrx*Ymax + Yrb] = 1;
|
|
|
|
|
|
|
|
ycover[Yax*Ymax + Yrx] = 1;
|
|
|
|
ycover[Ycx*Ymax + Yrx] = 1;
|
|
|
|
|
|
|
|
ycover[Yax*Ymax + Yrl] = 1;
|
|
|
|
ycover[Ycx*Ymax + Yrl] = 1;
|
|
|
|
ycover[Yrx*Ymax + Yrl] = 1;
|
|
|
|
|
|
|
|
ycover[Yf0*Ymax + Yrf] = 1;
|
|
|
|
|
|
|
|
ycover[Yal*Ymax + Ymb] = 1;
|
|
|
|
ycover[Ycl*Ymax + Ymb] = 1;
|
|
|
|
ycover[Yax*Ymax + Ymb] = 1;
|
|
|
|
ycover[Ycx*Ymax + Ymb] = 1;
|
|
|
|
ycover[Yrx*Ymax + Ymb] = 1;
|
|
|
|
ycover[Yrb*Ymax + Ymb] = 1;
|
|
|
|
ycover[Ym*Ymax + Ymb] = 1;
|
|
|
|
|
|
|
|
ycover[Yax*Ymax + Yml] = 1;
|
|
|
|
ycover[Ycx*Ymax + Yml] = 1;
|
|
|
|
ycover[Yrx*Ymax + Yml] = 1;
|
|
|
|
ycover[Yrl*Ymax + Yml] = 1;
|
|
|
|
ycover[Ym*Ymax + Yml] = 1;
|
|
|
|
|
|
|
|
for(i=0; i<D_NONE; i++) {
|
|
|
|
reg[i] = -1;
|
|
|
|
if(i >= D_AL && i <= D_BH)
|
|
|
|
reg[i] = (i-D_AL) & 7;
|
|
|
|
if(i >= D_AX && i <= D_DI)
|
|
|
|
reg[i] = (i-D_AX) & 7;
|
|
|
|
if(i >= D_F0 && i <= D_F0+7)
|
|
|
|
reg[i] = (i-D_F0) & 7;
|
|
|
|
}
|
|
|
|
|
|
|
|
zprg.link = P;
|
|
|
|
zprg.pcond = P;
|
|
|
|
zprg.back = 2;
|
|
|
|
zprg.as = AGOK;
|
|
|
|
zprg.from.type = D_NONE;
|
|
|
|
zprg.from.index = D_NONE;
|
|
|
|
zprg.from.scale = 1;
|
|
|
|
zprg.to = zprg.from;
|
|
|
|
|
|
|
|
pcstr = "%.6lux ";
|
|
|
|
nuxiinit();
|
|
|
|
histgen = 0;
|
|
|
|
textp = P;
|
|
|
|
datap = P;
|
|
|
|
edatap = P;
|
|
|
|
pc = 0;
|
|
|
|
dtype = 4;
|
2009-08-07 16:22:09 -06:00
|
|
|
unlink(outfile);
|
2009-01-06 10:41:38 -07:00
|
|
|
cout = create(outfile, 1, 0775);
|
|
|
|
if(cout < 0) {
|
|
|
|
diag("cannot create %s", outfile);
|
|
|
|
errorexit();
|
|
|
|
}
|
|
|
|
version = 0;
|
|
|
|
cbp = buf.cbuf;
|
|
|
|
cbc = sizeof(buf.cbuf);
|
|
|
|
firstp = prg();
|
|
|
|
lastp = firstp;
|
|
|
|
|
2009-03-20 15:22:59 -06:00
|
|
|
if(INITENTRY == nil) {
|
|
|
|
INITENTRY = mal(strlen(goarch)+strlen(goos)+10);
|
|
|
|
sprint(INITENTRY, "_rt0_%s_%s", goarch, goos);
|
|
|
|
}
|
|
|
|
lookup(INITENTRY, 0)->type = SXREF;
|
|
|
|
|
2009-01-06 10:41:38 -07:00
|
|
|
while(*argv)
|
|
|
|
objfile(*argv++);
|
2009-03-20 15:22:59 -06:00
|
|
|
|
|
|
|
if(!debug['l']) {
|
2009-01-06 10:41:38 -07:00
|
|
|
loadlib();
|
2009-03-20 15:22:59 -06:00
|
|
|
a = mal(strlen(goroot)+strlen(goarch)+strlen(goos)+20);
|
2009-06-06 23:04:50 -06:00
|
|
|
sprint(a, "%s/pkg/%s_%s/runtime.a", goroot, goos, goarch);
|
2009-03-20 15:22:59 -06:00
|
|
|
objfile(a);
|
|
|
|
}
|
2009-03-31 01:20:07 -06:00
|
|
|
deadcode();
|
|
|
|
|
2009-01-06 10:41:38 -07:00
|
|
|
firstp = firstp->link;
|
|
|
|
if(firstp == P)
|
|
|
|
errorexit();
|
|
|
|
if(doexp || dlm){
|
|
|
|
EXPTAB = "_exporttab";
|
|
|
|
zerosig(EXPTAB);
|
|
|
|
zerosig("etext");
|
|
|
|
zerosig("edata");
|
|
|
|
zerosig("end");
|
|
|
|
if(dlm){
|
|
|
|
import();
|
|
|
|
HEADTYPE = 2;
|
|
|
|
INITTEXT = INITDAT = 0;
|
|
|
|
INITRND = 8;
|
|
|
|
INITENTRY = EXPTAB;
|
|
|
|
}
|
|
|
|
export();
|
|
|
|
}
|
|
|
|
patch();
|
|
|
|
follow();
|
2009-09-24 13:53:35 -06:00
|
|
|
doelf();
|
2009-01-06 10:41:38 -07:00
|
|
|
dodata();
|
|
|
|
dostkoff();
|
|
|
|
if(debug['p'])
|
|
|
|
if(debug['1'])
|
|
|
|
doprof1();
|
|
|
|
else
|
|
|
|
doprof2();
|
|
|
|
span();
|
|
|
|
doinit();
|
|
|
|
asmb();
|
|
|
|
undef();
|
|
|
|
if(debug['v']) {
|
|
|
|
Bprint(&bso, "%5.2f cpu time\n", cputime());
|
|
|
|
Bprint(&bso, "%ld symbols\n", nsymbol);
|
|
|
|
Bprint(&bso, "%ld memory used\n", thunk);
|
|
|
|
Bprint(&bso, "%d sizeof adr\n", sizeof(Adr));
|
|
|
|
Bprint(&bso, "%d sizeof prog\n", sizeof(Prog));
|
|
|
|
}
|
|
|
|
Bflush(&bso);
|
|
|
|
|
|
|
|
errorexit();
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
loadlib(void)
|
|
|
|
{
|
|
|
|
int i;
|
2009-01-06 12:34:02 -07:00
|
|
|
int32 h;
|
2009-01-06 10:41:38 -07:00
|
|
|
Sym *s;
|
|
|
|
|
|
|
|
loop:
|
|
|
|
xrefresolv = 0;
|
|
|
|
for(i=0; i<libraryp; i++) {
|
|
|
|
if(debug['v'])
|
|
|
|
Bprint(&bso, "%5.2f autolib: %s (from %s)\n", cputime(), library[i], libraryobj[i]);
|
|
|
|
objfile(library[i]);
|
|
|
|
}
|
|
|
|
if(xrefresolv)
|
|
|
|
for(h=0; h<nelem(hash); h++)
|
|
|
|
for(s = hash[h]; s != S; s = s->link)
|
|
|
|
if(s->type == SXREF)
|
|
|
|
goto loop;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
errorexit(void)
|
|
|
|
{
|
|
|
|
|
|
|
|
if(nerrors) {
|
|
|
|
if(cout >= 0)
|
|
|
|
remove(outfile);
|
|
|
|
exits("error");
|
|
|
|
}
|
|
|
|
exits(0);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
objfile(char *file)
|
|
|
|
{
|
2009-01-06 12:34:02 -07:00
|
|
|
int32 off, esym, cnt, l;
|
2009-03-20 17:40:00 -06:00
|
|
|
int work;
|
|
|
|
Biobuf *f;
|
2009-01-06 10:41:38 -07:00
|
|
|
Sym *s;
|
|
|
|
char magbuf[SARMAG];
|
|
|
|
char name[100], pname[150];
|
|
|
|
struct ar_hdr arhdr;
|
|
|
|
char *e, *start, *stop;
|
|
|
|
|
2009-03-20 17:40:00 -06:00
|
|
|
if(file[0] == '-' && file[1] == 'l') { // TODO: fix this
|
2009-01-06 10:41:38 -07:00
|
|
|
if(debug['9'])
|
|
|
|
sprint(name, "/%s/lib/lib", thestring);
|
|
|
|
else
|
|
|
|
sprint(name, "/usr/%clib/lib", thechar);
|
|
|
|
strcat(name, file+2);
|
|
|
|
strcat(name, ".a");
|
|
|
|
file = name;
|
|
|
|
}
|
|
|
|
if(debug['v'])
|
|
|
|
Bprint(&bso, "%5.2f ldobj: %s\n", cputime(), file);
|
|
|
|
Bflush(&bso);
|
2009-03-20 17:40:00 -06:00
|
|
|
f = Bopen(file, 0);
|
|
|
|
if(f == nil) {
|
2009-01-06 10:41:38 -07:00
|
|
|
diag("cannot open file: %s", file);
|
|
|
|
errorexit();
|
|
|
|
}
|
2009-03-20 17:40:00 -06:00
|
|
|
l = Bread(f, magbuf, SARMAG);
|
2009-01-06 10:41:38 -07:00
|
|
|
if(l != SARMAG || strncmp(magbuf, ARMAG, SARMAG)){
|
|
|
|
/* load it as a regular file */
|
2009-03-20 17:40:00 -06:00
|
|
|
l = Bseek(f, 0L, 2);
|
|
|
|
Bseek(f, 0L, 0);
|
2009-01-06 10:41:38 -07:00
|
|
|
ldobj(f, l, file);
|
2009-03-20 17:40:00 -06:00
|
|
|
Bterm(f);
|
2009-01-06 10:41:38 -07:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2009-03-20 17:40:00 -06:00
|
|
|
l = Bread(f, &arhdr, SAR_HDR);
|
2009-01-06 10:41:38 -07:00
|
|
|
if(l != SAR_HDR) {
|
|
|
|
diag("%s: short read on archive file symbol header", file);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
if(strncmp(arhdr.name, symname, strlen(symname))) {
|
|
|
|
diag("%s: first entry not symbol header", file);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
esym = SARMAG + SAR_HDR + atolwhex(arhdr.size);
|
|
|
|
off = SARMAG + SAR_HDR;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* just bang the whole symbol file into memory
|
|
|
|
*/
|
2009-03-20 17:40:00 -06:00
|
|
|
Bseek(f, off, 0);
|
2009-01-06 10:41:38 -07:00
|
|
|
cnt = esym - off;
|
2009-08-20 18:33:28 -06:00
|
|
|
start = mal(cnt + 10);
|
2009-03-20 17:40:00 -06:00
|
|
|
cnt = Bread(f, start, cnt);
|
2009-01-06 10:41:38 -07:00
|
|
|
if(cnt <= 0){
|
2009-03-20 17:40:00 -06:00
|
|
|
Bterm(f);
|
2009-01-06 10:41:38 -07:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
stop = &start[cnt];
|
|
|
|
memset(stop, 0, 10);
|
|
|
|
|
|
|
|
work = 1;
|
|
|
|
while(work) {
|
|
|
|
if(debug['v'])
|
|
|
|
Bprint(&bso, "%5.2f library pass: %s\n", cputime(), file);
|
|
|
|
Bflush(&bso);
|
|
|
|
work = 0;
|
|
|
|
for(e = start; e < stop; e = strchr(e+5, 0) + 1) {
|
|
|
|
s = lookup(e+5, 0);
|
|
|
|
if(s->type != SXREF)
|
|
|
|
continue;
|
|
|
|
sprint(pname, "%s(%s)", file, s->name);
|
|
|
|
if(debug['v'])
|
|
|
|
Bprint(&bso, "%5.2f library: %s\n", cputime(), pname);
|
|
|
|
Bflush(&bso);
|
|
|
|
l = e[1] & 0xff;
|
|
|
|
l |= (e[2] & 0xff) << 8;
|
|
|
|
l |= (e[3] & 0xff) << 16;
|
|
|
|
l |= (e[4] & 0xff) << 24;
|
2009-03-20 17:40:00 -06:00
|
|
|
Bseek(f, l, 0);
|
|
|
|
l = Bread(f, &arhdr, SAR_HDR);
|
2009-01-06 10:41:38 -07:00
|
|
|
if(l != SAR_HDR)
|
|
|
|
goto bad;
|
|
|
|
if(strncmp(arhdr.fmag, ARFMAG, sizeof(arhdr.fmag)))
|
|
|
|
goto bad;
|
2009-03-20 17:40:00 -06:00
|
|
|
l = SARNAME;
|
|
|
|
while(l > 0 && arhdr.name[l-1] == ' ')
|
|
|
|
l--;
|
|
|
|
sprint(pname, "%s(%.*s)", file, l, arhdr.name);
|
2009-01-06 10:41:38 -07:00
|
|
|
l = atolwhex(arhdr.size);
|
|
|
|
ldobj(f, l, pname);
|
|
|
|
if(s->type == SXREF) {
|
|
|
|
diag("%s: failed to load: %s", file, s->name);
|
|
|
|
errorexit();
|
|
|
|
}
|
|
|
|
work = 1;
|
|
|
|
xrefresolv = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
|
|
|
|
bad:
|
|
|
|
diag("%s: bad or out of date archive", file);
|
|
|
|
out:
|
2009-03-20 17:40:00 -06:00
|
|
|
Bterm(f);
|
2009-01-06 10:41:38 -07:00
|
|
|
}
|
|
|
|
|
2009-03-20 17:40:00 -06:00
|
|
|
int32
|
|
|
|
Bget4(Biobuf *f)
|
2009-01-06 10:41:38 -07:00
|
|
|
{
|
2009-03-20 17:40:00 -06:00
|
|
|
uchar p[4];
|
|
|
|
|
|
|
|
if(Bread(f, p, 4) != 4)
|
|
|
|
return 0;
|
|
|
|
return p[0] | (p[1] << 8) | (p[2] << 16) | (p[3] << 24);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
zaddr(Biobuf *f, Adr *a, Sym *h[])
|
|
|
|
{
|
|
|
|
int t;
|
2009-01-06 12:34:02 -07:00
|
|
|
int32 l;
|
2009-01-06 10:41:38 -07:00
|
|
|
Sym *s;
|
|
|
|
Auto *u;
|
|
|
|
|
2009-03-20 17:40:00 -06:00
|
|
|
t = Bgetc(f);
|
2009-01-06 10:41:38 -07:00
|
|
|
if(t & T_INDEX) {
|
2009-03-20 17:40:00 -06:00
|
|
|
a->index = Bgetc(f);
|
|
|
|
a->scale = Bgetc(f);
|
2009-01-06 10:41:38 -07:00
|
|
|
} else {
|
|
|
|
a->index = D_NONE;
|
|
|
|
a->scale = 0;
|
|
|
|
}
|
2009-03-20 17:40:00 -06:00
|
|
|
a->type = D_NONE;
|
2009-01-06 10:41:38 -07:00
|
|
|
a->offset = 0;
|
2009-03-20 17:40:00 -06:00
|
|
|
if(t & T_OFFSET)
|
|
|
|
a->offset = Bget4(f);
|
|
|
|
a->offset2 = 0;
|
|
|
|
if(t & T_OFFSET2) {
|
|
|
|
a->offset2 = Bget4(f);
|
|
|
|
a->type = D_CONST2;
|
2009-01-06 10:41:38 -07:00
|
|
|
}
|
|
|
|
a->sym = S;
|
2009-03-20 17:40:00 -06:00
|
|
|
if(t & T_SYM)
|
|
|
|
a->sym = h[Bgetc(f)];
|
2009-01-06 10:41:38 -07:00
|
|
|
if(t & T_FCONST) {
|
2009-03-20 17:40:00 -06:00
|
|
|
a->ieee.l = Bget4(f);
|
|
|
|
a->ieee.h = Bget4(f);
|
2009-01-06 10:41:38 -07:00
|
|
|
a->type = D_FCONST;
|
|
|
|
} else
|
|
|
|
if(t & T_SCONST) {
|
2009-03-20 17:40:00 -06:00
|
|
|
Bread(f, a->scon, NSNAME);
|
2009-01-06 10:41:38 -07:00
|
|
|
a->type = D_SCONST;
|
|
|
|
}
|
2009-03-20 17:40:00 -06:00
|
|
|
if(t & T_TYPE)
|
|
|
|
a->type = Bgetc(f);
|
2009-08-13 16:45:58 -06:00
|
|
|
if(t & T_GOTYPE)
|
|
|
|
a->gotype = h[Bgetc(f)];
|
2009-01-06 10:41:38 -07:00
|
|
|
s = a->sym;
|
|
|
|
if(s == S)
|
2009-03-20 17:40:00 -06:00
|
|
|
return;
|
2009-01-06 10:41:38 -07:00
|
|
|
|
|
|
|
t = a->type;
|
2009-08-13 16:45:58 -06:00
|
|
|
if(t != D_AUTO && t != D_PARAM) {
|
|
|
|
if(a->gotype)
|
|
|
|
s->gotype = a->gotype;
|
2009-03-20 17:40:00 -06:00
|
|
|
return;
|
2009-08-13 16:45:58 -06:00
|
|
|
}
|
2009-01-06 10:41:38 -07:00
|
|
|
l = a->offset;
|
|
|
|
for(u=curauto; u; u=u->link) {
|
|
|
|
if(u->asym == s)
|
|
|
|
if(u->type == t) {
|
|
|
|
if(u->aoffset > l)
|
|
|
|
u->aoffset = l;
|
2009-08-13 16:45:58 -06:00
|
|
|
if(a->gotype)
|
|
|
|
u->gotype = a->gotype;
|
2009-03-20 17:40:00 -06:00
|
|
|
return;
|
2009-01-06 10:41:38 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-03-20 17:40:00 -06:00
|
|
|
u = mal(sizeof(*u));
|
2009-01-06 10:41:38 -07:00
|
|
|
u->link = curauto;
|
|
|
|
curauto = u;
|
|
|
|
u->asym = s;
|
|
|
|
u->aoffset = l;
|
|
|
|
u->type = t;
|
2009-08-13 16:45:58 -06:00
|
|
|
u->gotype = a->gotype;
|
2009-01-06 10:41:38 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2009-03-20 17:40:00 -06:00
|
|
|
addlib(char *src, char *obj)
|
2009-01-06 10:41:38 -07:00
|
|
|
{
|
2009-08-12 15:41:02 -06:00
|
|
|
char name[1024], pname[1024], comp[256], *p;
|
2009-06-02 23:33:21 -06:00
|
|
|
int i, search;
|
2009-01-06 10:41:38 -07:00
|
|
|
|
|
|
|
if(histfrogp <= 0)
|
|
|
|
return;
|
|
|
|
|
2009-06-02 23:33:21 -06:00
|
|
|
search = 0;
|
2009-01-06 10:41:38 -07:00
|
|
|
if(histfrog[0]->name[1] == '/') {
|
|
|
|
sprint(name, "");
|
|
|
|
i = 1;
|
|
|
|
} else
|
|
|
|
if(histfrog[0]->name[1] == '.') {
|
|
|
|
sprint(name, ".");
|
|
|
|
i = 0;
|
|
|
|
} else {
|
2009-06-02 23:33:21 -06:00
|
|
|
sprint(name, "");
|
2009-01-06 10:41:38 -07:00
|
|
|
i = 0;
|
2009-06-02 23:33:21 -06:00
|
|
|
search = 1;
|
2009-01-06 10:41:38 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
for(; i<histfrogp; i++) {
|
|
|
|
snprint(comp, sizeof comp, histfrog[i]->name+1);
|
|
|
|
for(;;) {
|
|
|
|
p = strstr(comp, "$O");
|
|
|
|
if(p == 0)
|
|
|
|
break;
|
|
|
|
memmove(p+1, p+2, strlen(p+2)+1);
|
|
|
|
p[0] = thechar;
|
|
|
|
}
|
|
|
|
for(;;) {
|
|
|
|
p = strstr(comp, "$M");
|
|
|
|
if(p == 0)
|
|
|
|
break;
|
|
|
|
if(strlen(comp)+strlen(thestring)-2+1 >= sizeof comp) {
|
|
|
|
diag("library component too long");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
memmove(p+strlen(thestring), p+2, strlen(p+2)+1);
|
|
|
|
memmove(p, thestring, strlen(thestring));
|
|
|
|
}
|
|
|
|
if(strlen(name) + strlen(comp) + 3 >= sizeof(name)) {
|
|
|
|
diag("library component too long");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
strcat(name, "/");
|
|
|
|
strcat(name, comp);
|
|
|
|
}
|
2009-06-02 23:33:21 -06:00
|
|
|
|
|
|
|
if(search) {
|
|
|
|
// try dot, -L "libdir", and then goroot.
|
|
|
|
snprint(pname, sizeof pname, "./%s", name);
|
|
|
|
if(access(pname, AEXIST) < 0 && LIBDIR != nil)
|
|
|
|
snprint(pname, sizeof pname, "%s/%s", LIBDIR, name);
|
|
|
|
if(access(pname, AEXIST) < 0)
|
2009-06-05 23:18:32 -06:00
|
|
|
snprint(pname, sizeof pname, "%s/pkg/%s_%s/%s", goroot, goos, goarch, name);
|
2009-06-02 23:33:21 -06:00
|
|
|
strcpy(name, pname);
|
|
|
|
}
|
2009-08-12 15:41:02 -06:00
|
|
|
cleanname(name);
|
2009-03-20 17:40:00 -06:00
|
|
|
if(debug['v'])
|
|
|
|
Bprint(&bso, "%5.2f addlib: %s %s pulls in %s\n", cputime(), obj, src, name);
|
|
|
|
|
2009-01-06 10:41:38 -07:00
|
|
|
for(i=0; i<libraryp; i++)
|
|
|
|
if(strcmp(name, library[i]) == 0)
|
|
|
|
return;
|
|
|
|
if(libraryp == nelem(library)){
|
|
|
|
diag("too many autolibs; skipping %s", name);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2009-08-20 18:33:28 -06:00
|
|
|
p = mal(strlen(name) + 1);
|
2009-01-06 10:41:38 -07:00
|
|
|
strcpy(p, name);
|
|
|
|
library[libraryp] = p;
|
2009-08-20 18:33:28 -06:00
|
|
|
p = mal(strlen(obj) + 1);
|
2009-01-06 10:41:38 -07:00
|
|
|
strcpy(p, obj);
|
|
|
|
libraryobj[libraryp] = p;
|
|
|
|
libraryp++;
|
|
|
|
}
|
|
|
|
|
2009-03-20 17:40:00 -06:00
|
|
|
void
|
|
|
|
copyhistfrog(char *buf, int nbuf)
|
|
|
|
{
|
|
|
|
char *p, *ep;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
p = buf;
|
|
|
|
ep = buf + nbuf;
|
|
|
|
i = 0;
|
|
|
|
for(i=0; i<histfrogp; i++) {
|
|
|
|
p = seprint(p, ep, "%s", histfrog[i]->name+1);
|
|
|
|
if(i+1<histfrogp && (p == buf || p[-1] != '/'))
|
|
|
|
p = seprint(p, ep, "/");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-01-06 10:41:38 -07:00
|
|
|
void
|
2009-01-06 12:34:02 -07:00
|
|
|
addhist(int32 line, int type)
|
2009-01-06 10:41:38 -07:00
|
|
|
{
|
|
|
|
Auto *u;
|
|
|
|
Sym *s;
|
|
|
|
int i, j, k;
|
|
|
|
|
2009-08-20 18:33:28 -06:00
|
|
|
u = mal(sizeof(Auto));
|
|
|
|
s = mal(sizeof(Sym));
|
|
|
|
s->name = mal(2*(histfrogp+1) + 1);
|
2009-01-06 10:41:38 -07:00
|
|
|
|
|
|
|
u->asym = s;
|
|
|
|
u->type = type;
|
|
|
|
u->aoffset = line;
|
|
|
|
u->link = curhist;
|
|
|
|
curhist = u;
|
|
|
|
|
2009-03-20 17:40:00 -06:00
|
|
|
s->name[0] = 0;
|
2009-01-06 10:41:38 -07:00
|
|
|
j = 1;
|
|
|
|
for(i=0; i<histfrogp; i++) {
|
|
|
|
k = histfrog[i]->value;
|
|
|
|
s->name[j+0] = k>>8;
|
|
|
|
s->name[j+1] = k;
|
|
|
|
j += 2;
|
|
|
|
}
|
2009-03-20 17:40:00 -06:00
|
|
|
s->name[j] = 0;
|
|
|
|
s->name[j+1] = 0;
|
2009-01-06 10:41:38 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
histtoauto(void)
|
|
|
|
{
|
|
|
|
Auto *l;
|
|
|
|
|
|
|
|
while(l = curhist) {
|
|
|
|
curhist = l->link;
|
|
|
|
l->link = curauto;
|
|
|
|
curauto = l;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
collapsefrog(Sym *s)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* bad encoding of path components only allows
|
|
|
|
* MAXHIST components. if there is an overflow,
|
|
|
|
* first try to collapse xxx/..
|
|
|
|
*/
|
|
|
|
for(i=1; i<histfrogp; i++)
|
|
|
|
if(strcmp(histfrog[i]->name+1, "..") == 0) {
|
|
|
|
memmove(histfrog+i-1, histfrog+i+1,
|
|
|
|
(histfrogp-i-1)*sizeof(histfrog[0]));
|
|
|
|
histfrogp--;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* next try to collapse .
|
|
|
|
*/
|
|
|
|
for(i=0; i<histfrogp; i++)
|
|
|
|
if(strcmp(histfrog[i]->name+1, ".") == 0) {
|
|
|
|
memmove(histfrog+i, histfrog+i+1,
|
|
|
|
(histfrogp-i-1)*sizeof(histfrog[0]));
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* last chance, just truncate from front
|
|
|
|
*/
|
|
|
|
memmove(histfrog+0, histfrog+1,
|
|
|
|
(histfrogp-1)*sizeof(histfrog[0]));
|
|
|
|
|
|
|
|
out:
|
|
|
|
histfrog[histfrogp-1] = s;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
nopout(Prog *p)
|
|
|
|
{
|
|
|
|
p->as = ANOP;
|
|
|
|
p->from.type = D_NONE;
|
|
|
|
p->to.type = D_NONE;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2009-03-20 17:40:00 -06:00
|
|
|
ldobj(Biobuf *f, int32 len, char *pn)
|
2009-01-06 10:41:38 -07:00
|
|
|
{
|
2009-01-06 12:34:02 -07:00
|
|
|
int32 ipc;
|
2009-01-06 10:41:38 -07:00
|
|
|
Prog *p, *t;
|
|
|
|
int v, o, r, skip;
|
|
|
|
Sym *h[NSYM], *s, *di;
|
2009-01-06 12:34:02 -07:00
|
|
|
uint32 sig;
|
2009-01-06 10:41:38 -07:00
|
|
|
static int files;
|
|
|
|
static char **filen;
|
|
|
|
char **nfilen;
|
2009-03-20 17:40:00 -06:00
|
|
|
int ntext, n, c1, c2, c3;
|
|
|
|
int32 eof;
|
|
|
|
int32 import0, import1;
|
|
|
|
char *line, *name;
|
|
|
|
char src[1024];
|
|
|
|
|
|
|
|
src[0] = '\0';
|
|
|
|
eof = Boffset(f) + len;
|
|
|
|
|
|
|
|
ntext = 0;
|
2009-01-06 10:41:38 -07:00
|
|
|
|
|
|
|
if((files&15) == 0){
|
|
|
|
nfilen = malloc((files+16)*sizeof(char*));
|
|
|
|
memmove(nfilen, filen, files*sizeof(char*));
|
|
|
|
free(filen);
|
|
|
|
filen = nfilen;
|
|
|
|
}
|
2009-03-20 17:40:00 -06:00
|
|
|
pn = strdup(pn);
|
|
|
|
filen[files++] = pn;
|
2009-01-06 10:41:38 -07:00
|
|
|
|
|
|
|
di = S;
|
|
|
|
|
2009-03-20 17:40:00 -06:00
|
|
|
/* check the header */
|
|
|
|
line = Brdline(f, '\n');
|
|
|
|
if(line == nil) {
|
|
|
|
if(Blinelen(f) > 0) {
|
|
|
|
diag("%s: malformed object file", pn);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
goto eof;
|
|
|
|
}
|
|
|
|
n = Blinelen(f) - 1;
|
|
|
|
if(n != strlen(thestring) || strncmp(line, thestring, n) != 0) {
|
|
|
|
if(line)
|
|
|
|
line[n] = '\0';
|
|
|
|
diag("file not %s [%s]\n", thestring, line);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* skip over exports and other info -- ends with \n!\n */
|
|
|
|
import0 = Boffset(f);
|
|
|
|
c1 = '\n'; // the last line ended in \n
|
|
|
|
c2 = Bgetc(f);
|
|
|
|
c3 = Bgetc(f);
|
|
|
|
while(c1 != '\n' || c2 != '!' || c3 != '\n') {
|
|
|
|
c1 = c2;
|
|
|
|
c2 = c3;
|
|
|
|
c3 = Bgetc(f);
|
|
|
|
if(c3 == Beof)
|
|
|
|
goto eof;
|
|
|
|
}
|
|
|
|
import1 = Boffset(f);
|
|
|
|
|
|
|
|
Bseek(f, import0, 0);
|
2009-03-31 01:20:07 -06:00
|
|
|
ldpkg(f, import1 - import0 - 2, pn); // -2 for !\n
|
2009-03-20 17:40:00 -06:00
|
|
|
Bseek(f, import1, 0);
|
|
|
|
|
2009-01-06 10:41:38 -07:00
|
|
|
newloop:
|
|
|
|
memset(h, 0, sizeof(h));
|
|
|
|
version++;
|
|
|
|
histfrogp = 0;
|
|
|
|
ipc = pc;
|
|
|
|
skip = 0;
|
|
|
|
|
|
|
|
loop:
|
2009-03-20 17:40:00 -06:00
|
|
|
if(f->state == Bracteof || Boffset(f) >= eof)
|
2009-01-06 10:41:38 -07:00
|
|
|
goto eof;
|
2009-03-20 17:40:00 -06:00
|
|
|
o = Bgetc(f);
|
|
|
|
if(o == Beof)
|
|
|
|
goto eof;
|
|
|
|
o |= Bgetc(f) << 8;
|
2009-01-06 10:41:38 -07:00
|
|
|
if(o <= AXXX || o >= ALAST) {
|
|
|
|
if(o < 0)
|
|
|
|
goto eof;
|
2009-03-20 17:40:00 -06:00
|
|
|
diag("%s:#%lld: opcode out of range: %#ux", pn, Boffset(f), o);
|
|
|
|
print(" probably not a .%c file\n", thechar);
|
2009-01-06 10:41:38 -07:00
|
|
|
errorexit();
|
|
|
|
}
|
|
|
|
|
|
|
|
if(o == ANAME || o == ASIGNAME) {
|
|
|
|
sig = 0;
|
2009-03-20 17:40:00 -06:00
|
|
|
if(o == ASIGNAME)
|
|
|
|
sig = Bget4(f);
|
|
|
|
v = Bgetc(f); /* type */
|
|
|
|
o = Bgetc(f); /* sym */
|
|
|
|
r = 0;
|
|
|
|
if(v == D_STATIC)
|
|
|
|
r = version;
|
|
|
|
name = Brdline(f, '\0');
|
|
|
|
if(name == nil) {
|
|
|
|
if(Blinelen(f) > 0) {
|
2009-01-06 10:41:38 -07:00
|
|
|
fprint(2, "%s: name too long\n", pn);
|
|
|
|
errorexit();
|
|
|
|
}
|
2009-03-20 17:40:00 -06:00
|
|
|
goto eof;
|
2009-01-06 10:41:38 -07:00
|
|
|
}
|
2009-03-20 17:40:00 -06:00
|
|
|
s = lookup(name, r);
|
2009-01-06 10:41:38 -07:00
|
|
|
|
|
|
|
if(debug['S'] && r == 0)
|
|
|
|
sig = 1729;
|
|
|
|
if(sig != 0){
|
|
|
|
if(s->sig != 0 && s->sig != sig)
|
2009-03-20 17:40:00 -06:00
|
|
|
diag("incompatible type signatures"
|
|
|
|
"%lux(%s) and %lux(%s) for %s",
|
|
|
|
s->sig, filen[s->file], sig, pn, s->name);
|
2009-01-06 10:41:38 -07:00
|
|
|
s->sig = sig;
|
|
|
|
s->file = files-1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if(debug['W'])
|
|
|
|
print(" ANAME %s\n", s->name);
|
|
|
|
h[o] = s;
|
|
|
|
if((v == D_EXTERN || v == D_STATIC) && s->type == 0)
|
|
|
|
s->type = SXREF;
|
|
|
|
if(v == D_FILE) {
|
|
|
|
if(s->type != SFILE) {
|
|
|
|
histgen++;
|
|
|
|
s->type = SFILE;
|
|
|
|
s->value = histgen;
|
|
|
|
}
|
|
|
|
if(histfrogp < MAXHIST) {
|
|
|
|
histfrog[histfrogp] = s;
|
|
|
|
histfrogp++;
|
|
|
|
} else
|
|
|
|
collapsefrog(s);
|
|
|
|
}
|
|
|
|
goto loop;
|
|
|
|
}
|
|
|
|
|
2009-01-06 12:34:02 -07:00
|
|
|
p = mal(sizeof(*p));
|
2009-01-06 10:41:38 -07:00
|
|
|
p->as = o;
|
2009-03-20 17:40:00 -06:00
|
|
|
p->line = Bget4(f);
|
2009-01-06 10:41:38 -07:00
|
|
|
p->back = 2;
|
2009-03-20 17:40:00 -06:00
|
|
|
zaddr(f, &p->from, h);
|
|
|
|
zaddr(f, &p->to, h);
|
2009-01-06 10:41:38 -07:00
|
|
|
|
|
|
|
if(debug['W'])
|
|
|
|
print("%P\n", p);
|
|
|
|
|
|
|
|
switch(p->as) {
|
|
|
|
case AHISTORY:
|
|
|
|
if(p->to.offset == -1) {
|
2009-03-20 17:40:00 -06:00
|
|
|
addlib(src, pn);
|
2009-01-06 10:41:38 -07:00
|
|
|
histfrogp = 0;
|
|
|
|
goto loop;
|
|
|
|
}
|
2009-03-20 17:40:00 -06:00
|
|
|
if(src[0] == '\0')
|
|
|
|
copyhistfrog(src, sizeof src);
|
2009-01-06 10:41:38 -07:00
|
|
|
addhist(p->line, D_FILE); /* 'z' */
|
|
|
|
if(p->to.offset)
|
|
|
|
addhist(p->to.offset, D_FILE1); /* 'Z' */
|
|
|
|
histfrogp = 0;
|
|
|
|
goto loop;
|
|
|
|
|
|
|
|
case AEND:
|
|
|
|
histtoauto();
|
|
|
|
if(curtext != P)
|
|
|
|
curtext->to.autom = curauto;
|
|
|
|
curauto = 0;
|
|
|
|
curtext = P;
|
2009-03-20 17:40:00 -06:00
|
|
|
if(Boffset(f) == eof)
|
|
|
|
return;
|
|
|
|
goto newloop;
|
2009-01-06 10:41:38 -07:00
|
|
|
|
|
|
|
case AGLOBL:
|
|
|
|
s = p->from.sym;
|
|
|
|
if(s->type == 0 || s->type == SXREF) {
|
|
|
|
s->type = SBSS;
|
|
|
|
s->value = 0;
|
|
|
|
}
|
|
|
|
if(s->type != SBSS) {
|
|
|
|
diag("%s: redefinition: %s in %s",
|
|
|
|
pn, s->name, TNAME);
|
|
|
|
s->type = SBSS;
|
|
|
|
s->value = 0;
|
|
|
|
}
|
|
|
|
if(p->to.offset > s->value)
|
|
|
|
s->value = p->to.offset;
|
2009-06-02 23:33:21 -06:00
|
|
|
if(p->from.scale & DUPOK)
|
|
|
|
s->dupok = 1;
|
2009-01-06 10:41:38 -07:00
|
|
|
goto loop;
|
|
|
|
|
|
|
|
case ADYNT:
|
|
|
|
if(p->to.sym == S) {
|
|
|
|
diag("DYNT without a sym\n%P", p);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
di = p->to.sym;
|
|
|
|
p->from.scale = 4;
|
|
|
|
if(di->type == SXREF) {
|
|
|
|
if(debug['z'])
|
|
|
|
Bprint(&bso, "%P set to %d\n", p, dtype);
|
|
|
|
di->type = SCONST;
|
|
|
|
di->value = dtype;
|
|
|
|
dtype += 4;
|
|
|
|
}
|
|
|
|
if(p->from.sym == S)
|
|
|
|
break;
|
|
|
|
|
|
|
|
p->from.offset = di->value;
|
|
|
|
p->from.sym->type = SDATA;
|
|
|
|
if(curtext == P) {
|
|
|
|
diag("DYNT not in text: %P", p);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
p->to.sym = curtext->from.sym;
|
|
|
|
p->to.type = D_ADDR;
|
|
|
|
p->to.index = D_EXTERN;
|
|
|
|
goto data;
|
|
|
|
|
|
|
|
case AINIT:
|
|
|
|
if(p->from.sym == S) {
|
|
|
|
diag("INIT without a sym\n%P", p);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if(di == S) {
|
|
|
|
diag("INIT without previous DYNT\n%P", p);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
p->from.offset = di->value;
|
|
|
|
p->from.sym->type = SDATA;
|
|
|
|
goto data;
|
|
|
|
|
|
|
|
case ADATA:
|
|
|
|
data:
|
2009-03-31 01:20:07 -06:00
|
|
|
// Assume that AGLOBL comes after ADATA.
|
|
|
|
// If we've seen an AGLOBL that said this sym was DUPOK,
|
|
|
|
// ignore any more ADATA we see, which must be
|
|
|
|
// redefinitions.
|
|
|
|
s = p->from.sym;
|
|
|
|
if(s != S && s->dupok) {
|
|
|
|
if(debug['v'])
|
2009-06-17 16:15:55 -06:00
|
|
|
Bprint(&bso, "skipping %s in %s: dupok\n", s->name, pn);
|
2009-03-31 01:20:07 -06:00
|
|
|
goto loop;
|
|
|
|
}
|
|
|
|
if(s != S) {
|
|
|
|
p->dlink = s->data;
|
|
|
|
s->data = p;
|
|
|
|
}
|
2009-01-06 10:41:38 -07:00
|
|
|
if(edatap == P)
|
|
|
|
datap = p;
|
|
|
|
else
|
|
|
|
edatap->link = p;
|
|
|
|
edatap = p;
|
|
|
|
p->link = P;
|
|
|
|
goto loop;
|
|
|
|
|
|
|
|
case AGOK:
|
|
|
|
diag("%s: GOK opcode in %s", pn, TNAME);
|
|
|
|
pc++;
|
|
|
|
goto loop;
|
|
|
|
|
|
|
|
case ATEXT:
|
2009-03-20 17:40:00 -06:00
|
|
|
s = p->from.sym;
|
|
|
|
if(s == S) {
|
|
|
|
diag("%s: no TEXT symbol: %P", pn, p);
|
|
|
|
errorexit();
|
|
|
|
}
|
|
|
|
if(ntext++ == 0 && s->type != 0 && s->type != SXREF) {
|
|
|
|
/* redefinition, so file has probably been seen before */
|
|
|
|
if(debug['v'])
|
|
|
|
diag("skipping: %s: redefinition: %s", pn, s->name);
|
|
|
|
return;
|
|
|
|
}
|
2009-01-06 10:41:38 -07:00
|
|
|
if(curtext != P) {
|
|
|
|
histtoauto();
|
|
|
|
curtext->to.autom = curauto;
|
|
|
|
curauto = 0;
|
|
|
|
}
|
|
|
|
skip = 0;
|
|
|
|
curtext = p;
|
|
|
|
if(s->type != 0 && s->type != SXREF) {
|
|
|
|
if(p->from.scale & DUPOK) {
|
|
|
|
skip = 1;
|
|
|
|
goto casdef;
|
|
|
|
}
|
|
|
|
diag("%s: redefinition: %s\n%P", pn, s->name, p);
|
|
|
|
}
|
2009-03-31 01:20:07 -06:00
|
|
|
newtext(p, s);
|
2009-01-06 10:41:38 -07:00
|
|
|
goto loop;
|
|
|
|
|
|
|
|
case AFMOVF:
|
|
|
|
case AFADDF:
|
|
|
|
case AFSUBF:
|
|
|
|
case AFSUBRF:
|
|
|
|
case AFMULF:
|
|
|
|
case AFDIVF:
|
|
|
|
case AFDIVRF:
|
|
|
|
case AFCOMF:
|
|
|
|
case AFCOMFP:
|
|
|
|
if(skip)
|
|
|
|
goto casdef;
|
|
|
|
if(p->from.type == D_FCONST) {
|
|
|
|
/* size sb 9 max */
|
|
|
|
sprint(literal, "$%lux", ieeedtof(&p->from.ieee));
|
|
|
|
s = lookup(literal, 0);
|
|
|
|
if(s->type == 0) {
|
|
|
|
s->type = SBSS;
|
|
|
|
s->value = 4;
|
|
|
|
t = prg();
|
|
|
|
t->as = ADATA;
|
|
|
|
t->line = p->line;
|
|
|
|
t->from.type = D_EXTERN;
|
|
|
|
t->from.sym = s;
|
|
|
|
t->from.scale = 4;
|
|
|
|
t->to = p->from;
|
|
|
|
if(edatap == P)
|
|
|
|
datap = t;
|
|
|
|
else
|
|
|
|
edatap->link = t;
|
|
|
|
edatap = t;
|
|
|
|
t->link = P;
|
|
|
|
}
|
|
|
|
p->from.type = D_EXTERN;
|
|
|
|
p->from.sym = s;
|
|
|
|
p->from.offset = 0;
|
|
|
|
}
|
|
|
|
goto casdef;
|
|
|
|
|
|
|
|
case AFMOVD:
|
|
|
|
case AFADDD:
|
|
|
|
case AFSUBD:
|
|
|
|
case AFSUBRD:
|
|
|
|
case AFMULD:
|
|
|
|
case AFDIVD:
|
|
|
|
case AFDIVRD:
|
|
|
|
case AFCOMD:
|
|
|
|
case AFCOMDP:
|
|
|
|
if(skip)
|
|
|
|
goto casdef;
|
|
|
|
if(p->from.type == D_FCONST) {
|
|
|
|
/* size sb 18 max */
|
|
|
|
sprint(literal, "$%lux.%lux",
|
|
|
|
p->from.ieee.l, p->from.ieee.h);
|
|
|
|
s = lookup(literal, 0);
|
|
|
|
if(s->type == 0) {
|
|
|
|
s->type = SBSS;
|
|
|
|
s->value = 8;
|
|
|
|
t = prg();
|
|
|
|
t->as = ADATA;
|
|
|
|
t->line = p->line;
|
|
|
|
t->from.type = D_EXTERN;
|
|
|
|
t->from.sym = s;
|
|
|
|
t->from.scale = 8;
|
|
|
|
t->to = p->from;
|
|
|
|
if(edatap == P)
|
|
|
|
datap = t;
|
|
|
|
else
|
|
|
|
edatap->link = t;
|
|
|
|
edatap = t;
|
|
|
|
t->link = P;
|
|
|
|
}
|
|
|
|
p->from.type = D_EXTERN;
|
|
|
|
p->from.sym = s;
|
|
|
|
p->from.offset = 0;
|
|
|
|
}
|
|
|
|
goto casdef;
|
|
|
|
|
|
|
|
casdef:
|
|
|
|
default:
|
|
|
|
if(skip)
|
|
|
|
nopout(p);
|
|
|
|
|
|
|
|
if(p->to.type == D_BRANCH)
|
|
|
|
p->to.offset += ipc;
|
|
|
|
lastp->link = p;
|
|
|
|
lastp = p;
|
|
|
|
p->pc = pc;
|
|
|
|
pc++;
|
|
|
|
goto loop;
|
|
|
|
}
|
|
|
|
goto loop;
|
|
|
|
|
|
|
|
eof:
|
|
|
|
diag("truncated object file: %s", pn);
|
|
|
|
}
|
|
|
|
|
|
|
|
Sym*
|
|
|
|
lookup(char *symb, int v)
|
|
|
|
{
|
|
|
|
Sym *s;
|
|
|
|
char *p;
|
2009-01-06 12:34:02 -07:00
|
|
|
int32 h;
|
2009-01-06 10:41:38 -07:00
|
|
|
int l, c;
|
|
|
|
|
|
|
|
h = v;
|
|
|
|
for(p=symb; c = *p; p++)
|
|
|
|
h = h+h+h + c;
|
|
|
|
l = (p - symb) + 1;
|
|
|
|
if(h < 0)
|
|
|
|
h = ~h;
|
|
|
|
h %= NHASH;
|
|
|
|
for(s = hash[h]; s != S; s = s->link)
|
|
|
|
if(s->version == v)
|
|
|
|
if(memcmp(s->name, symb, l) == 0)
|
|
|
|
return s;
|
|
|
|
|
2009-01-06 12:34:02 -07:00
|
|
|
s = mal(sizeof(Sym));
|
2009-08-20 18:33:28 -06:00
|
|
|
s->name = mal(l + 1);
|
2009-01-06 10:41:38 -07:00
|
|
|
memmove(s->name, symb, l);
|
|
|
|
|
|
|
|
s->link = hash[h];
|
|
|
|
s->type = 0;
|
|
|
|
s->version = v;
|
|
|
|
s->value = 0;
|
|
|
|
s->sig = 0;
|
|
|
|
hash[h] = s;
|
|
|
|
nsymbol++;
|
|
|
|
return s;
|
|
|
|
}
|
|
|
|
|
|
|
|
Prog*
|
|
|
|
prg(void)
|
|
|
|
{
|
|
|
|
Prog *p;
|
|
|
|
|
2009-01-06 12:34:02 -07:00
|
|
|
p = mal(sizeof(Prog));
|
2009-01-06 10:41:38 -07:00
|
|
|
*p = zprg;
|
|
|
|
return p;
|
|
|
|
}
|
|
|
|
|
|
|
|
Prog*
|
|
|
|
copyp(Prog *q)
|
|
|
|
{
|
|
|
|
Prog *p;
|
|
|
|
|
|
|
|
p = prg();
|
|
|
|
*p = *q;
|
|
|
|
return p;
|
|
|
|
}
|
|
|
|
|
|
|
|
Prog*
|
|
|
|
appendp(Prog *q)
|
|
|
|
{
|
|
|
|
Prog *p;
|
|
|
|
|
|
|
|
p = prg();
|
|
|
|
p->link = q->link;
|
|
|
|
q->link = p;
|
|
|
|
p->line = q->line;
|
|
|
|
return p;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
doprof1(void)
|
|
|
|
{
|
|
|
|
Sym *s;
|
2009-01-06 12:34:02 -07:00
|
|
|
int32 n;
|
2009-01-06 10:41:38 -07:00
|
|
|
Prog *p, *q;
|
|
|
|
|
|
|
|
if(debug['v'])
|
|
|
|
Bprint(&bso, "%5.2f profile 1\n", cputime());
|
|
|
|
Bflush(&bso);
|
|
|
|
s = lookup("__mcount", 0);
|
|
|
|
n = 1;
|
|
|
|
for(p = firstp->link; p != P; p = p->link) {
|
|
|
|
if(p->as == ATEXT) {
|
|
|
|
q = prg();
|
|
|
|
q->line = p->line;
|
|
|
|
q->link = datap;
|
|
|
|
datap = q;
|
|
|
|
q->as = ADATA;
|
|
|
|
q->from.type = D_EXTERN;
|
|
|
|
q->from.offset = n*4;
|
|
|
|
q->from.sym = s;
|
|
|
|
q->from.scale = 4;
|
|
|
|
q->to = p->from;
|
|
|
|
q->to.type = D_CONST;
|
|
|
|
|
|
|
|
q = prg();
|
|
|
|
q->line = p->line;
|
|
|
|
q->pc = p->pc;
|
|
|
|
q->link = p->link;
|
|
|
|
p->link = q;
|
|
|
|
p = q;
|
|
|
|
p->as = AADDL;
|
|
|
|
p->from.type = D_CONST;
|
|
|
|
p->from.offset = 1;
|
|
|
|
p->to.type = D_EXTERN;
|
|
|
|
p->to.sym = s;
|
|
|
|
p->to.offset = n*4 + 4;
|
|
|
|
|
|
|
|
n += 2;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
q = prg();
|
|
|
|
q->line = 0;
|
|
|
|
q->link = datap;
|
|
|
|
datap = q;
|
|
|
|
|
|
|
|
q->as = ADATA;
|
|
|
|
q->from.type = D_EXTERN;
|
|
|
|
q->from.sym = s;
|
|
|
|
q->from.scale = 4;
|
|
|
|
q->to.type = D_CONST;
|
|
|
|
q->to.offset = n;
|
|
|
|
|
|
|
|
s->type = SBSS;
|
|
|
|
s->value = n*4;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
doprof2(void)
|
|
|
|
{
|
|
|
|
Sym *s2, *s4;
|
|
|
|
Prog *p, *q, *ps2, *ps4;
|
|
|
|
|
|
|
|
if(debug['v'])
|
|
|
|
Bprint(&bso, "%5.2f profile 2\n", cputime());
|
|
|
|
Bflush(&bso);
|
|
|
|
|
|
|
|
s2 = lookup("_profin", 0);
|
|
|
|
s4 = lookup("_profout", 0);
|
|
|
|
if(s2->type != STEXT || s4->type != STEXT) {
|
|
|
|
diag("_profin/_profout not defined");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
ps2 = P;
|
|
|
|
ps4 = P;
|
|
|
|
for(p = firstp; p != P; p = p->link) {
|
|
|
|
if(p->as == ATEXT) {
|
|
|
|
if(p->from.sym == s2) {
|
|
|
|
p->from.scale = 1;
|
|
|
|
ps2 = p;
|
|
|
|
}
|
|
|
|
if(p->from.sym == s4) {
|
|
|
|
p->from.scale = 1;
|
|
|
|
ps4 = p;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
for(p = firstp; p != P; p = p->link) {
|
|
|
|
if(p->as == ATEXT) {
|
|
|
|
curtext = p;
|
|
|
|
|
|
|
|
if(p->from.scale & NOPROF) { /* dont profile */
|
|
|
|
for(;;) {
|
|
|
|
q = p->link;
|
|
|
|
if(q == P)
|
|
|
|
break;
|
|
|
|
if(q->as == ATEXT)
|
|
|
|
break;
|
|
|
|
p = q;
|
|
|
|
}
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* JMPL profin
|
|
|
|
*/
|
|
|
|
q = prg();
|
|
|
|
q->line = p->line;
|
|
|
|
q->pc = p->pc;
|
|
|
|
q->link = p->link;
|
|
|
|
p->link = q;
|
|
|
|
p = q;
|
|
|
|
p->as = ACALL;
|
|
|
|
p->to.type = D_BRANCH;
|
|
|
|
p->pcond = ps2;
|
|
|
|
p->to.sym = s2;
|
|
|
|
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if(p->as == ARET) {
|
|
|
|
/*
|
|
|
|
* RET
|
|
|
|
*/
|
|
|
|
q = prg();
|
|
|
|
q->as = ARET;
|
|
|
|
q->from = p->from;
|
|
|
|
q->to = p->to;
|
|
|
|
q->link = p->link;
|
|
|
|
p->link = q;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* JAL profout
|
|
|
|
*/
|
|
|
|
p->as = ACALL;
|
|
|
|
p->from = zprg.from;
|
|
|
|
p->to = zprg.to;
|
|
|
|
p->to.type = D_BRANCH;
|
|
|
|
p->pcond = ps4;
|
|
|
|
p->to.sym = s4;
|
|
|
|
|
|
|
|
p = q;
|
|
|
|
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
nuxiinit(void)
|
|
|
|
{
|
|
|
|
int i, c;
|
|
|
|
|
|
|
|
for(i=0; i<4; i++) {
|
|
|
|
c = find1(0x04030201L, i+1);
|
|
|
|
if(i < 2)
|
|
|
|
inuxi2[i] = c;
|
|
|
|
if(i < 1)
|
|
|
|
inuxi1[i] = c;
|
|
|
|
inuxi4[i] = c;
|
|
|
|
fnuxi4[i] = c;
|
|
|
|
fnuxi8[i] = c;
|
|
|
|
fnuxi8[i+4] = c+4;
|
|
|
|
}
|
|
|
|
if(debug['v']) {
|
|
|
|
Bprint(&bso, "inuxi = ");
|
|
|
|
for(i=0; i<1; i++)
|
|
|
|
Bprint(&bso, "%d", inuxi1[i]);
|
|
|
|
Bprint(&bso, " ");
|
|
|
|
for(i=0; i<2; i++)
|
|
|
|
Bprint(&bso, "%d", inuxi2[i]);
|
|
|
|
Bprint(&bso, " ");
|
|
|
|
for(i=0; i<4; i++)
|
|
|
|
Bprint(&bso, "%d", inuxi4[i]);
|
|
|
|
Bprint(&bso, "\nfnuxi = ");
|
|
|
|
for(i=0; i<4; i++)
|
|
|
|
Bprint(&bso, "%d", fnuxi4[i]);
|
|
|
|
Bprint(&bso, " ");
|
|
|
|
for(i=0; i<8; i++)
|
|
|
|
Bprint(&bso, "%d", fnuxi8[i]);
|
|
|
|
Bprint(&bso, "\n");
|
|
|
|
}
|
|
|
|
Bflush(&bso);
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2009-01-06 12:34:02 -07:00
|
|
|
find1(int32 l, int c)
|
2009-01-06 10:41:38 -07:00
|
|
|
{
|
|
|
|
char *p;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
p = (char*)&l;
|
|
|
|
for(i=0; i<4; i++)
|
|
|
|
if(*p++ == c)
|
|
|
|
return i;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2009-01-06 12:34:02 -07:00
|
|
|
find2(int32 l, int c)
|
2009-01-06 10:41:38 -07:00
|
|
|
{
|
|
|
|
short *p;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
p = (short*)&l;
|
|
|
|
for(i=0; i<4; i+=2) {
|
|
|
|
if(((*p >> 8) & 0xff) == c)
|
|
|
|
return i;
|
|
|
|
if((*p++ & 0xff) == c)
|
|
|
|
return i+1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-01-06 12:34:02 -07:00
|
|
|
int32
|
2009-01-06 10:41:38 -07:00
|
|
|
ieeedtof(Ieee *e)
|
|
|
|
{
|
|
|
|
int exp;
|
2009-01-06 12:34:02 -07:00
|
|
|
int32 v;
|
2009-01-06 10:41:38 -07:00
|
|
|
|
|
|
|
if(e->h == 0)
|
|
|
|
return 0;
|
|
|
|
exp = (e->h>>20) & ((1L<<11)-1L);
|
|
|
|
exp -= (1L<<10) - 2L;
|
|
|
|
v = (e->h & 0xfffffL) << 3;
|
|
|
|
v |= (e->l >> 29) & 0x7L;
|
|
|
|
if((e->l >> 28) & 1) {
|
|
|
|
v++;
|
|
|
|
if(v & 0x800000L) {
|
|
|
|
v = (v & 0x7fffffL) >> 1;
|
|
|
|
exp++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if(exp <= -126 || exp >= 130)
|
|
|
|
diag("double fp to single fp overflow");
|
|
|
|
v |= ((exp + 126) & 0xffL) << 23;
|
|
|
|
v |= e->h & 0x80000000L;
|
|
|
|
return v;
|
|
|
|
}
|
|
|
|
|
|
|
|
double
|
|
|
|
ieeedtod(Ieee *ieeep)
|
|
|
|
{
|
|
|
|
Ieee e;
|
|
|
|
double fr;
|
|
|
|
int exp;
|
|
|
|
|
|
|
|
if(ieeep->h & (1L<<31)) {
|
|
|
|
e.h = ieeep->h & ~(1L<<31);
|
|
|
|
e.l = ieeep->l;
|
|
|
|
return -ieeedtod(&e);
|
|
|
|
}
|
|
|
|
if(ieeep->l == 0 && ieeep->h == 0)
|
|
|
|
return 0;
|
|
|
|
fr = ieeep->l & ((1L<<16)-1L);
|
|
|
|
fr /= 1L<<16;
|
|
|
|
fr += (ieeep->l>>16) & ((1L<<16)-1L);
|
|
|
|
fr /= 1L<<16;
|
|
|
|
fr += (ieeep->h & (1L<<20)-1L) | (1L<<20);
|
|
|
|
fr /= 1L<<21;
|
|
|
|
exp = (ieeep->h>>20) & ((1L<<11)-1L);
|
|
|
|
exp -= (1L<<10) - 2L;
|
|
|
|
return ldexp(fr, exp);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
undefsym(Sym *s)
|
|
|
|
{
|
|
|
|
int n;
|
|
|
|
|
|
|
|
n = imports;
|
|
|
|
if(s->value != 0)
|
|
|
|
diag("value != 0 on SXREF");
|
|
|
|
if(n >= 1<<Rindex)
|
|
|
|
diag("import index %d out of range", n);
|
|
|
|
s->value = n<<Roffset;
|
|
|
|
s->type = SUNDEF;
|
|
|
|
imports++;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
zerosig(char *sp)
|
|
|
|
{
|
|
|
|
Sym *s;
|
|
|
|
|
|
|
|
s = lookup(sp, 0);
|
|
|
|
s->sig = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
readundefs(char *f, int t)
|
|
|
|
{
|
|
|
|
int i, n;
|
|
|
|
Sym *s;
|
|
|
|
Biobuf *b;
|
|
|
|
char *l, buf[256], *fields[64];
|
|
|
|
|
|
|
|
if(f == nil)
|
|
|
|
return;
|
|
|
|
b = Bopen(f, OREAD);
|
|
|
|
if(b == nil){
|
|
|
|
diag("could not open %s: %r", f);
|
|
|
|
errorexit();
|
|
|
|
}
|
|
|
|
while((l = Brdline(b, '\n')) != nil){
|
|
|
|
n = Blinelen(b);
|
|
|
|
if(n >= sizeof(buf)){
|
|
|
|
diag("%s: line too long", f);
|
|
|
|
errorexit();
|
|
|
|
}
|
|
|
|
memmove(buf, l, n);
|
|
|
|
buf[n-1] = '\0';
|
|
|
|
n = getfields(buf, fields, nelem(fields), 1, " \t\r\n");
|
|
|
|
if(n == nelem(fields)){
|
|
|
|
diag("%s: bad format", f);
|
|
|
|
errorexit();
|
|
|
|
}
|
|
|
|
for(i = 0; i < n; i++){
|
|
|
|
s = lookup(fields[i], 0);
|
|
|
|
s->type = SXREF;
|
|
|
|
s->subtype = t;
|
|
|
|
if(t == SIMPORT)
|
|
|
|
nimports++;
|
|
|
|
else
|
|
|
|
nexports++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Bterm(b);
|
|
|
|
}
|