Change rules for Not, since it is now implemented as Xor(reg,11..1).

Eliminate bool, boolreg and boolconst nonterminals, and just use
reg and Constant instead.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@3440 91177308-0d34-0410-b5e6-96231b3b80d8

1 files changed, 54 insertions, 48 deletions

diff --git a/lib/Target/SparcV9/SparcV9.burg.in b/lib/Target/SparcV9/SparcV9.burg.in
index 46af49ccbb..61ec4d7274 100644
--- a/lib/Target/SparcV9/SparcV9.burg.in
+++ b/lib/Target/SparcV9/SparcV9.burg.in
@@ -28,7 +28,6 @@ Xdefine PANIC		printf
 %term BrCond=102
 %term Switch=SwitchOPCODE
 		/* 4 is unused */
-%term Not=NotOPCODE
 %term Add=AddOPCODE
 %term Sub=SubOPCODE
 %term Mul=MulOPCODE
@@ -37,15 +36,22 @@ Xdefine PANIC		printf
 %term And=AndOPCODE
 %term Or=OrOPCODE
 %term Xor=XorOPCODE
-                /* Use the next 4 to distinguish bitwise operators (reg) from
-                 * logical operators (bool).  Burg will diverge otherwise.
+                /* Use the next 4 to distinguish bitwise operators from
+                 * logical operators.  This is no longer used for Sparc,
+                 * but may be useful for other target machines.
+                 * The last one is the bitwise Not(val) == XOR val, 11..1.
+                 * Note that it is also a binary operator, not unary.
                  */
 %term BAnd=111
 %term BOr=112
 %term BXor=113
-%term BNot=105
+%term BNot=213
+                /* The next one is the boolean Not(val) == bool XOR val, true
+                 * Note that it is also a binary operator, not unary.
+                 */
+%term  Not=313
 
-%term SetCC=114		/* use this to match all SetCC instructions */
+%term SetCC=114	/* use this to match all SetCC instructions */
 	/* %term SetEQ=13 */
 	/* %term SetNE=14 */
 	/* %term SetLE=15 */
@@ -55,12 +61,12 @@ Xdefine PANIC		printf
 %term Malloc=MallocOPCODE
 %term Free=FreeOPCODE
 %term Alloca=AllocaOPCODE
-%term AllocaN=122	/* alloca with arg N */
+%term AllocaN=122               /* alloca with arg N */
 %term Load=LoadOPCODE
-%term LoadIdx=123	/* load with index vector */
+%term LoadIdx=123               /* load with index vector */
 %term Store=StoreOPCODE
 %term GetElemPtr=GetElementPtrOPCODE
-%term GetElemPtrIdx=125	/* getElemPtr with index vector */
+%term GetElemPtrIdx=125         /* getElemPtr with index vector */
 
 %term Phi=PHINodeOPCODE
 
@@ -110,14 +116,13 @@ stmt:	RetValue(reg)		=   2 (30);
 stmt:	Store(reg,reg)		=   3 (10);
 stmt:	Store(reg,ptrreg)	=   4 (10);
 stmt:	BrUncond		=   5 (20);
-stmt:	BrCond(bool)		=   6 (20);
+stmt:	BrCond(setCC)		=   6 (20);     /* branch on cond. code */
 stmt:	BrCond(setCCconst)	= 206 (10);	/* may save one instruction */
-stmt:	BrCond(boolreg)		=   8 (20);	/* may avoid an extra instr */
-stmt:	BrCond(boolconst)	= 208 (20);	/* may avoid an extra instr */
+stmt:	BrCond(reg)		=   8 (20);	/* may avoid an extra instr */
+stmt:	BrCond(Constant)	= 208 (20);	/* may avoid an extra instr */
 stmt:	Switch(reg)		=   9 (30);	/* cost = load + branch */
 
 stmt:	reg			=  111 (0);
-stmt:	bool			=  113 (0);
 
 	/*
 	 * List node used for nodes with more than 2 children
@@ -128,12 +133,11 @@ reg:	VRegList(reg,reg)	=  10 (0);
 	 * Special case non-terminals to help combine unary instructions.
 	 *	Eg1:  zdouble <- todouble(xfloat) * todouble(yfloat)
 	 *	Eg2:  c       <- a AND (NOT b).
-	 * Note that the costs are counted for the special non-terminals
-	 * here, not for the bool or reg productions later.
+	 * Note that the costs are counted for the special non-terminals here,
+	 * and should not be counted again for the reg productions later.
 	 */
-not:	  Not(bool)		=   21 (10);
-tobool:	  ToBoolTy(bool)	=   22 (10);
-tobool:	  ToBoolTy(reg)		=  322 (10);
+not:	  Not(reg,reg)		=   21 (10);
+tobool:	  ToBoolTy(reg)		=   22 (10);
 toubyte:  ToUByteTy(reg)	=   23 (10);
 tosbyte:  ToSByteTy(reg)	=   24 (10);
 toushort: ToUShortTy(reg)	=   25 (10);
@@ -147,39 +151,40 @@ todouble: ToDoubleTy(reg)	=   32 (10);
 todoubleConst: ToDoubleTy(Constant) = 232 (10);
 
 	/*
-	 * All the ways to produce a boolean value:
+	 * All the ways to produce a boolean value (Not and ToBoolTy are above):
 	 * -- boolean operators: Not, And, Or, ..., ToBoolTy, SetCC
 	 * -- an existing boolean register not in the same tree
 	 * -- a boolean constant
 	 * 
-	 * We add special cases for when one operand is a constant.
-	 * We do not need the cases when all operands (one or both) are const
+	 * For And, Or, Xor, we add special cases for when:
+         * (a) one operand is a constant.
+         * (b) one operand is a NOT, to use the ANDN, ORN, and XORN instrns.
+	 * We do not need the cases when both operands are constant
 	 * because constant folding should take care of that beforehand.
 	 */
-bool:	And(bool,bool)		=   38 (10);
-bool:	And(bool,not)		=  138 (0);	/* cost is counted for not */
-bool:	And(bool,boolconst)	=  238 (10);
-bool:	Or (bool,bool)		=   39 (10);
-bool:	Or (bool,not)		=  139 (0);	/* cost is counted for not */
-bool:	Or (bool,boolconst)	=  239 (10);
-bool:	Xor(bool,bool)		=   40 (10);
-bool:	Xor(bool,not)		=  140 (0);	/* cost is counted for not */
-bool:	Xor(bool,boolconst)	=  240 (10);
-
-bool:	   not			=  221 (0);
-bool:	   tobool		=  222 (0);
-bool:	   setCCconst		=  241 (0);
-bool:	   setCC		=  242 (0);
-bool:      boolreg		=  243 (10);
-bool:      boolconst		=  244 (10);
-
+reg:	And(reg,reg)		=   38 (10);
+reg:	And(reg,not)		=  138 (0);	/* cost is counted for not */
+reg:	And(reg,Constant)	=  238 (10);
+reg:	Or (reg,reg)		=   39 (10);
+reg:	Or (reg,not)		=  139 (0);	/* cost is counted for not */
+reg:	Or (reg,Constant)	=  239 (10);
+reg:	Xor(reg,reg)		=   40 (10);
+reg:	Xor(reg,not)		=  140 (0);	/* cost is counted for not */
+reg:	Xor(reg,Constant)	=  240 (10);
+
+        /* Special case non-terms for BrCond(setCC) and BrCond(setCCconst) */
 setCCconst: SetCC(reg,Constant)	=   41 (5);
 setCC:	    SetCC(reg,reg)	=   42 (10);
-boolreg:    VReg		=   43 (0);
-boolconst:  Constant		=   44 (0);
+
+reg:	not			=  221 (0);
+reg:	tobool                  =  222 (0);
+reg:	setCCconst		=  241 (0);
+reg:	setCC                   =  242 (0);
 
 	/*
-	 * The unary cast operators.
+	 * Special case non-terminals for the unary cast operators.
+         * Some of these can be folded into other operations (e.g., todouble).
+         * The rest are just for uniformity.
 	 */
 reg:	toubyte			=  123 (0);
 reg:	tosbyte			=  124 (0);
@@ -193,8 +198,8 @@ reg:	tofloat			=  131 (0);
 reg:	todouble		=  132 (0);
 reg:	todoubleConst		=  133 (0);
 
-reg:	  ToArrayTy(reg)	=  19 (10);
-reg:	  ToPointerTy(reg)	=  20 (10);
+reg:	ToArrayTy(reg)          =  19 (10);
+reg:	ToPointerTy(reg)	=  20 (10);
 
 	/*
 	 * The binary arithmetic operators.
@@ -210,17 +215,18 @@ reg:	Rem(reg,reg)		=   37 (60);
 	 * The binary bitwise logical operators.
 	 */
 reg:    BAnd(reg,reg)           =  338 (10);
-reg:    BAnd(reg,bnot)          =  438 (10);
+reg:    BAnd(reg,bnot)          =  438 ( 0);	/* cost is counted for not */
 reg:    BOr( reg,reg)           =  339 (10);
-reg:    BOr( reg,bnot)          =  439 (10);
+reg:    BOr( reg,bnot)          =  439 ( 0);	/* cost is counted for not */
 reg:    BXor(reg,reg)           =  340 (10);
-reg:    BXor(reg,bnot)          =  440 (10);
+reg:    BXor(reg,bnot)          =  440 ( 0);	/* cost is counted for not */
 
 reg:    bnot                    =  321 ( 0);
-bnot:   BNot(reg)               =  421 (10);
+bnot:   BNot(reg,reg)           =  421 (10);
 
 	/*
-	 * The binary operators with one constant argument.
+	 * Special cases for the binary operators with one constant argument.
+         * Not and BNot are effectively just one argument, so not needed here.
 	 */
 reg:	Add(reg,Constant)	=  233 (10);
 reg:	Sub(reg,Constant)	=  234 (10);
@@ -255,7 +261,7 @@ reg:	Shr(reg,reg)		=   63 (20);	/* 1 for issue restrictions */
 reg:	Phi(reg,reg)		=   64 (0);
 
 	/*
-	 * Finally, leaf nodes of expression trees (other than boolreg)
+	 * Finally, leaf nodes of expression trees.
 	 */
 reg:	VReg			=   71 (0);
 reg:	Constant		=   72 (3);	/* prefer direct use */