llvm/lib/CodeGen/TargetMachine/Sparc/Sparc.burg - toolchain/llvm-project - Gitiles

 %{
 #include <stdio.h>
 #include <llvm/Codegen/InstrForest.h>

 typedef BasicTreeNode* NODEPTR_TYPE;
 #define OP_LABEL(p)	((p)->opLabel)
 #define LEFT_CHILD(p)	((p)->leftChild)
 #define RIGHT_CHILD(p)	((p)->rightChild)
 #define STATE_LABEL(p)	((p)->state)
 #define PANIC		printf
 %}

 %start stmt

 %term Ret=1		/* return void from a function */
 %term RetValue=101	/* return a value from a function */
 %term BrUncond=2
 %term BrCond=102
 %term Switch=3
 		/* 4 is unused */
 %term Not=4
 %term Add=5
 %term Sub=6
 %term Mul=7
 %term Div=8
 %term Rem=9
 %term And=10
 %term Or=11
 %term Xor=12
 %term SetCC=113		/* use this to match all SetCC instructions */
 	/* %term SetEQ=13 */
 	/* %term SetNE=14 */
 	/* %term SetLE=15 */
 	/* %term SetGE=16 */
 	/* %term SetLT=17 */
 	/* %term SetGT=18 */
 %term Malloc=19
 %term Free=20
 %term Alloca=21
 %term AllocaN=121	/* alloca with arg N */
 %term Load=22
 %term LoadIdx=122	/* load with index vector */
 %term Store=23
 %term GetElemPtr=24
 %term GetElemPtrIdx=124	/* getElemPtr with index vector */

 		/* 25 is PHINode, which is never a real tree node */

 %term Cast=26	/* cast that will be ignored.  others are made explicit */
 %term ToBoolTy=126
 %term ToUByteTy=127
 %term ToSByteTy=128
 %term ToUShortTy=129
 %term ToShortTy=130
 %term ToUIntTy=131
 %term ToIntTy=132
 %term ToULongTy=133
 %term ToLongTy=134
 %term ToFloatTy=135
 %term ToDoubleTy=136
 %term ToArrayTy=137
 %term ToPointerTy=138

 %term Call=27
 %term Shl=28
 %term Shr=29
 		/* 30...46 are unused */
     /*
      * The foll. values should match the constants in InstrForest.h
      */
 %term VRegList=97
 %term VReg=98
 %term Constant=99
 %term Label=100
 		/* 50+i is a variant of i, as defined above */


 %%
 /*-----------------------------------------------------------------------*
  * The productions of the grammar.
  * Note that all chain rules are numbered 101 and above.
  * Also, a special case of production X is numbered 100+X.
  *-----------------------------------------------------------------------*/

 	/*
 	 * The top-level statements
 	 */
 stmt:	Ret			=   1 (3);
 stmt:	RetValue(reg)		=   2 (3);
 stmt:	Store(reg,reg)		=   3 (1);
 stmt:	Store(reg,ptrreg)	=   4 (1);
 stmt:	BrUncond		=   5 (2);
 stmt:	BrCond(boolconst)	=   6 (1);	/* may save one instruction */
 stmt:	BrCond(bool)		=   7 (2);
 stmt:	BrCond(boolreg)		=   8 (2);
 stmt:	Switch(reg)		=   9 (3);	/* cost = load + branch */

 stmt:	reg			=  111 (0);
 stmt:	boolconst		=  112 (0);
 stmt:	bool			=  113 (0);

 	/*
 	 * List node used for nodes with more than 2 children
 	 */
 reg:	VRegList(reg,reg)	=  10 (0);

 	/*
 	 * The unary operators.  We encode NOT and individual casts into
 	 * separate non-terminals to combine instructions for some cases:
 	 *	Eg1:  zdouble <- todouble(xfloat) * todouble(yfloat)
 	 *	Eg2:  c       <- a AND (NOT b).
 	 * Note that the costs are counted for the individual non-terminals
 	 * below, not for reg.
 	 */
 reg:	not			=  121 (0);
 reg:	tobool			=  122 (0);
 reg:	toubyte			=  123 (0);
 reg:	tosbyte			=  124 (0);
 reg:	toushort		=  125 (0);
 reg:	toshort			=  126 (0);
 reg:	touint			=  127 (0);
 reg:	toint			=  128 (0);
 reg:	toulong			=  129 (0);
 reg:	tolong			=  130 (0);
 reg:	tofloat			=  131 (0);
 reg:	todouble		=  132 (0);

 not:	  Not(reg)		=  21 (1);
 tobool:	  ToBoolTy(reg)		=  22 (1);
 toubyte:  ToUByteTy(reg)	=  23 (1);
 tosbyte:  ToSByteTy(reg)	=  24 (1);
 toushort: ToUShortTy(reg)	=  25 (1);
 toshort:  ToShortTy(reg)	=  26 (1);
 touint:	  ToUIntTy(reg)		=  27 (1);
 toint:	  ToIntTy(reg)		=  28 (1);
 toulong:  ToULongTy(reg)	=  29 (1);
 tolong:	  ToLongTy(reg)		=  30 (1);
 tofloat:  ToFloatTy(reg)	=  31 (1);
 todouble: ToDoubleTy(reg)	=  32 (1);

 reg:	  ToArrayTy(reg)	=  19 (1);
 reg:	  ToPointerTy(reg)	=  20 (1);

 	/*
 	 * The binary operators.
 	 */
 reg:	Add(reg,reg)		=   33 (1);
 reg:	Sub(reg,reg)		=   34 (1);
 reg:	Mul(reg,reg)		=   35 (3);
 reg:	Mul(todouble,todouble)	=  135 (2);	/* avoids 1-2 type converts */
 reg:	Div(reg,reg)		=   36 (6);
 reg:	Rem(reg,reg)		=   37 (6);
 reg:	And(reg,reg)		=   38 (1);
 reg:	And(reg,not)		=  138 (0);	/* cost is counted for not */
 reg:	Or (reg,reg)		=   39 (1);
 reg:	Or (reg,not)		=  139 (0);	/* cost is counted for not */
 reg:	Xor(reg,reg)		=   40 (1);
 reg:	Xor(reg,not)		=  140 (0);	/* cost is counted for not */

 	/*
 	 * The SetCC instructions and other boolean values
 	 */
 boolconst: SetCC(reg,Constant)	=   41 (1);
 bool:	   SetCC(reg,reg)	=   42 (1);
 boolreg:   VReg			=   43 (0);

 	/*
 	 * Memory access instructions
 	 */
 reg:	Load(reg)		=   51 (3);
 reg:	Load(ptrreg)		=   52 (2);	/* 1 counted for ptrreg */
 reg:	LoadIdx(reg,reg)	=   53 (3);
 reg:	LoadIdx(ptrreg,reg)	=   54 (2);	/* 1 counted for ptrreg */
 reg:	ptrreg			=  155 (0);
 ptrreg:	GetElemPtr(reg)		=   55 (1);
 ptrreg:	GetElemPtrIdx(reg,reg)	=   56 (1);
 reg:	Alloca			=   57 (1);
 reg:	AllocaN(reg)		=   58 (1);

 	/*
 	 * Other operators producing register values
 	 */
 reg:	Call			=   61 (0);
 reg:	Shl(reg,reg)		=   62 (1);
 reg:	Shr(reg,reg)		=   63 (1);

 	/*
 	 * Finally, leaf nodes of expression trees (other than boolreg)
 	 */
 reg:	VReg			=   71 (0);
 reg:	Constant		=   72 (0);


 %%
 /*-----------------------------------------------------------------------*
  * The rest of this file provides code to print the cover produced
  * by BURG and information about computed tree cost and matches.
  * This code was taken from sample.gr provided with BURG.
  *-----------------------------------------------------------------------*/

 static char rcsid[] = "$Id$";

 #ifdef __STDC__
 void printcover(NODEPTR_TYPE p, int goalnt, int indent) {
 #else
 void printcover(p, goalnt, indent) NODEPTR_TYPE p; int goalnt; int indent; {
 #endif
 	int eruleno = burm_rule(STATE_LABEL(p), goalnt);
 	short *nts = burm_nts[eruleno];
 	NODEPTR_TYPE kids[10];
 	int i;

 	if (eruleno == 0) {
 		printf("no cover\n");
 		return;
 	}
 	for (i = 0; i < indent; i++)
 		printf(".");
 	printf("%s\n", burm_string[eruleno]);
 	burm_kids(p, eruleno, kids);
 	for (i = 0; nts[i]; i++)
 		printcover(kids[i], nts[i], indent+1);
 }

 #ifdef __STDC__
 void printtree(NODEPTR_TYPE p) {
 #else
 void printtree(p) NODEPTR_TYPE p; {
 #endif
 	int op = burm_op_label(p);

 	printf("%s", burm_opname[op]);
 	switch (burm_arity[op]) {
 	case 0:
 		break;
 	case 1:
 		printf("(");
 		printtree(burm_child(p, 0));
 		printf(")");
 		break;
 	case 2:
 		printf("(");
 		printtree(burm_child(p, 0));
 		printf(", ");
 		printtree(burm_child(p, 1));
 		printf(")");
 		break;
 	}
 }

 #ifdef __STDC__
 int treecost(NODEPTR_TYPE p, int goalnt, int costindex) {
 #else
 int treecost(p, goalnt, costindex) NODEPTR_TYPE p; int goalnt; int costindex; {
 #endif
 	int eruleno = burm_rule(STATE_LABEL(p), goalnt);
 	int cost = burm_cost[eruleno][costindex], i;
 	short *nts = burm_nts[eruleno];
 	NODEPTR_TYPE kids[10];

 	burm_kids(p, eruleno, kids);
 	for (i = 0; nts[i]; i++)
 		cost += treecost(kids[i], nts[i], costindex);
 	return cost;
 }

 #ifdef __STDC__
 void printMatches(NODEPTR_TYPE p) {
 #else
 void printMatches(p) NODEPTR_TYPE p; {
 #endif
 	int nt;
 	int eruleno;

 	printf("Node 0x%lx= ", (unsigned long)p);
 	printtree(p);
 	printf(" matched rules:\n");
 	for (nt = 1; burm_ntname[nt] != (char*)NULL; nt++)
 		if ((eruleno = burm_rule(STATE_LABEL(p), nt)) != 0)
 			printf("\t%s\n", burm_string[eruleno]);
 }
	%{
	#include <stdio.h>
	#include <llvm/Codegen/InstrForest.h>

	typedef BasicTreeNode* NODEPTR_TYPE;
	#define OP_LABEL(p) ((p)->opLabel)
	#define LEFT_CHILD(p) ((p)->leftChild)
	#define RIGHT_CHILD(p) ((p)->rightChild)
	#define STATE_LABEL(p) ((p)->state)
	#define PANIC printf
	%}

	%start stmt

	%term Ret=1 /* return void from a function */
	%term RetValue=101 /* return a value from a function */
	%term BrUncond=2
	%term BrCond=102
	%term Switch=3
	/* 4 is unused */
	%term Not=4
	%term Add=5
	%term Sub=6
	%term Mul=7
	%term Div=8
	%term Rem=9
	%term And=10
	%term Or=11
	%term Xor=12
	%term SetCC=113 /* use this to match all SetCC instructions */
	/* %term SetEQ=13 */
	/* %term SetNE=14 */
	/* %term SetLE=15 */
	/* %term SetGE=16 */
	/* %term SetLT=17 */
	/* %term SetGT=18 */
	%term Malloc=19
	%term Free=20
	%term Alloca=21
	%term AllocaN=121 /* alloca with arg N */
	%term Load=22
	%term LoadIdx=122 /* load with index vector */
	%term Store=23
	%term GetElemPtr=24
	%term GetElemPtrIdx=124 /* getElemPtr with index vector */

	/* 25 is PHINode, which is never a real tree node */

	%term Cast=26 /* cast that will be ignored. others are made explicit */
	%term ToBoolTy=126
	%term ToUByteTy=127
	%term ToSByteTy=128
	%term ToUShortTy=129
	%term ToShortTy=130
	%term ToUIntTy=131
	%term ToIntTy=132
	%term ToULongTy=133
	%term ToLongTy=134
	%term ToFloatTy=135
	%term ToDoubleTy=136
	%term ToArrayTy=137
	%term ToPointerTy=138

	%term Call=27
	%term Shl=28
	%term Shr=29
	/* 30...46 are unused */
	/*
	* The foll. values should match the constants in InstrForest.h
	*/
	%term VRegList=97
	%term VReg=98
	%term Constant=99
	%term Label=100
	/* 50+i is a variant of i, as defined above */


	%%
	/-----------------------------------------------------------------------
	* The productions of the grammar.
	* Note that all chain rules are numbered 101 and above.
	* Also, a special case of production X is numbered 100+X.
	-----------------------------------------------------------------------/

	/*
	* The top-level statements
	*/
	stmt: Ret = 1 (3);
	stmt: RetValue(reg) = 2 (3);
	stmt: Store(reg,reg) = 3 (1);
	stmt: Store(reg,ptrreg) = 4 (1);
	stmt: BrUncond = 5 (2);
	stmt: BrCond(boolconst) = 6 (1); /* may save one instruction */
	stmt: BrCond(bool) = 7 (2);
	stmt: BrCond(boolreg) = 8 (2);
	stmt: Switch(reg) = 9 (3); /* cost = load + branch */

	stmt: reg = 111 (0);
	stmt: boolconst = 112 (0);
	stmt: bool = 113 (0);

	/*
	* List node used for nodes with more than 2 children
	*/
	reg: VRegList(reg,reg) = 10 (0);

	/*
	* The unary operators. We encode NOT and individual casts into
	* separate non-terminals to combine instructions for some cases:
	* Eg1: zdouble <- todouble(xfloat) * todouble(yfloat)
	* Eg2: c <- a AND (NOT b).
	* Note that the costs are counted for the individual non-terminals
	* below, not for reg.
	*/
	reg: not = 121 (0);
	reg: tobool = 122 (0);
	reg: toubyte = 123 (0);
	reg: tosbyte = 124 (0);
	reg: toushort = 125 (0);
	reg: toshort = 126 (0);
	reg: touint = 127 (0);
	reg: toint = 128 (0);
	reg: toulong = 129 (0);
	reg: tolong = 130 (0);
	reg: tofloat = 131 (0);
	reg: todouble = 132 (0);

	not: Not(reg) = 21 (1);
	tobool: ToBoolTy(reg) = 22 (1);
	toubyte: ToUByteTy(reg) = 23 (1);
	tosbyte: ToSByteTy(reg) = 24 (1);
	toushort: ToUShortTy(reg) = 25 (1);
	toshort: ToShortTy(reg) = 26 (1);
	touint: ToUIntTy(reg) = 27 (1);
	toint: ToIntTy(reg) = 28 (1);
	toulong: ToULongTy(reg) = 29 (1);
	tolong: ToLongTy(reg) = 30 (1);
	tofloat: ToFloatTy(reg) = 31 (1);
	todouble: ToDoubleTy(reg) = 32 (1);

	reg: ToArrayTy(reg) = 19 (1);
	reg: ToPointerTy(reg) = 20 (1);

	/*
	* The binary operators.
	*/
	reg: Add(reg,reg) = 33 (1);
	reg: Sub(reg,reg) = 34 (1);
	reg: Mul(reg,reg) = 35 (3);
	reg: Mul(todouble,todouble) = 135 (2); /* avoids 1-2 type converts */
	reg: Div(reg,reg) = 36 (6);
	reg: Rem(reg,reg) = 37 (6);
	reg: And(reg,reg) = 38 (1);
	reg: And(reg,not) = 138 (0); /* cost is counted for not */
	reg: Or (reg,reg) = 39 (1);
	reg: Or (reg,not) = 139 (0); /* cost is counted for not */
	reg: Xor(reg,reg) = 40 (1);
	reg: Xor(reg,not) = 140 (0); /* cost is counted for not */

	/*
	* The SetCC instructions and other boolean values
	*/
	boolconst: SetCC(reg,Constant) = 41 (1);
	bool: SetCC(reg,reg) = 42 (1);
	boolreg: VReg = 43 (0);

	/*
	* Memory access instructions
	*/
	reg: Load(reg) = 51 (3);
	reg: Load(ptrreg) = 52 (2); /* 1 counted for ptrreg */
	reg: LoadIdx(reg,reg) = 53 (3);
	reg: LoadIdx(ptrreg,reg) = 54 (2); /* 1 counted for ptrreg */
	reg: ptrreg = 155 (0);
	ptrreg: GetElemPtr(reg) = 55 (1);
	ptrreg: GetElemPtrIdx(reg,reg) = 56 (1);
	reg: Alloca = 57 (1);
	reg: AllocaN(reg) = 58 (1);

	/*
	* Other operators producing register values
	*/
	reg: Call = 61 (0);
	reg: Shl(reg,reg) = 62 (1);
	reg: Shr(reg,reg) = 63 (1);

	/*
	* Finally, leaf nodes of expression trees (other than boolreg)
	*/
	reg: VReg = 71 (0);
	reg: Constant = 72 (0);



	%%
	/-----------------------------------------------------------------------
	* The rest of this file provides code to print the cover produced
	* by BURG and information about computed tree cost and matches.
	* This code was taken from sample.gr provided with BURG.
	-----------------------------------------------------------------------/

	static char rcsid[] = "$Id$";

	#ifdef __STDC__
	void printcover(NODEPTR_TYPE p, int goalnt, int indent) {
	#else
	void printcover(p, goalnt, indent) NODEPTR_TYPE p; int goalnt; int indent; {
	#endif
	int eruleno = burm_rule(STATE_LABEL(p), goalnt);
	short *nts = burm_nts[eruleno];
	NODEPTR_TYPE kids[10];
	int i;

	if (eruleno == 0) {
	printf("no cover\n");
	return;
	}
	for (i = 0; i < indent; i++)
	printf(".");
	printf("%s\n", burm_string[eruleno]);
	burm_kids(p, eruleno, kids);
	for (i = 0; nts[i]; i++)
	printcover(kids[i], nts[i], indent+1);
	}

	#ifdef __STDC__
	void printtree(NODEPTR_TYPE p) {
	#else
	void printtree(p) NODEPTR_TYPE p; {
	#endif
	int op = burm_op_label(p);

	printf("%s", burm_opname[op]);
	switch (burm_arity[op]) {
	case 0:
	break;
	case 1:
	printf("(");
	printtree(burm_child(p, 0));
	printf(")");
	break;
	case 2:
	printf("(");
	printtree(burm_child(p, 0));
	printf(", ");
	printtree(burm_child(p, 1));
	printf(")");
	break;
	}
	}

	#ifdef __STDC__
	int treecost(NODEPTR_TYPE p, int goalnt, int costindex) {
	#else
	int treecost(p, goalnt, costindex) NODEPTR_TYPE p; int goalnt; int costindex; {
	#endif
	int eruleno = burm_rule(STATE_LABEL(p), goalnt);
	int cost = burm_cost[eruleno][costindex], i;
	short *nts = burm_nts[eruleno];
	NODEPTR_TYPE kids[10];

	burm_kids(p, eruleno, kids);
	for (i = 0; nts[i]; i++)
	cost += treecost(kids[i], nts[i], costindex);
	return cost;
	}

	#ifdef __STDC__
	void printMatches(NODEPTR_TYPE p) {
	#else
	void printMatches(p) NODEPTR_TYPE p; {
	#endif
	int nt;
	int eruleno;

	printf("Node 0x%lx= ", (unsigned long)p);
	printtree(p);
	printf(" matched rules:\n");
	for (nt = 1; burm_ntname[nt] != (char*)NULL; nt++)
	if ((eruleno = burm_rule(STATE_LABEL(p), nt)) != 0)
	printf("\t%s\n", burm_string[eruleno]);
	}