src/cmd/6c/gc.h - go - Git at Google

 // Inferno utils/6c/gc.h
 // http://code.google.com/p/inferno-os/source/browse/utils/6c/gc.h
 //
 //	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	<u.h>
 #include	"../cc/cc.h"
 #include	"../6l/6.out.h"

 /*
  * 6c/amd64
  * Intel 386 with AMD64 extensions
  */
 #define	SZ_CHAR		1
 #define	SZ_SHORT	2
 #define	SZ_INT		4
 #define	SZ_LONG		4
 #define	SZ_IND		8
 #define	SZ_FLOAT	4
 #define	SZ_VLONG	8
 #define	SZ_DOUBLE	8
 #define	FNX		100

 typedef	struct	Adr	Adr;
 typedef	struct	Prog	Prog;
 typedef	struct	Case	Case;
 typedef	struct	C1	C1;
 typedef	struct	Var	Var;
 typedef	struct	Reg	Reg;
 typedef	struct	Rgn	Rgn;
 typedef	struct	Renv	Renv;

 EXTERN	struct
 {
 	Node*	regtree;
 	Node*	basetree;
 	short	scale;
 	short	reg;
 	short	ptr;
 } idx;

 struct	Adr
 {
 	vlong	offset;
 	double	dval;
 	char	sval[NSNAME];

 	Sym*	sym;
 	uchar	type;
 	uchar	index;
 	uchar	etype;
 	uchar	scale;	/* doubles as width in DATA op */
 };
 #define	A	((Adr*)0)

 #define	INDEXED	9
 struct	Prog
 {
 	Adr	from;
 	Adr	to;
 	Prog*	link;
 	int32	lineno;
 	short	as;
 };
 #define	P	((Prog*)0)

 struct	Case
 {
 	Case*	link;
 	vlong	val;
 	int32	label;
 	char	def;
 	char	isv;
 };
 #define	C	((Case*)0)

 struct	C1
 {
 	vlong	val;
 	int32	label;
 };

 struct	Var
 {
 	vlong	offset;
 	Sym*	sym;
 	char	name;
 	char	etype;
 };

 struct	Reg
 {
 	int32	pc;
 	int32	rpo;		/* reverse post ordering */

 	Bits	set;
 	Bits	use1;
 	Bits	use2;

 	Bits	refbehind;
 	Bits	refahead;
 	Bits	calbehind;
 	Bits	calahead;
 	Bits	regdiff;
 	Bits	act;

 	int32	regu;
 	int32	loop;		/* could be shorter */

 	Reg*	log5;
 	int32	active;

 	Reg*	p1;
 	Reg*	p2;
 	Reg*	p2link;
 	Reg*	s1;
 	Reg*	s2;
 	Reg*	link;
 	Prog*	prog;
 };
 #define	R	((Reg*)0)

 struct	Renv
 {
 	int	safe;
 	Node	base;
 	Node*	saved;
 	Node*	scope;
 };

 #define	NRGN	600
 struct	Rgn
 {
 	Reg*	enter;
 	short	cost;
 	short	varno;
 	short	regno;
 };

 EXTERN	int32	breakpc;
 EXTERN	int32	nbreak;
 EXTERN	Case*	cases;
 EXTERN	Node	constnode;
 EXTERN	Node	fconstnode;
 EXTERN	Node	vconstnode;
 EXTERN	int32	continpc;
 EXTERN	int32	curarg;
 EXTERN	int32	cursafe;
 EXTERN	Prog*	firstp;
 EXTERN	Prog*	lastp;
 EXTERN	int32	maxargsafe;
 EXTERN	int	mnstring;
 EXTERN	int	retok;
 EXTERN	Node*	nodrat;
 EXTERN	Node*	nodret;
 EXTERN	Node*	nodsafe;
 EXTERN	int32	nrathole;
 EXTERN	int32	nstring;
 EXTERN	Prog*	p;
 EXTERN	int32	pc;
 EXTERN	Node	lregnode;
 EXTERN	Node	qregnode;
 EXTERN	char	string[NSNAME];
 EXTERN	Sym*	symrathole;
 EXTERN	Node	znode;
 EXTERN	Prog	zprog;
 EXTERN	int	reg[D_NONE];
 EXTERN	int32	exregoffset;
 EXTERN	int32	exfregoffset;
 EXTERN	uchar	typechlpv[NTYPE];

 #define	BLOAD(r)	band(bnot(r->refbehind), r->refahead)
 #define	BSTORE(r)	band(bnot(r->calbehind), r->calahead)
 #define	LOAD(r)		(~r->refbehind.b[z] & r->refahead.b[z])
 #define	STORE(r)	(~r->calbehind.b[z] & r->calahead.b[z])

 #define	bset(a,n)	((a).b[(n)/32]&(1L<<(n)%32))

 #define	CLOAD	5
 #define	CREF	5
 #define	CINF	1000
 #define	LOOP	3

 EXTERN	Rgn	region[NRGN];
 EXTERN	Rgn*	rgp;
 EXTERN	int	nregion;
 EXTERN	int	nvar;

 EXTERN	Bits	externs;
 EXTERN	Bits	params;
 EXTERN	Bits	consts;
 EXTERN	Bits	addrs;

 EXTERN	int32	regbits;
 EXTERN	int32	exregbits;

 EXTERN	int	change;
 EXTERN	int	suppress;

 EXTERN	Reg*	firstr;
 EXTERN	Reg*	lastr;
 EXTERN	Reg	zreg;
 EXTERN	Reg*	freer;
 EXTERN	Var	var[NVAR];
 EXTERN	int32*	idom;
 EXTERN	Reg**	rpo2r;
 EXTERN	int32	maxnr;

 extern	char*	anames[];

 /*
  * sgen.c
  */
 void	codgen(Node*, Node*);
 void	gen(Node*);
 void	noretval(int);
 void	usedset(Node*, int);
 void	xcom(Node*);
 void	indx(Node*);
 int	bcomplex(Node*, Node*);
 Prog*	gtext(Sym*, int32);
 vlong	argsize(void);

 /*
  * cgen.c
  */
 void	zeroregm(Node*);
 void	cgen(Node*, Node*);
 void	reglcgen(Node*, Node*, Node*);
 void	lcgen(Node*, Node*);
 void	bcgen(Node*, int);
 void	boolgen(Node*, int, Node*);
 void	sugen(Node*, Node*, int32);
 int	needreg(Node*, int);
 int	hardconst(Node*);
 int	immconst(Node*);

 /*
  * txt.c
  */
 void	ginit(void);
 void	gclean(void);
 void	nextpc(void);
 void	gargs(Node*, Node*, Node*);
 void	garg1(Node*, Node*, Node*, int, Node**);
 Node*	nodconst(int32);
 Node*	nodfconst(double);
 Node*	nodgconst(vlong, Type*);
 int	nodreg(Node*, Node*, int);
 int	isreg(Node*, int);
 void	regret(Node*, Node*);
 void	regalloc(Node*, Node*, Node*);
 void	regfree(Node*);
 void	regialloc(Node*, Node*, Node*);
 void	regsalloc(Node*, Node*);
 void	regaalloc1(Node*, Node*);
 void	regaalloc(Node*, Node*);
 void	regind(Node*, Node*);
 void	gprep(Node*, Node*);
 void	naddr(Node*, Adr*);
 void	gcmp(int, Node*, vlong);
 void	gmove(Node*, Node*);
 void	gins(int a, Node*, Node*);
 void	gopcode(int, Type*, Node*, Node*);
 int	samaddr(Node*, Node*);
 void	gbranch(int);
 void	patch(Prog*, int32);
 int	sconst(Node*);
 void	gpseudo(int, Sym*, Node*);

 /*
  * swt.c
  */
 int	swcmp(const void*, const void*);
 void	doswit(Node*);
 void	swit1(C1*, int, int32, Node*);
 void	cas(void);
 void	bitload(Node*, Node*, Node*, Node*, Node*);
 void	bitstore(Node*, Node*, Node*, Node*, Node*);
 int32	outstring(char*, int32);
 void	nullwarn(Node*, Node*);
 void	sextern(Sym*, Node*, int32, int32);
 void	gextern(Sym*, Node*, int32, int32);
 void	outcode(void);
 void	ieeedtod(Ieee*, double);

 /*
  * list
  */
 void	listinit(void);
 int	Pconv(Fmt*);
 int	Aconv(Fmt*);
 int	Dconv(Fmt*);
 int	Sconv(Fmt*);
 int	Rconv(Fmt*);
 int	Xconv(Fmt*);
 int	Bconv(Fmt*);

 /*
  * reg.c
  */
 Reg*	rega(void);
 int	rcmp(const void*, const void*);
 void	regopt(Prog*);
 void	addmove(Reg*, int, int, int);
 Bits	mkvar(Reg*, Adr*);
 void	prop(Reg*, Bits, Bits);
 void	loopit(Reg*, int32);
 void	synch(Reg*, Bits);
 uint32	allreg(uint32, Rgn*);
 void	paint1(Reg*, int);
 uint32	paint2(Reg*, int);
 void	paint3(Reg*, int, int32, int);
 void	addreg(Adr*, int);

 /*
  * peep.c
  */
 void	peep(void);
 void	excise(Reg*);
 Reg*	uniqp(Reg*);
 Reg*	uniqs(Reg*);
 int	regtyp(Adr*);
 int	anyvar(Adr*);
 int	subprop(Reg*);
 int	copyprop(Reg*);
 int	copy1(Adr*, Adr*, Reg*, int);
 int	copyu(Prog*, Adr*, Adr*);

 int	copyas(Adr*, Adr*);
 int	copyau(Adr*, Adr*);
 int	copysub(Adr*, Adr*, Adr*, int);
 int	copysub1(Prog*, Adr*, Adr*, int);

 int32	RtoB(int);
 int32	FtoB(int);
 int	BtoR(int32);
 int	BtoF(int32);

 #define	D_HI	D_NONE
 #define	D_LO	D_NONE

 #define	isregtype(t)	((t)>= D_AX && (t)<=D_R15)

 /*
  * bound
  */
 void	comtarg(void);

 /*
  * com64
  */
 int	cond(int);
 int	com64(Node*);
 void	com64init(void);
 void	bool64(Node*);
 int32	lo64v(Node*);
 int32	hi64v(Node*);
 Node*	lo64(Node*);
 Node*	hi64(Node*);

 /*
  * div/mul
  */
 void	sdivgen(Node*, Node*, Node*, Node*);
 void	udivgen(Node*, Node*, Node*, Node*);
 void	sdiv2(int32, int, Node*, Node*);
 void	smod2(int32, int, Node*, Node*);
 void	mulgen(Type*, Node*, Node*);
 void	genmuladd(Node*, Node*, int, Node*);
 void	shiftit(Type*, Node*, Node*);

 #pragma	varargck	type	"A"	int
 #pragma	varargck	type	"B"	Bits
 #pragma	varargck	type	"D"	Adr*
 #pragma	varargck	type	"lD"	Adr*
 #pragma	varargck	type	"P"	Prog*
 #pragma	varargck	type	"R"	int
 #pragma	varargck	type	"S"	char*

 #define	D_X7	(D_X0+7)

 void	fgopcode(int, Node*, Node*, int, int);
	// Inferno utils/6c/gc.h
	// http://code.google.com/p/inferno-os/source/browse/utils/6c/gc.h
	//
	// 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 <u.h>
	#include "../cc/cc.h"
	#include "../6l/6.out.h"

	/*
	* 6c/amd64
	* Intel 386 with AMD64 extensions
	*/
	#define SZ_CHAR 1
	#define SZ_SHORT 2
	#define SZ_INT 4
	#define SZ_LONG 4
	#define SZ_IND 8
	#define SZ_FLOAT 4
	#define SZ_VLONG 8
	#define SZ_DOUBLE 8
	#define FNX 100

	typedef struct Adr Adr;
	typedef struct Prog Prog;
	typedef struct Case Case;
	typedef struct C1 C1;
	typedef struct Var Var;
	typedef struct Reg Reg;
	typedef struct Rgn Rgn;
	typedef struct Renv Renv;

	EXTERN struct
	{
	Node* regtree;
	Node* basetree;
	short scale;
	short reg;
	short ptr;
	} idx;

	struct Adr
	{
	vlong offset;
	double dval;
	char sval[NSNAME];

	Sym* sym;
	uchar type;
	uchar index;
	uchar etype;
	uchar scale; /* doubles as width in DATA op */
	};
	#define A ((Adr*)0)

	#define INDEXED 9
	struct Prog
	{
	Adr from;
	Adr to;
	Prog* link;
	int32 lineno;
	short as;
	};
	#define P ((Prog*)0)

	struct Case
	{
	Case* link;
	vlong val;
	int32 label;
	char def;
	char isv;
	};
	#define C ((Case*)0)

	struct C1
	{
	vlong val;
	int32 label;
	};

	struct Var
	{
	vlong offset;
	Sym* sym;
	char name;
	char etype;
	};

	struct Reg
	{
	int32 pc;
	int32 rpo; /* reverse post ordering */

	Bits set;
	Bits use1;
	Bits use2;

	Bits refbehind;
	Bits refahead;
	Bits calbehind;
	Bits calahead;
	Bits regdiff;
	Bits act;

	int32 regu;
	int32 loop; /* could be shorter */

	Reg* log5;
	int32 active;

	Reg* p1;
	Reg* p2;
	Reg* p2link;
	Reg* s1;
	Reg* s2;
	Reg* link;
	Prog* prog;
	};
	#define R ((Reg*)0)

	struct Renv
	{
	int safe;
	Node base;
	Node* saved;
	Node* scope;
	};

	#define NRGN 600
	struct Rgn
	{
	Reg* enter;
	short cost;
	short varno;
	short regno;
	};

	EXTERN int32 breakpc;
	EXTERN int32 nbreak;
	EXTERN Case* cases;
	EXTERN Node constnode;
	EXTERN Node fconstnode;
	EXTERN Node vconstnode;
	EXTERN int32 continpc;
	EXTERN int32 curarg;
	EXTERN int32 cursafe;
	EXTERN Prog* firstp;
	EXTERN Prog* lastp;
	EXTERN int32 maxargsafe;
	EXTERN int mnstring;
	EXTERN int retok;
	EXTERN Node* nodrat;
	EXTERN Node* nodret;
	EXTERN Node* nodsafe;
	EXTERN int32 nrathole;
	EXTERN int32 nstring;
	EXTERN Prog* p;
	EXTERN int32 pc;
	EXTERN Node lregnode;
	EXTERN Node qregnode;
	EXTERN char string[NSNAME];
	EXTERN Sym* symrathole;
	EXTERN Node znode;
	EXTERN Prog zprog;
	EXTERN int reg[D_NONE];
	EXTERN int32 exregoffset;
	EXTERN int32 exfregoffset;
	EXTERN uchar typechlpv[NTYPE];

	#define BLOAD(r) band(bnot(r->refbehind), r->refahead)
	#define BSTORE(r) band(bnot(r->calbehind), r->calahead)
	#define LOAD(r) (~r->refbehind.b[z] & r->refahead.b[z])
	#define STORE(r) (~r->calbehind.b[z] & r->calahead.b[z])

	#define bset(a,n) ((a).b[(n)/32]&(1L<<(n)%32))

	#define CLOAD 5
	#define CREF 5
	#define CINF 1000
	#define LOOP 3

	EXTERN Rgn region[NRGN];
	EXTERN Rgn* rgp;
	EXTERN int nregion;
	EXTERN int nvar;

	EXTERN Bits externs;
	EXTERN Bits params;
	EXTERN Bits consts;
	EXTERN Bits addrs;

	EXTERN int32 regbits;
	EXTERN int32 exregbits;

	EXTERN int change;
	EXTERN int suppress;

	EXTERN Reg* firstr;
	EXTERN Reg* lastr;
	EXTERN Reg zreg;
	EXTERN Reg* freer;
	EXTERN Var var[NVAR];
	EXTERN int32* idom;
	EXTERN Reg** rpo2r;
	EXTERN int32 maxnr;

	extern char* anames[];

	/*
	* sgen.c
	*/
	void codgen(Node, Node);
	void gen(Node*);
	void noretval(int);
	void usedset(Node*, int);
	void xcom(Node*);
	void indx(Node*);
	int bcomplex(Node, Node);
	Prog* gtext(Sym*, int32);
	vlong argsize(void);

	/*
	* cgen.c
	*/
	void zeroregm(Node*);
	void cgen(Node, Node);
	void reglcgen(Node, Node, Node*);
	void lcgen(Node, Node);
	void bcgen(Node*, int);
	void boolgen(Node, int, Node);
	void sugen(Node, Node, int32);
	int needreg(Node*, int);
	int hardconst(Node*);
	int immconst(Node*);

	/*
	* txt.c
	*/
	void ginit(void);
	void gclean(void);
	void nextpc(void);
	void gargs(Node, Node, Node*);
	void garg1(Node, Node, Node, int, Node*);
	Node* nodconst(int32);
	Node* nodfconst(double);
	Node* nodgconst(vlong, Type*);
	int nodreg(Node, Node, int);
	int isreg(Node*, int);
	void regret(Node, Node);
	void regalloc(Node, Node, Node*);
	void regfree(Node*);
	void regialloc(Node, Node, Node*);
	void regsalloc(Node, Node);
	void regaalloc1(Node, Node);
	void regaalloc(Node, Node);
	void regind(Node, Node);
	void gprep(Node, Node);
	void naddr(Node, Adr);
	void gcmp(int, Node*, vlong);
	void gmove(Node, Node);
	void gins(int a, Node, Node);
	void gopcode(int, Type, Node, Node*);
	int samaddr(Node, Node);
	void gbranch(int);
	void patch(Prog*, int32);
	int sconst(Node*);
	void gpseudo(int, Sym, Node);

	/*
	* swt.c
	*/
	int swcmp(const void, const void);
	void doswit(Node*);
	void swit1(C1, int, int32, Node);
	void cas(void);
	void bitload(Node, Node, Node, Node, Node*);
	void bitstore(Node, Node, Node, Node, Node*);
	int32 outstring(char*, int32);
	void nullwarn(Node, Node);
	void sextern(Sym, Node, int32, int32);
	void gextern(Sym, Node, int32, int32);
	void outcode(void);
	void ieeedtod(Ieee*, double);

	/*
	* list
	*/
	void listinit(void);
	int Pconv(Fmt*);
	int Aconv(Fmt*);
	int Dconv(Fmt*);
	int Sconv(Fmt*);
	int Rconv(Fmt*);
	int Xconv(Fmt*);
	int Bconv(Fmt*);

	/*
	* reg.c
	*/
	Reg* rega(void);
	int rcmp(const void, const void);
	void regopt(Prog*);
	void addmove(Reg*, int, int, int);
	Bits mkvar(Reg, Adr);
	void prop(Reg*, Bits, Bits);
	void loopit(Reg*, int32);
	void synch(Reg*, Bits);
	uint32 allreg(uint32, Rgn*);
	void paint1(Reg*, int);
	uint32 paint2(Reg*, int);
	void paint3(Reg*, int, int32, int);
	void addreg(Adr*, int);

	/*
	* peep.c
	*/
	void peep(void);
	void excise(Reg*);
	Reg* uniqp(Reg*);
	Reg* uniqs(Reg*);
	int regtyp(Adr*);
	int anyvar(Adr*);
	int subprop(Reg*);
	int copyprop(Reg*);
	int copy1(Adr, Adr, Reg*, int);
	int copyu(Prog, Adr, Adr*);

	int copyas(Adr, Adr);
	int copyau(Adr, Adr);
	int copysub(Adr, Adr, Adr*, int);
	int copysub1(Prog, Adr, Adr*, int);

	int32 RtoB(int);
	int32 FtoB(int);
	int BtoR(int32);
	int BtoF(int32);

	#define D_HI D_NONE
	#define D_LO D_NONE

	#define isregtype(t) ((t)>= D_AX && (t)<=D_R15)

	/*
	* bound
	*/
	void comtarg(void);

	/*
	* com64
	*/
	int cond(int);
	int com64(Node*);
	void com64init(void);
	void bool64(Node*);
	int32 lo64v(Node*);
	int32 hi64v(Node*);
	Node* lo64(Node*);
	Node* hi64(Node*);

	/*
	* div/mul
	*/
	void sdivgen(Node, Node, Node, Node);
	void udivgen(Node, Node, Node, Node);
	void sdiv2(int32, int, Node, Node);
	void smod2(int32, int, Node, Node);
	void mulgen(Type, Node, Node*);
	void genmuladd(Node, Node, int, Node*);
	void shiftit(Type, Node, Node*);

	#pragma varargck type "A" int
	#pragma varargck type "B" Bits
	#pragma varargck type "D" Adr*
	#pragma varargck type "lD" Adr*
	#pragma varargck type "P" Prog*
	#pragma varargck type "R" int
	#pragma varargck type "S" char*

	#define D_X7 (D_X0+7)

	void fgopcode(int, Node, Node, int, int);