From: Chris Lattner Date: Sun, 14 Oct 2001 17:26:21 +0000 (+0000) Subject: Move the burg file to here. Add .in suffix to indicate that it gets X-Git-Url: http://demsky.eecs.uci.edu/git/?a=commitdiff_plain;h=aa703203c3a1c67f68d31a498cc0cd233e5b29e3;p=oota-llvm.git 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 --- diff --git a/lib/Target/SparcV9/SparcV9.burg.in b/lib/Target/SparcV9/SparcV9.burg.in new file mode 100644 index 00000000000..0832c5684b4 --- /dev/null +++ b/lib/Target/SparcV9/SparcV9.burg.in @@ -0,0 +1,309 @@ +%{ // -*- C++ -*- +Xinclude +Xinclude + +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]); +}