qbit/go
1
0
Fork 0
mirror of https://github.com/golang/go synced 2024-11-25 03:57:56 -07:00
Code Releases Activity

Copied 8g/6g into 5g. Used sharp tools to coax a .5 file out

Browse Source 
of 5g. 5l balks at the output and running 5g with -S shows
the true extent of the disaster. Still, better than
yesterday. Maybe.

Tested on the canonical:

package main
func main() {
}

R=rsc
APPROVED=rsc
DELTA=4182  (4181 added, 0 deleted, 1 changed)
OCL=27601
CL=28175
This commit is contained in:
Kai Backman 2009-05-01 13:21:53 -07:00
parent 68523603e1
commit eac5db7f4c
9 changed files with 4292 additions and 1 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

39
src/cmd/5g/Makefile Normal file
View File

@ -0,0 +1,39 @@
# Copyright 2009 The Go Authors. All rights reserved.
# Use of this source code is governed by a BSD-style
# license that can be found in the LICENSE file.
include ../../Make.conf
TARG=\
5g
HFILES=\
../gc/go.h\
../5l/5.out.h\
gg.h\
# opt.h\
OFILES=\
../5l/enam.$O\
list.$O\
align.$O\
obj.$O\
gen.$O\
gsubr.$O\
cgen.$O\
# peep.$O\
# reg.$O\
LIB=\
../gc/gc.a$O
$(TARG): $(OFILES) $(LIB)
$(LD) -o $(TARG) -L$(GOROOT)/lib $(OFILES) $(LIB) -lbio -l9 -lm
$(OFILES): $(HFILES)
clean:
rm -f $(OFILES) $(TARG) *.5 enam.c 5.out a.out
install: $(TARG)
cp $(TARG) $(BIN)/$(TARG)

38
src/cmd/5g/align.c Normal file
View File

@ -0,0 +1,38 @@
// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
#include "gg.h"
int thechar = '5';
char* thestring = "arm";
/*
* go declares several platform-specific type aliases:
* int, uint, float, and uintptr
*/
Typedef typedefs[] =
{
"int", TINT, TINT32,
"uint", TUINT, TUINT32,
"uintptr", TUINTPTR, TUINT32,
"float", TFLOAT, TFLOAT32,
0
};
void
betypeinit(void)
{
maxround = 4;
widthptr = 4;
zprog.link = P;
zprog.as = AGOK;
zprog.from.type = D_NONE;
zprog.from.index = D_NONE;
zprog.from.scale = 0;
zprog.to = zprog.from;
listinit();
}

923
src/cmd/5g/cgen.c Normal file
View File

@ -0,0 +1,923 @@
// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
#include "gg.h"
/*
* generate:
* res = n;
* simplifies and calls gmove.
*/
void
cgen(Node *n, Node *res)
{
// fatal("cgen_unimplemented");
// Node *nl, *nr, *r;
// Node n1, n2;
// int a, f;
// Prog *p1, *p2, *p3;
// Addr addr;
// if(debug['g']) {
// dump("\ncgen-n", n);
// dump("cgen-res", res);
// }
// if(n == N || n->type == T)
// return;
// if(res == N || res->type == T)
// fatal("cgen: res nil");
// if(n->ullman >= UINF) {
// if(n->op == OINDREG)
// fatal("cgen: this is going to misscompile");
// if(res->ullman >= UINF) {
// tempname(&n1, n->type);
// cgen(n, &n1);
// cgen(&n1, res);
// goto ret;
// }
// }
// if(isfat(n->type)) {
// sgen(n, res, n->type->width);
// goto ret;
// }
// if(!res->addable) {
// if(n->ullman > res->ullman) {
// regalloc(&n1, n->type, res);
// cgen(n, &n1);
// if(n1.ullman > res->ullman) {
// dump("n1", &n1);
// dump("res", res);
// fatal("loop in cgen");
// }
// cgen(&n1, res);
// regfree(&n1);
// goto ret;
// }
// if(res->ullman >= UINF)
// goto gen;
// f = 1; // gen thru register
// switch(n->op) {
// case OLITERAL:
// if(smallintconst(n))
// f = 0;
// break;
// case OREGISTER:
// f = 0;
// break;
// }
// if(sudoaddable(res, &addr)) {
// a = optoas(OAS, res->type);
// if(f) {
// regalloc(&n2, res->type, N);
// cgen(n, &n2);
// p1 = gins(a, &n2, N);
// regfree(&n2);
// } else
// p1 = gins(a, n, N);
// p1->to = addr;
// if(debug['g'])
// print("%P [ignore previous line]\n", p1);
// sudoclean();
// goto ret;
// }
// gen:
// igen(res, &n1, N);
// cgen(n, &n1);
// regfree(&n1);
// goto ret;
// }
// if(n->addable) {
// gmove(n, res);
// goto ret;
// }
// nl = n->left;
// nr = n->right;
// if(nl != N && nl->ullman >= UINF)
// if(nr != N && nr->ullman >= UINF) {
// tempname(&n1, nl->type);
// cgen(nl, &n1);
// n2 = *n;
// n2.left = &n1;
// cgen(&n2, res);
// goto ret;
// }
// if(sudoaddable(n, &addr)) {
// a = optoas(OAS, n->type);
// if(res->op == OREGISTER) {
// p1 = gins(a, N, res);
// p1->from = addr;
// } else {
// regalloc(&n2, n->type, N);
// p1 = gins(a, N, &n2);
// p1->from = addr;
// gins(a, &n2, res);
// regfree(&n2);
// }
// sudoclean();
// goto ret;
// }
// switch(n->op) {
// default:
// dump("cgen", n);
// fatal("cgen: unknown op %N", n);
// break;
// // these call bgen to get a bool value
// case OOROR:
// case OANDAND:
// case OEQ:
// case ONE:
// case OLT:
// case OLE:
// case OGE:
// case OGT:
// case ONOT:
// p1 = gbranch(AB, T);
// p2 = pc;
// gmove(nodbool(1), res);
// p3 = gbranch(AB, T);
// patch(p1, pc);
// bgen(n, 1, p2);
// gmove(nodbool(0), res);
// patch(p3, pc);
// goto ret;
// case OPLUS:
// cgen(nl, res);
// goto ret;
// // unary
// case OCOM:
// a = optoas(OXOR, nl->type);
// regalloc(&n1, nl->type, N);
// cgen(nl, &n1);
// nodconst(&n2, nl->type, -1);
// gins(a, &n2, &n1);
// gmove(&n1, res);
// regfree(&n1);
// goto ret;
// case OMINUS:
// a = optoas(n->op, nl->type);
// goto uop;
// // symmetric binary
// case OAND:
// case OOR:
// case OXOR:
// case OADD:
// case OMUL:
// a = optoas(n->op, nl->type);
// if(a != AIMULB)
// goto sbop;
// cgen_bmul(n->op, nl, nr, res);
// break;
// // asymmetric binary
// case OSUB:
// a = optoas(n->op, nl->type);
// goto abop;
// case OCONV:
// if(eqtype(n->type, nl->type, 0)) {
// cgen(nl, res);
// break;
// }
// regalloc(&n1, nl->type, res);
// cgen(nl, &n1);
// gmove(&n1, res);
// regfree(&n1);
// break;
// case ODOT:
// case ODOTPTR:
// case OINDEX:
// case OIND:
// case ONAME: // PHEAP or PPARAMREF var
// igen(n, &n1, res);
// gmove(&n1, res);
// regfree(&n1);
// break;
// case OLEN:
// if(istype(nl->type, TMAP)) {
// // map hsd len in the first 32-bit word.
// // a zero pointer means zero length
// regalloc(&n1, types[tptr], res);
// cgen(nl, &n1);
// nodconst(&n2, types[tptr], 0);
// gins(optoas(OCMP, types[tptr]), &n1, &n2);
// p1 = gbranch(optoas(OEQ, types[tptr]), T);
// n2 = n1;
// n2.op = OINDREG;
// n2.type = types[TINT32];
// gmove(&n2, &n1);
// patch(p1, pc);
// gmove(&n1, res);
// regfree(&n1);
// break;
// }
// if(istype(nl->type, TSTRING) || isslice(nl->type)) {
// // both slice and string have len in the first 32-bit word.
// // a zero pointer means zero length
// regalloc(&n1, types[tptr], res);
// agen(nl, &n1);
// n1.op = OINDREG;
// n1.type = types[TUINT32];
// n1.xoffset = Array_nel;
// gmove(&n1, res);
// regfree(&n1);
// break;
// }
// fatal("cgen: OLEN: unknown type %lT", nl->type);
// break;
// case OCAP:
// if(isslice(nl->type)) {
// regalloc(&n1, types[tptr], res);
// agen(nl, &n1);
// n1.op = OINDREG;
// n1.type = types[TUINT32];
// n1.xoffset = Array_cap;
// gmove(&n1, res);
// regfree(&n1);
// break;
// }
// fatal("cgen: OCAP: unknown type %lT", nl->type);
// break;
// case OADDR:
// agen(nl, res);
// break;
// case OCALLMETH:
// cgen_callmeth(n, 0);
// cgen_callret(n, res);
// break;
// case OCALLINTER:
// cgen_callinter(n, res, 0);
// cgen_callret(n, res);
// break;
// case OCALL:
// cgen_call(n, 0);
// cgen_callret(n, res);
// break;
// case OMOD:
// case ODIV:
// if(isfloat[n->type->etype]) {
// a = optoas(n->op, nl->type);
// goto abop;
// }
// cgen_div(n->op, nl, nr, res);
// break;
// case OLSH:
// case ORSH:
// cgen_shift(n->op, nl, nr, res);
// break;
// }
// goto ret;
// sbop: // symmetric binary
// if(nl->ullman < nr->ullman) {
// r = nl;
// nl = nr;
// nr = r;
// }
// abop: // asymmetric binary
// if(nl->ullman >= nr->ullman) {
// regalloc(&n1, nl->type, res);
// cgen(nl, &n1);
// if(sudoaddable(nr, &addr)) {
// p1 = gins(a, N, &n1);
// p1->from = addr;
// gmove(&n1, res);
// sudoclean();
// regfree(&n1);
// goto ret;
// }
// regalloc(&n2, nr->type, N);
// cgen(nr, &n2);
// } else {
// regalloc(&n2, nr->type, N);
// cgen(nr, &n2);
// regalloc(&n1, nl->type, res);
// cgen(nl, &n1);
// }
// gins(a, &n2, &n1);
// gmove(&n1, res);
// regfree(&n1);
// regfree(&n2);
// goto ret;
// uop: // unary
// regalloc(&n1, nl->type, res);
// cgen(nl, &n1);
// gins(a, N, &n1);
// gmove(&n1, res);
// regfree(&n1);
// goto ret;
// ret:
;
}
/*
* generate:
* res = &n;
*/
void
agen(Node *n, Node *res)
{
fatal("agen_unimplemented");
// Node *nl, *nr;
// Node n1, n2, n3, tmp;
// Prog *p1;
// uint32 w;
// uint64 v;
// Type *t;
// if(debug['g']) {
// dump("\nagen-res", res);
// dump("agen-r", n);
// }
// if(n == N || n->type == T)
// return;
// if(!isptr[res->type->etype])
// fatal("agen: not tptr: %T", res->type);
// if(n->addable) {
// regalloc(&n1, types[tptr], res);
// gins(ALEAQ, n, &n1);
// gmove(&n1, res);
// regfree(&n1);
// goto ret;
// }
// nl = n->left;
// nr = n->right;
// switch(n->op) {
// default:
// fatal("agen: unknown op %N", n);
// break;
// case OCONV:
// if(!eqtype(n->type, nl->type, 0))
// fatal("agen: non-trivial OCONV");
// agen(nl, res);
// return;
// case OCALLMETH:
// cgen_callmeth(n, 0);
// cgen_aret(n, res);
// break;
// case OCALLINTER:
// cgen_callinter(n, res, 0);
// cgen_aret(n, res);
// break;
// case OCALL:
// cgen_call(n, 0);
// cgen_aret(n, res);
// break;
// case OINDEX:
// w = n->type->width;
// if(nr->addable)
// goto irad;
// if(nl->addable) {
// if(!isconst(nr, CTINT)) {
// regalloc(&n1, nr->type, N);
// cgen(nr, &n1);
// }
// regalloc(&n3, types[tptr], res);
// agen(nl, &n3);
// goto index;
// }
// cgen(nr, res);
// tempname(&tmp, nr->type);
// gmove(res, &tmp);
// irad:
// regalloc(&n3, types[tptr], res);
// agen(nl, &n3);
// if(!isconst(nr, CTINT)) {
// regalloc(&n1, nr->type, N);
// cgen(nr, &n1);
// }
// goto index;
// index:
// // &a is in &n3 (allocated in res)
// // i is in &n1 (if not constant)
// // w is width
// if(w == 0)
// fatal("index is zero width");
// // constant index
// if(isconst(nr, CTINT)) {
// v = mpgetfix(nr->val.u.xval);
// if(isslice(nl->type)) {
// if(!debug['B']) {
// n1 = n3;
// n1.op = OINDREG;
// n1.type = types[tptr];
// n1.xoffset = Array_nel;
// nodconst(&n2, types[TUINT64], v);
// gins(optoas(OCMP, types[TUINT32]), &n1, &n2);
// p1 = gbranch(optoas(OGT, types[TUINT32]), T);
// ginscall(throwindex, 0);
// patch(p1, pc);
// }
// n1 = n3;
// n1.op = OINDREG;
// n1.type = types[tptr];
// n1.xoffset = Array_array;
// gmove(&n1, &n3);
// } else
// if(!debug['B']) {
// if(v < 0)
// yyerror("out of bounds on array");
// else
// if(v >= nl->type->bound)
// yyerror("out of bounds on array");
// }
// nodconst(&n2, types[tptr], v*w);
// gins(optoas(OADD, types[tptr]), &n2, &n3);
// gmove(&n3, res);
// regfree(&n3);
// break;
// }
// // type of the index
// t = types[TUINT64];
// if(issigned[n1.type->etype])
// t = types[TINT64];
// regalloc(&n2, t, &n1); // i
// gmove(&n1, &n2);
// regfree(&n1);
// if(!debug['B']) {
// // check bounds
// if(isslice(nl->type)) {
// n1 = n3;
// n1.op = OINDREG;
// n1.type = types[tptr];
// n1.xoffset = Array_nel;
// } else
// nodconst(&n1, types[TUINT64], nl->type->bound);
// gins(optoas(OCMP, types[TUINT32]), &n2, &n1);
// p1 = gbranch(optoas(OLT, types[TUINT32]), T);
// ginscall(throwindex, 0);
// patch(p1, pc);
// }
// if(isslice(nl->type)) {
// n1 = n3;
// n1.op = OINDREG;
// n1.type = types[tptr];
// n1.xoffset = Array_array;
// gmove(&n1, &n3);
// }
// if(w == 1 || w == 2 || w == 4 || w == 8) {
// p1 = gins(ALEAQ, &n2, &n3);
// p1->from.scale = w;
// p1->from.index = p1->from.type;
// p1->from.type = p1->to.type + D_INDIR;
// } else {
// nodconst(&n1, t, w);
// gins(optoas(OMUL, t), &n1, &n2);
// gins(optoas(OADD, types[tptr]), &n2, &n3);
// gmove(&n3, res);
// }
// gmove(&n3, res);
// regfree(&n2);
// regfree(&n3);
// break;
// case ONAME:
// // should only get here with names in this func.
// if(n->funcdepth > 0 && n->funcdepth != funcdepth) {
// dump("bad agen", n);
// fatal("agen: bad ONAME funcdepth %d != %d",
// n->funcdepth, funcdepth);
// }
// // should only get here for heap vars or paramref
// if(!(n->class & PHEAP) && n->class != PPARAMREF) {
// dump("bad agen", n);
// fatal("agen: bad ONAME class %#x", n->class);
// }
// cgen(n->heapaddr, res);
// if(n->xoffset != 0) {
// nodconst(&n1, types[TINT64], n->xoffset);
// gins(optoas(OADD, types[tptr]), &n1, res);
// }
// break;
// case OIND:
// cgen(nl, res);
// break;
// case ODOT:
// t = nl->type;
// agen(nl, res);
// if(n->xoffset != 0) {
// nodconst(&n1, types[TINT64], n->xoffset);
// gins(optoas(OADD, types[tptr]), &n1, res);
// }
// break;
// case ODOTPTR:
// t = nl->type;
// if(!isptr[t->etype])
// fatal("agen: not ptr %N", n);
// cgen(nl, res);
// if(n->xoffset != 0) {
// nodconst(&n1, types[TINT64], n->xoffset);
// gins(optoas(OADD, types[tptr]), &n1, res);
// }
// break;
// }
// ret:
// ;
}
/*
* generate:
* newreg = &n;
* res = newreg
*
* on exit, a has been changed to be *newreg.
* caller must regfree(a).
*/
void
igen(Node *n, Node *a, Node *res)
{
regalloc(a, types[tptr], res);
agen(n, a);
a->op = OINDREG;
a->type = n->type;
}
/*
* generate:
* if(n == true) goto to;
*/
void
bgen(Node *n, int true, Prog *to)
{
// zzz
// fatal("bgen_unimplemented");
// int et, a;
// Node *nl, *nr, *r;
// Node n1, n2, tmp;
// Prog *p1, *p2;
// if(debug['g']) {
// dump("\nbgen", n);
// }
// if(n == N)
// n = nodbool(1);
// nl = n->left;
// nr = n->right;
// if(n->type == T) {
// convlit(n, types[TBOOL]);
// if(n->type == T)
// goto ret;
// }
// et = n->type->etype;
// if(et != TBOOL) {
// yyerror("cgen: bad type %T for %O", n->type, n->op);
// patch(gins(AEND, N, N), to);
// goto ret;
// }
// nl = N;
// nr = N;
// switch(n->op) {
// default:
// regalloc(&n1, n->type, N);
// cgen(n, &n1);
// nodconst(&n2, n->type, 0);
// gins(optoas(OCMP, n->type), &n1, &n2);
// a = AJNE;
// if(!true)
// a = AJEQ;
// patch(gbranch(a, n->type), to);
// regfree(&n1);
// goto ret;
// case OLITERAL:
// // need to ask if it is bool?
// if(!true == !n->val.u.bval)
// patch(gbranch(AB, T), to);
// goto ret;
// case ONAME:
// nodconst(&n1, n->type, 0);
// gins(optoas(OCMP, n->type), n, &n1);
// a = AJNE;
// if(!true)
// a = AJEQ;
// patch(gbranch(a, n->type), to);
// goto ret;
// case OANDAND:
// if(!true)
// goto caseor;
// caseand:
// p1 = gbranch(AB, T);
// p2 = gbranch(AB, T);
// patch(p1, pc);
// bgen(n->left, !true, p2);
// bgen(n->right, !true, p2);
// p1 = gbranch(AB, T);
// patch(p1, to);
// patch(p2, pc);
// goto ret;
// case OOROR:
// if(!true)
// goto caseand;
// caseor:
// bgen(n->left, true, to);
// bgen(n->right, true, to);
// goto ret;
// case OEQ:
// case ONE:
// case OLT:
// case OGT:
// case OLE:
// case OGE:
// nr = n->right;
// if(nr == N || nr->type == T)
// goto ret;
// case ONOT: // unary
// nl = n->left;
// if(nl == N || nl->type == T)
// goto ret;
// }
// switch(n->op) {
// case ONOT:
// bgen(nl, !true, to);
// goto ret;
// case OEQ:
// case ONE:
// case OLT:
// case OGT:
// case OLE:
// case OGE:
// a = n->op;
// if(!true)
// a = brcom(a);
// // make simplest on right
// if(nl->op == OLITERAL || nl->ullman < nr->ullman) {
// a = brrev(a);
// r = nl;
// nl = nr;
// nr = r;
// }
// if(isslice(nl->type)) {
// // only valid to cmp darray to literal nil
// if((a != OEQ && a != ONE) || nr->op != OLITERAL) {
// yyerror("illegal array comparison");
// break;
// }
// a = optoas(a, types[tptr]);
// regalloc(&n1, types[tptr], N);
// agen(nl, &n1);
// n2 = n1;
// n2.op = OINDREG;
// n2.xoffset = Array_array;
// nodconst(&tmp, types[tptr], 0);
// gins(optoas(OCMP, types[tptr]), &n2, &tmp);
// patch(gbranch(a, types[tptr]), to);
// regfree(&n1);
// break;
// }
// a = optoas(a, nr->type);
// if(nr->ullman >= UINF) {
// regalloc(&n1, nr->type, N);
// cgen(nr, &n1);
// tempname(&tmp, nr->type);
// gmove(&n1, &tmp);
// regfree(&n1);
// regalloc(&n1, nl->type, N);
// cgen(nl, &n1);
// regalloc(&n2, nr->type, &n2);
// cgen(&tmp, &n2);
// gins(optoas(OCMP, nr->type), &n1, &n2);
// patch(gbranch(a, nr->type), to);
// regfree(&n1);
// regfree(&n2);
// break;
// }
// regalloc(&n1, nl->type, N);
// cgen(nl, &n1);
// if(smallintconst(nr)) {
// gins(optoas(OCMP, nr->type), &n1, nr);
// patch(gbranch(a, nr->type), to);
// regfree(&n1);
// break;
// }
// regalloc(&n2, nr->type, N);
// cgen(nr, &n2);
// gins(optoas(OCMP, nr->type), &n1, &n2);
// patch(gbranch(a, nr->type), to);
// regfree(&n1);
// regfree(&n2);
// break;
// }
// goto ret;
// ret:
// ;
}
/*
* n is on stack, either local variable
* or return value from function call.
* return n's offset from SP.
*/
int32
stkof(Node *n)
{
Type *t;
Iter flist;
switch(n->op) {
case OINDREG:
return n->xoffset;
case OCALLMETH:
case OCALLINTER:
case OCALL:
t = n->left->type;
if(isptr[t->etype])
t = t->type;
t = structfirst(&flist, getoutarg(t));
if(t != T)
return t->width;
break;
}
// botch - probably failing to recognize address
// arithmetic on the above. eg INDEX and DOT
return -1000;
}
/*
* block copy:
* memmove(&n, &ns, w);
*/
void
sgen(Node *n, Node *ns, int32 w)
{
fatal("sgen_unimplemented");
// Node nodl, nodr;
// int32 c, q, odst, osrc;
// if(debug['g']) {
// print("\nsgen w=%d\n", w);
// dump("r", n);
// dump("res", ns);
// }
// if(w == 0)
// return;
// if(n->ullman >= UINF && ns->ullman >= UINF) {
// fatal("sgen UINF");
// }
// if(w < 0)
// fatal("sgen copy %d", w);
// // offset on the stack
// osrc = stkof(n);
// odst = stkof(ns);
// nodreg(&nodl, types[tptr], D_DI);
// nodreg(&nodr, types[tptr], D_SI);
// if(n->ullman >= ns->ullman) {
// agen(n, &nodr);
// agen(ns, &nodl);
// } else {
// agen(ns, &nodl);
// agen(n, &nodr);
// }
// c = w % 8; // bytes
// q = w / 8; // quads
// // if we are copying forward on the stack and
// // the src and dst overlap, then reverse direction
// if(osrc < odst && odst < osrc+w) {
// // reverse direction
// gins(ASTD, N, N); // set direction flag
// if(c > 0) {
// gconreg(AADDQ, w-1, D_SI);
// gconreg(AADDQ, w-1, D_DI);
// gconreg(AMOVQ, c, D_CX);
// gins(AREP, N, N); // repeat
// gins(AMOVSB, N, N); // MOVB *(SI)-,*(DI)-
// }
// if(q > 0) {
// if(c > 0) {
// gconreg(AADDQ, -7, D_SI);
// gconreg(AADDQ, -7, D_DI);
// } else {
// gconreg(AADDQ, w-8, D_SI);
// gconreg(AADDQ, w-8, D_DI);
// }
// gconreg(AMOVQ, q, D_CX);
// gins(AREP, N, N); // repeat
// gins(AMOVSQ, N, N); // MOVQ *(SI)-,*(DI)-
// }
// // we leave with the flag clear
// gins(ACLD, N, N);
// } else {
// // normal direction
// if(q >= 4) {
// gconreg(AMOVQ, q, D_CX);
// gins(AREP, N, N); // repeat
// gins(AMOVSQ, N, N); // MOVQ *(SI)+,*(DI)+
// } else
// while(q > 0) {
// gins(AMOVSQ, N, N); // MOVQ *(SI)+,*(DI)+
// q--;
// }
// if(c >= 4) {
// gins(AMOVSL, N, N); // MOVL *(SI)+,*(DI)+
// c -= 4;
// }
// while(c > 0) {
// gins(AMOVSB, N, N); // MOVB *(SI)+,*(DI)+
// c--;
// }
// }
}

331
src/cmd/5g/gen.c Normal file
View File

@ -0,0 +1,331 @@
// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
#undef EXTERN
#define EXTERN
#include "gg.h"
void
compile(Node *fn)
{
Plist *pl;
Node nod1;
Prog *ptxt;
int32 lno;
Type *t;
Iter save;
if(newproc == N) {
newproc = sysfunc("newproc");
deferproc = sysfunc("deferproc");
deferreturn = sysfunc("deferreturn");
throwindex = sysfunc("throwindex");
throwreturn = sysfunc("throwreturn");
}
if(fn->nbody == N)
return;
// set up domain for labels
labellist = L;
lno = setlineno(fn);
curfn = fn;
dowidth(curfn->type);
if(curfn->type->outnamed) {
// add clearing of the output parameters
t = structfirst(&save, getoutarg(curfn->type));
while(t != T) {
if(t->nname != N)
curfn->nbody = list(nod(OAS, t->nname, N), curfn->nbody);
t = structnext(&save);
}
}
hasdefer = 0;
walk(curfn);
if(nerrors != 0)
goto ret;
allocparams();
continpc = P;
breakpc = P;
pl = newplist();
pl->name = curfn->nname;
pl->locals = autodcl;
nodconst(&nod1, types[TINT32], 0);
ptxt = gins(ATEXT, curfn->nname, &nod1);
afunclit(&ptxt->from);
// ginit();
gen(curfn->enter);
gen(curfn->nbody);
// gclean();
checklabels();
// if(curfn->type->outtuple != 0)
// ginscall(throwreturn, 0);
// if(hasdefer)
// ginscall(deferreturn, 0);
pc->as = ARET; // overwrite AEND
pc->lineno = lineno;
// if(!debug['N'] || debug['R'] || debug['P'])
// regopt(ptxt);
// fill in argument size
ptxt->to.offset2 = rnd(curfn->type->argwid, maxround);
// fill in final stack size
if(stksize > maxstksize)
maxstksize = stksize;
ptxt->to.offset = rnd(maxstksize+maxarg, maxround);
maxstksize = 0;
if(debug['f'])
frame(0);
ret:
lineno = lno;
}
void
clearfat(Node *nl)
{
fatal("clearfat");
}
/*
* generate:
* call f
* proc=0 normal call
* proc=1 goroutine run in new proc
* proc=2 defer call save away stack
*/
void
ginscall(Node *f, int proc)
{
// Prog *p;
// Node reg, con;
// switch(proc) {
// default:
// fatal("ginscall: bad proc %d", proc);
// break;
// case 0: // normal call
// p = gins(ACALL, N, f);
// afunclit(&p->to);
// break;
// case 1: // call in new proc (go)
// case 2: // defered call (defer)
// nodreg(&reg, types[TINT32], D_AX);
// gins(APUSHL, f, N);
// nodconst(&con, types[TINT32], argsize(f->type));
// gins(APUSHL, &con, N);
// if(proc == 1)
// ginscall(newproc, 0);
// else
// ginscall(deferproc, 0);
// gins(APOPL, N, &reg);
// gins(APOPL, N, &reg);
// break;
// }
}
/*
* n is call to interface method.
* generate res = n.
*/
void
cgen_callinter(Node *n, Node *res, int proc)
{
fatal("cgen_call");
}
/*
* generate function call;
* proc=0 normal call
* proc=1 goroutine run in new proc
* proc=2 defer call save away stack
*/
void
cgen_call(Node *n, int proc)
{
fatal("cgen_call_unimplemented");
// Type *t;
// Node nod, afun;
// if(n == N)
// return;
// if(n->left->ullman >= UINF) {
// // if name involves a fn call
// // precompute the address of the fn
// tempalloc(&afun, types[tptr]);
// cgen(n->left, &afun);
// }
// gen(n->right); // assign the args
// t = n->left->type;
// setmaxarg(t);
// // call tempname pointer
// if(n->left->ullman >= UINF) {
// regalloc(&nod, types[tptr], N);
// cgen_as(&nod, &afun);
// tempfree(&afun);
// nod.type = t;
// ginscall(&nod, proc);
// regfree(&nod);
// return;
// }
// // call pointer
// if(n->left->op != ONAME || n->left->class != PFUNC) {
// regalloc(&nod, types[tptr], N);
// cgen_as(&nod, n->left);
// nod.type = t;
// ginscall(&nod, proc);
// regfree(&nod);
// return;
// }
// // call direct
// n->left->method = 1;
// ginscall(n->left, proc);
}
/*
* call to n has already been generated.
* generate:
* res = return value from call.
*/
void
cgen_callret(Node *n, Node *res)
{
fatal("cgen_callret_unimplemented");
// Node nod;
// Type *fp, *t;
// Iter flist;
// t = n->left->type;
// if(t->etype == TPTR32 || t->etype == TPTR64)
// t = t->type;
// fp = structfirst(&flist, getoutarg(t));
// if(fp == T)
// fatal("cgen_callret: nil");
// memset(&nod, 0, sizeof(nod));
// nod.op = OINDREG;
// nod.val.u.reg = D_SP;
// nod.addable = 1;
// nod.xoffset = fp->width;
// nod.type = fp->type;
// cgen_as(res, &nod);
}
/*
* call to n has already been generated.
* generate:
* res = &return value from call.
*/
void
cgen_aret(Node *n, Node *res)
{
// Node nod1, nod2;
// Type *fp, *t;
// Iter flist;
// t = n->left->type;
// if(isptr[t->etype])
// t = t->type;
// fp = structfirst(&flist, getoutarg(t));
// if(fp == T)
// fatal("cgen_aret: nil");
// memset(&nod1, 0, sizeof(nod1));
// nod1.op = OINDREG;
// nod1.val.u.reg = D_SP;
// nod1.addable = 1;
// nod1.xoffset = fp->width;
// nod1.type = fp->type;
// if(res->op != OREGISTER) {
// regalloc(&nod2, types[tptr], res);
// gins(ALEAL, &nod1, &nod2);
// gins(AMOVL, &nod2, res);
// regfree(&nod2);
// } else
// gins(ALEAL, &nod1, res);
}
/*
* generate return.
* n->left is assignments to return values.
*/
void
cgen_ret(Node *n)
{
gen(n->left); // copy out args
if(hasdefer)
ginscall(deferreturn, 0);
gins(ARET, N, N);
}
/*
* generate += *= etc.
*/
void
cgen_asop(Node *n)
{
fatal("cgen_asop");
}
/*
* generate division according to op, one of:
* res = nl / nr
* res = nl % nr
*/
void
cgen_div(int op, Node *nl, Node *nr, Node *res)
{
fatal("cgen_div");
}
/*
* generate shift according to op, one of:
* res = nl << nr
* res = nl >> nr
*/
void
cgen_shift(int op, Node *nl, Node *nr, Node *res)
{
fatal("cgen_shift");
}
/*
* generate byte multiply:
* res = nl * nr
* no byte multiply instruction so have to do
* 16-bit multiply and take bottom half.
*/
void
cgen_bmul(int op, Node *nl, Node *nr, Node *res)
{
fatal("cgen_bmul");
}

144
src/cmd/5g/gg.h Normal file
View File

@ -0,0 +1,144 @@
// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
#include <u.h>
#include <libc.h>
#include "../gc/go.h"
#include "../5l/5.out.h"
#ifndef EXTERN
#define EXTERN extern
#endif
typedef struct Addr Addr;
struct Addr
{
int32 offset;
int32 offset2;
double dval;
Prog* branch;
char sval[NSNAME];
Sym* sym;
uchar type;
uchar index;
uchar etype;
uchar scale; /* doubles as width in DATA op */
};
#define A ((Addr*)0)
struct Prog
{
short as; // opcode
uint32 loc; // pc offset in this func
uint32 lineno; // source line that generated this
Addr from; // src address
Addr to; // dst address
Prog* link; // next instruction in this func
void* reg; // pointer to containing Reg struct
};
EXTERN Biobuf* bout;
EXTERN int32 dynloc;
EXTERN uchar reg[D_NONE];
EXTERN int32 pcloc; // instruction counter
/*EXTERN String emptystring;*/
extern char* anames[];
EXTERN Hist* hist;
EXTERN Prog zprog;
EXTERN Node* curfn;
EXTERN Node* newproc;
EXTERN Node* deferproc;
EXTERN Node* deferreturn;
EXTERN Node* throwindex;
EXTERN Node* throwreturn;
EXTERN int maxstksize;
/*
* gen.c
*/
void compile(Node*);
void proglist(void);
void gen(Node*);
Node* lookdot(Node*, Node*, int);
void cgen_as(Node*, Node*);
void cgen_callmeth(Node*, int);
void cgen_callinter(Node*, Node*, int);
void cgen_proc(Node*, int);
void cgen_callret(Node*, Node*);
void cgen_div(int, Node*, Node*, Node*);
void cgen_bmul(int, Node*, Node*, Node*);
void cgen_shift(int, Node*, Node*, Node*);
void cgen_dcl(Node*);
int needconvert(Type*, Type*);
void genconv(Type*, Type*);
void allocparams(void);
void checklabels();
void ginscall(Node*, int);
/*
* cgen
*/
void agen(Node*, Node*);
void igen(Node*, Node*, Node*);
vlong fieldoffset(Type*, Node*);
void bgen(Node*, int, Prog*);
void sgen(Node*, Node*, int32);
void gmove(Node*, Node*);
Prog* gins(int, Node*, Node*);
int samaddr(Node*, Node*);
void naddr(Node*, Addr*);
void cgen_aret(Node*, Node*);
int cgen64(Node*, Node*);
int is64(Type*);
/*
* gsubr.c
*/
void clearp(Prog*);
void proglist(void);
Prog* gbranch(int, Type*);
Prog* prog(int);
void gaddoffset(Node*);
void gconv(int, int);
int conv2pt(Type*);
vlong convvtox(vlong, int);
void fnparam(Type*, int, int);
Prog* gop(int, Node*, Node*, Node*);
void setconst(Addr*, vlong);
void setaddr(Addr*, Node*);
int optoas(int, Type*);
void ginit(void);
void gclean(void);
void regalloc(Node*, Type*, Node*);
void regfree(Node*);
void tempalloc(Node*, Type*);
void tempfree(Node*);
Node* nodarg(Type*, int);
void nodreg(Node*, Type*, int);
void nodindreg(Node*, Type*, int);
void nodconst(Node*, Type*, int64);
void gconreg(int, vlong, int);
void buildtxt(void);
Plist* newplist(void);
int isfat(Type*);
void sudoclean(void);
int sudoaddable(Node*, Addr*);
void afunclit(Addr*);
/*
* list.c
*/
int Aconv(Fmt*);
int Dconv(Fmt*);
int Pconv(Fmt*);
int Rconv(Fmt*);
int Yconv(Fmt*);
void listinit(void);
void zaddr(Biobuf*, Addr*, int);

1984
src/cmd/5g/gsubr.c Normal file
View File

File diff suppressed because it is too large Load Diff

300
src/cmd/5g/list.c Normal file
View File

@ -0,0 +1,300 @@
// Derived from Inferno utils/5c/list.c
// http://code.google.com/p/inferno-os/source/browse/utils/5c/list.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.
#include "gg.h"
static int sconsize;
void
listinit(void)
{
fmtinstall('A', Aconv); // as
fmtinstall('P', Pconv); // Prog*
fmtinstall('D', Dconv); // Addr*
fmtinstall('R', Rconv); // reg
fmtinstall('Y', Yconv); // sconst
}
int
Pconv(Fmt *fp)
{
char str[STRINGSZ];
Prog *p;
p = va_arg(fp->args, Prog*);
sconsize = 8;
switch(p->as) {
default:
snprint(str, sizeof(str), "%.4ld (%4ld) %-7A %D,%D",
p->loc, p->lineno, p->as, &p->from, &p->to);
break;
case ADATA:
sconsize = p->from.scale;
snprint(str, sizeof(str), "%.4ld (%4ld) %-7A %D/%d,%D",
p->loc, p->lineno, p->as, &p->from, sconsize, &p->to);
break;
case ATEXT:
snprint(str, sizeof(str), "%.4ld (%4ld) %-7A %D,%lD",
p->loc, p->lineno, p->as, &p->from, &p->to);
break;
}
return fmtstrcpy(fp, str);
}
int
Dconv(Fmt *fp)
{
char str[100], s[100];
Addr *a;
int i;
uint32 d1, d2;
a = va_arg(fp->args, Addr*);
i = a->type;
// TODO(kaib): add back
// if(i >= D_INDIR) {
// if(a->offset)
// snprint(str, sizeof(str), "%ld(%R)", a->offset, i-D_INDIR);
// else
// snprint(str, sizeof(str), "(%R)", i-D_INDIR);
// goto brk;
// }
switch(i) {
default:
if(a->offset)
snprint(str, sizeof(str), "$%ld,%R", a->offset, i);
else
snprint(str, sizeof(str), "%R", i);
break;
case D_NONE:
str[0] = 0;
break;
case D_BRANCH:
snprint(str, sizeof(str), "%ld", a->branch->loc);
break;
case D_EXTERN:
snprint(str, sizeof(str), "%S+%ld(SB)", a->sym, a->offset);
break;
case D_STATIC:
snprint(str, sizeof(str), "%S<>+%ld(SB)", a->sym, a->offset);
break;
case D_AUTO:
snprint(str, sizeof(str), "%S+%ld(SP)", a->sym, a->offset);
break;
case D_PARAM:
snprint(str, sizeof(str), "%S+%ld(FP)", a->sym, a->offset);
break;
case D_CONST:
if(fp->flags & FmtLong) {
d1 = a->offset;
d2 = a->offset2;
snprint(str, sizeof(str), "$%lud-%lud", (ulong)d1, (ulong)d2);
break;
}
snprint(str, sizeof(str), "$%ld", a->offset);
break;
case D_FCONST:
snprint(str, sizeof(str), "$(%.17e)", a->dval);
break;
case D_SCONST:
snprint(str, sizeof(str), "$\"%Y\"", a->sval);
break;
// TODO(kaib): add back
// case D_ADDR:
// a->type = a->index;
// a->index = D_NONE;
// snprint(str, sizeof(str), "$%D", a);
// a->index = a->type;
// a->type = D_ADDR;
// goto conv;
}
brk:
if(a->index != D_NONE) {
snprint(s, sizeof(s), "(%R*%d)", (int)a->index, (int)a->scale);
strcat(str, s);
}
conv:
return fmtstrcpy(fp, str);
}
static char* regstr[] =
{
"AL", /* [D_AL] */
"CL",
"DL",
"BL",
"AH", /* [D_AH] */
"CH",
"DH",
"BH",
"AX", /* [D_AX] */
"CX",
"DX",
"BX",
"SP",
"BP",
"SI",
"DI",
"F0", /* [D_F0] */
"F1",
"F2",
"F3",
"F4",
"F5",
"F6",
"F7",
"CS", /* [D_CS] */
"SS",
"DS",
"ES",
"FS",
"GS",
"GDTR", /* [D_GDTR] */
"IDTR", /* [D_IDTR] */
"LDTR", /* [D_LDTR] */
"MSW", /* [D_MSW] */
"TASK", /* [D_TASK] */
"CR0", /* [D_CR] */
"CR1",
"CR2",
"CR3",
"CR4",
"CR5",
"CR6",
"CR7",
"DR0", /* [D_DR] */
"DR1",
"DR2",
"DR3",
"DR4",
"DR5",
"DR6",
"DR7",
"TR0", /* [D_TR] */
"TR1",
"TR2",
"TR3",
"TR4",
"TR5",
"TR6",
"TR7",
"NONE", /* [D_NONE] */
};
int
Rconv(Fmt *fp)
{
char str[STRINGSZ];
int r;
r = va_arg(fp->args, int);
if(r < 0 || r >= nelem(regstr) || regstr[r] == nil) {
snprint(str, sizeof(str), "BAD_R(%d)", r);
return fmtstrcpy(fp, str);
}
return fmtstrcpy(fp, regstr[r]);
}
int
Aconv(Fmt *fp)
{
int i;
i = va_arg(fp->args, int);
return fmtstrcpy(fp, anames[i]);
}
int
Yconv(Fmt *fp)
{
int i, c;
char str[30], *p, *a;
a = va_arg(fp->args, char*);
p = str;
for(i=0; i<sconsize; i++) {
c = a[i] & 0xff;
if((c >= 'a' && c <= 'z') ||
(c >= 'A' && c <= 'Z') ||
(c >= '0' && c <= '9')) {
*p++ = c;
continue;
}
*p++ = '\\';
switch(c) {
default:
if(c < 040 || c >= 0177)
break; /* not portable */
p[-1] = c;
continue;
case 0:
*p++ = 'z';
continue;
case '\\':
case '"':
*p++ = c;
continue;
case '\n':
*p++ = 'n';
continue;
case '\t':
*p++ = 't';
continue;
}
*p++ = (c>>6) + '0';
*p++ = ((c>>3) & 7) + '0';
*p++ = (c & 7) + '0';
}
*p = 0;
return fmtstrcpy(fp, str);
}

531
src/cmd/5g/obj.c Normal file
View File

@ -0,0 +1,531 @@
// Derived from Inferno utils/5c/swt.c
// http://code.google.com/p/inferno-os/source/browse/utils/5c/swt.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.
#include "gg.h"
void
zname(Biobuf *b, Sym *s, int t)
{
char *n;
Bputc(b, ANAME); /* as */
Bputc(b, ANAME>>8); /* as */
Bputc(b, t); /* type */
Bputc(b, s->sym); /* sym */
for(n=s->opackage; *n; n++)
Bputc(b, *n);
Bputdot(b);
for(n=s->name; *n; n++)
Bputc(b, *n);
Bputc(b, 0);
}
void
zfile(Biobuf *b, char *p, int n)
{
Bputc(b, ANAME);
Bputc(b, ANAME>>8);
Bputc(b, D_FILE);
Bputc(b, 1);
Bputc(b, '<');
Bwrite(b, p, n);
Bputc(b, 0);
}
void
zhist(Biobuf *b, int line, vlong offset)
{
Addr a;
Bputc(b, AHISTORY);
Bputc(b, AHISTORY>>8);
Bputc(b, line);
Bputc(b, line>>8);
Bputc(b, line>>16);
Bputc(b, line>>24);
zaddr(b, &zprog.from, 0);
a = zprog.to;
if(offset != 0) {
a.offset = offset;
a.type = D_CONST;
}
zaddr(b, &a, 0);
}
void
zaddr(Biobuf *b, Addr *a, int s)
{
// int32 l;
// uint64 e;
// int i, t;
// char *n;
// t = 0;
// if(a->index != D_NONE || a->scale != 0)
// t |= T_INDEX;
// if(s != 0)
// t |= T_SYM;
// switch(a->type) {
// case D_BRANCH:
// a->offset = a->branch->loc;
// default:
// t |= T_TYPE;
// case D_NONE:
// if(a->offset != 0)
// t |= T_OFFSET;
// if(a->offset2 != 0)
// t |= T_OFFSET2;
// break;
// case D_FCONST:
// t |= T_FCONST;
// break;
// case D_SCONST:
// t |= T_SCONST;
// break;
// }
// Bputc(b, t);
// if(t & T_INDEX) { /* implies index, scale */
// Bputc(b, a->index);
// Bputc(b, a->scale);
// }
// if(t & T_OFFSET) { /* implies offset */
// l = a->offset;
// Bputc(b, l);
// Bputc(b, l>>8);
// Bputc(b, l>>16);
// Bputc(b, l>>24);
// }
// if(t & T_OFFSET2) { /* implies offset */
// l = a->offset2;
// Bputc(b, l);
// Bputc(b, l>>8);
// Bputc(b, l>>16);
// Bputc(b, l>>24);
// }
// if(t & T_SYM) /* implies sym */
// Bputc(b, s);
// if(t & T_FCONST) {
// ieeedtod(&e, a->dval);
// l = e;
// Bputc(b, l);
// Bputc(b, l>>8);
// Bputc(b, l>>16);
// Bputc(b, l>>24);
// l = e >> 32;
// Bputc(b, l);
// Bputc(b, l>>8);
// Bputc(b, l>>16);
// Bputc(b, l>>24);
// return;
// }
// if(t & T_SCONST) {
// n = a->sval;
// for(i=0; i<NSNAME; i++) {
// Bputc(b, *n);
// n++;
// }
// return;
// }
// if(t & T_TYPE)
// Bputc(b, a->type);
}
void
dumpfuncs(void)
{
Plist *pl;
int sf, st, t, sym;
struct { Sym *sym; short type; } h[NSYM];
Sym *s;
Prog *p;
for(sym=0; sym<NSYM; sym++) {
h[sym].sym = S;
h[sym].type = 0;
}
sym = 1;
// fix up pc
pcloc = 0;
for(pl=plist; pl!=nil; pl=pl->link) {
for(p=pl->firstpc; p!=P; p=p->link) {
p->loc = pcloc;
pcloc++;
}
}
// put out functions
for(pl=plist; pl!=nil; pl=pl->link) {
if(debug['S']) {
s = S;
if(pl->name != N)
s = pl->name->sym;
print("\n--- prog list \"%S\" ---\n", s);
for(p=pl->firstpc; p!=P; p=p->link)
print("%P\n", p);
}
for(p=pl->firstpc; p!=P; p=p->link) {
jackpot:
sf = 0;
s = p->from.sym;
while(s != S) {
sf = s->sym;
if(sf < 0 || sf >= NSYM)
sf = 0;
t = p->from.type;
if(t == D_ADDR)
t = p->from.index;
if(h[sf].type == t)
if(h[sf].sym == s)
break;
s->sym = sym;
zname(bout, s, t);
h[sym].sym = s;
h[sym].type = t;
sf = sym;
sym++;
if(sym >= NSYM)
sym = 1;
break;
}
st = 0;
s = p->to.sym;
while(s != S) {
st = s->sym;
if(st < 0 || st >= NSYM)
st = 0;
t = p->to.type;
if(t == D_ADDR)
t = p->to.index;
if(h[st].type == t)
if(h[st].sym == s)
break;
s->sym = sym;
zname(bout, s, t);
h[sym].sym = s;
h[sym].type = t;
st = sym;
sym++;
if(sym >= NSYM)
sym = 1;
if(st == sf)
goto jackpot;
break;
}
Bputc(bout, p->as);
Bputc(bout, p->as>>8);
Bputc(bout, p->lineno);
Bputc(bout, p->lineno>>8);
Bputc(bout, p->lineno>>16);
Bputc(bout, p->lineno>>24);
zaddr(bout, &p->from, sf);
zaddr(bout, &p->to, st);
}
}
}
void
datastring(char *s, int len)
{
// int w;
// Prog *p;
// Addr ac, ao;
// // string
// memset(&ao, 0, sizeof(ao));
// ao.type = D_STATIC;
// ao.index = D_NONE;
// ao.etype = TINT32;
// ao.sym = symstringo;
// ao.offset = 0; // fill in
// // constant
// memset(&ac, 0, sizeof(ac));
// ac.type = D_CONST;
// ac.index = D_NONE;
// ac.offset = 0; // fill in
// for(w=0; w<len; w+=8) {
// p = pc;
// gins(ADATA, N, N);
// // .stringo<>+oo, [NSNAME], $"xxx"
// p->from = ao;
// p->from.offset = stringo;
// p->from.scale = NSNAME;
// if(w+8 > len)
// p->from.scale = len-w;
// p->to = ac;
// p->to.type = D_SCONST;
// p->to.offset = len;
// memmove(p->to.sval, s+w, p->from.scale);
// stringo += p->from.scale;
// }
}
void
dumpstrings(void)
{
// Pool *l;
// Prog *p;
// Addr ac, ao;
// int32 wi;
// if(poolist == nil)
// return;
// memset(&ac, 0, sizeof(ac));
// memset(&ao, 0, sizeof(ao));
// // constant
// ac.type = D_CONST;
// ac.index = D_NONE;
// ac.offset = 0; // fill in
// // string len+ptr
// ao.type = D_STATIC;
// ao.index = D_NONE;
// ao.etype = TINT32;
// ao.sym = symstringo;
// ao.offset = 0; // fill in
// wi = types[TINT32]->width;
// // lay out (count+string)
// for(l=poolist; l!=nil; l=l->link) {
// p = pc;
// gins(ADATA, N, N);
// // .stringo<>+xx, wi, $len
// stringo = rnd(stringo, wi);
// p->from = ao;
// p->from.offset = stringo;
// p->from.scale = wi;
// p->to = ac;
// p->to.offset = l->sval->len;
// stringo += wi;
// datastring(l->sval->s, l->sval->len);
// }
}
int
dstringptr(Sym *s, int off, char *str)
{
// Prog *p;
// off = rnd(off, widthptr);
// p = gins(ADATA, N, N);
// p->from.type = D_EXTERN;
// p->from.index = D_NONE;
// p->from.sym = s;
// p->from.offset = off;
// p->from.scale = widthptr;
// p->to.type = D_ADDR;
// p->to.index = D_STATIC;
// p->to.etype = TINT32;
// p->to.sym = symstringo;
// p->to.offset = stringo;
// off += widthptr;
// datastring(str, strlen(str)+1);
return off;
}
int
duintxx(Sym *s, int off, uint64 v, int wid)
{
// Prog *p;
// off = rnd(off, wid);
// p = gins(ADATA, N, N);
// p->from.type = D_EXTERN;
// p->from.index = D_NONE;
// p->from.sym = s;
// p->from.offset = off;
// p->from.scale = wid;
// p->to.type = D_CONST;
// p->to.index = D_NONE;
// p->to.offset = v;
// off += wid;
return off;
}
int
duint32(Sym *s, int off, uint32 v)
{
return duintxx(s, off, v, 4);
}
int
duint16(Sym *s, int off, uint32 v)
{
return duintxx(s, off, v, 2);
}
int
duintptr(Sym *s, int off, uint32 v)
{
return duintxx(s, off, v, 8);
}
int
dsymptr(Sym *s, int off, Sym *x)
{
// Prog *p;
// off = rnd(off, widthptr);
// p = gins(ADATA, N, N);
// p->from.type = D_EXTERN;
// p->from.index = D_NONE;
// p->from.sym = s;
// p->from.offset = off;
// p->from.scale = widthptr;
// p->to.type = D_ADDR;
// p->to.index = D_EXTERN;
// p->to.sym = x;
// p->to.offset = 0;
// off += widthptr;
return off;
}
void
genembedtramp(Type *t, Sig *b)
{
// Sym *e;
// int c, d, o;
// Prog *p;
// Type *f;
// e = lookup(b->name);
// for(d=0; d<nelem(dotlist); d++) {
// c = adddot1(e, t, d, nil);
// if(c == 1)
// goto out;
// }
// fatal("genembedtramp %T.%s", t, b->name);
// out:
// if(d == 0)
// return;
// // print("genembedtramp %d\n", d);
// // print(" t = %lT\n", t);
// // print(" name = %s\n", b->name);
// // print(" sym = %S\n", b->sym);
// // print(" hash = 0x%ux\n", b->hash);
// newplist()->name = newname(b->sym);
// //TEXT main·S_test2(SB),7,$0
// p = pc;
// gins(ATEXT, N, N);
// p->from.type = D_EXTERN;
// p->from.sym = b->sym;
// p->to.type = D_CONST;
// p->to.offset = 0;
// p->from.scale = 7;
// //print("1. %P\n", p);
// //MOVL 4(SP), AX
// p = pc;
// gins(AMOVL, N, N);
// p->from.type = D_INDIR+D_SP;
// p->from.offset = 4;
// p->to.type = D_AX;
// //print("2. %P\n", p);
// o = 0;
// for(c=d-1; c>=0; c--) {
// f = dotlist[c].field;
// o += f->width;
// if(!isptr[f->type->etype])
// continue;
// //MOVL o(AX), AX
// p = pc;
// gins(AMOVL, N, N);
// p->from.type = D_INDIR+D_AX;
// p->from.offset = o;
// p->to.type = D_AX;
// //print("3. %P\n", p);
// o = 0;
// }
// if(o != 0) {
// //ADDL $XX, AX
// p = pc;
// gins(AADDL, N, N);
// p->from.type = D_CONST;
// p->from.offset = o;
// p->to.type = D_AX;
// //print("4. %P\n", p);
// }
// //MOVL AX, 4(SP)
// p = pc;
// gins(AMOVL, N, N);
// p->from.type = D_AX;
// p->to.type = D_INDIR+D_SP;
// p->to.offset = 8;
// //print("5. %P\n", p);
// f = dotlist[0].field;
// //JMP main·*Sub_test2(SB)
// if(isptr[f->type->etype])
// f = f->type;
// p = pc;
// gins(AJMP, N, N);
// p->to.type = D_EXTERN;
// p->to.sym = methodsym(lookup(b->name), ptrto(f->type));
// //print("6. %P\n", p);
// pc->as = ARET; // overwrite AEND
}
void
nopout(Prog *p)
{
p->as = ANOP;
}

3
src/cmd/5l/5.out.h
View File

@ -201,7 +201,8 @@ enum as
#define D_SHIFT (D_NONE+19)
#define D_FPCR (D_NONE+20)
#define D_REGREG (D_NONE+21)
#define D_REGREG (D_NONE+21)
#define D_ADDR (D_NONE+22)
/* name */
#define D_EXTERN (D_NONE+3)