llvm-6502/lib/Target/SparcV9/SparcV9.burg.in
Chris Lattner aa703203c3 Move the burg file to here. Add .in suffix to indicate that it gets
preprocessed before burg gets to it


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@794 91177308-0d34-0410-b5e6-96231b3b80d8
2001-10-14 17:26:21 +00:00

310 lines
8.7 KiB
C++

%{ // -*- C++ -*-
Xinclude <stdio.h>
Xinclude <llvm/CodeGen/InstrForest.h>
typedef InstrTreeNode* NODEPTR_TYPE;
Xdefine OP_LABEL(p) ((p)->opLabel)
Xdefine LEFT_CHILD(p) ((p)->LeftChild)
Xdefine RIGHT_CHILD(p) ((p)->RightChild)
Xdefine STATE_LABEL(p) ((p)->state)
Xdefine PANIC printf
// Get definitions for various instruction values that we will need...
#define HANDLE_TERM_INST(N, OPC, CLASS) Ydefine OPC##OPCODE N
#define HANDLE_UNARY_INST(N, OPC, CLASS) Ydefine OPC##OPCODE N
#define HANDLE_BINARY_INST(N, OPC, CLASS) Ydefine OPC##OPCODE N
#define HANDLE_MEMORY_INST(N, OPC, CLASS) Ydefine OPC##OPCODE N
#define HANDLE_OTHER_INST(N, OPC, CLASS) Ydefine OPC##OPCODE N
#include "llvm/Instruction.def"
%}
%start stmt
%term Ret=RetOPCODE /* return void from a function */
%term RetValue=101 /* return a value from a function */
%term BrUncond=BrOPCODE
%term BrCond=102
%term Switch=SwitchOPCODE
/* 4 is unused */
%term Not=NotOPCODE
%term Add=AddOPCODE
%term Sub=SubOPCODE
%term Mul=MulOPCODE
%term Div=DivOPCODE
%term Rem=RemOPCODE
%term And=AndOPCODE
%term Or=OrOPCODE
%term Xor=XorOPCODE
%term SetCC=114 /* 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=MallocOPCODE
%term Free=FreeOPCODE
%term Alloca=AllocaOPCODE
%term AllocaN=122 /* alloca with arg N */
%term Load=LoadOPCODE
%term LoadIdx=123 /* load with index vector */
%term Store=StoreOPCODE
%term GetElemPtr=GetElementPtrOPCODE
%term GetElemPtrIdx=125 /* getElemPtr with index vector */
%term Phi=PHINodeOPCODE
%term Cast=CastOPCODE /* cast that will be ignored. others are made explicit */
%term ToBoolTy=127
%term ToUByteTy=128
%term ToSByteTy=129
%term ToUShortTy=130
%term ToShortTy=131
%term ToUIntTy=132
%term ToIntTy=133
%term ToULongTy=134
%term ToLongTy=135
%term ToFloatTy=136
%term ToDoubleTy=137
%term ToArrayTy=138
%term ToPointerTy=139
%term Call=CallOPCODE
%term Shl=ShlOPCODE
%term Shr=ShrOPCODE
/* 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, 200+X, etc.
* The cost of a 1-cycle operation is represented as 10, to allow
* finer comparisons of costs (effectively, fractions of 1/10).
*-----------------------------------------------------------------------*/
/*
* The top-level statements
*/
stmt: Ret = 1 (30);
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(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: 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
*/
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.
*/
not: Not(bool) = 21 (10);
tobool: ToBoolTy(bool) = 22 (10);
tobool: ToBoolTy(reg) = 322 (10);
toubyte: ToUByteTy(reg) = 23 (10);
tosbyte: ToSByteTy(reg) = 24 (10);
toushort: ToUShortTy(reg) = 25 (10);
toshort: ToShortTy(reg) = 26 (10);
touint: ToUIntTy(reg) = 27 (10);
toint: ToIntTy(reg) = 28 (10);
toulong: ToULongTy(reg) = 29 (10);
tolong: ToLongTy(reg) = 30 (10);
tofloat: ToFloatTy(reg) = 31 (10);
todouble: ToDoubleTy(reg) = 32 (10);
todoubleConst: ToDoubleTy(Constant) = 232 (10);
/*
* All the ways to produce a boolean value:
* -- 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
* 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 */
reg: And(bool,boolconst) = 238 (10);
bool: Or (bool,bool) = 39 (10);
bool: Or (bool,not) = 139 (0); /* cost is counted for not */
reg: Or (bool,boolconst) = 239 (10);
bool: Xor(bool,bool) = 40 (10);
bool: Xor(bool,not) = 140 (0); /* cost is counted for not */
reg: 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);
setCCconst: SetCC(reg,Constant) = 41 (5);
setCC: SetCC(reg,reg) = 42 (10);
boolreg: VReg = 43 (0);
boolconst: Constant = 44 (0);
/*
* The unary cast operators.
*/
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);
reg: todoubleConst = 133 (0);
reg: ToArrayTy(reg) = 19 (10);
reg: ToPointerTy(reg) = 20 (10);
/*
* The binary arithmetic operators.
*/
reg: Add(reg,reg) = 33 (10);
reg: Sub(reg,reg) = 34 (10);
reg: Mul(reg,reg) = 35 (30);
reg: Mul(todouble,todouble) = 135 (20); /* avoids 1-2 type converts */
reg: Div(reg,reg) = 36 (60);
reg: Rem(reg,reg) = 37 (60);
/*
* The binary operators with one constant argument.
*/
reg: Add(reg,Constant) = 233 (10);
reg: Sub(reg,Constant) = 234 (10);
reg: Mul(reg,Constant) = 235 (30);
reg: Mul(todouble,todoubleConst) = 335 (20); /* avoids 1-2 type converts */
reg: Div(reg,Constant) = 236 (60);
reg: Rem(reg,Constant) = 237 (60);
/*
* Memory access instructions
*/
reg: Load(reg) = 51 (30);
reg: Load(ptrreg) = 52 (20); /* 1 counted for ptrreg */
reg: LoadIdx(reg,reg) = 53 (30);
reg: LoadIdx(ptrreg,reg) = 54 (20); /* 1 counted for ptrreg */
reg: ptrreg = 155 (0);
ptrreg: GetElemPtr(reg) = 55 (10);
ptrreg: GetElemPtrIdx(reg,reg) = 56 (10);
reg: Alloca = 57 (10);
reg: AllocaN(reg) = 58 (10);
/*
* Other operators producing register values
*/
reg: Call = 61 (20); /* just ignore the operands! */
reg: Shl(reg,reg) = 62 (20); /* 1 for issue restrictions */
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)
*/
reg: VReg = 71 (0);
reg: Constant = 72 (3); /* prefer direct use */
%%
/*-----------------------------------------------------------------------*
* 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.
*-----------------------------------------------------------------------*/
void printcover(NODEPTR_TYPE p, int goalnt, int indent) {
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);
}
void printtree(NODEPTR_TYPE p) {
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;
}
}
int treecost(NODEPTR_TYPE p, int goalnt, int costindex) {
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;
}
void printMatches(NODEPTR_TYPE p) {
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]);
}