2 /* ===----------------------------------------------------------------------===
4 // The LLVM Compiler Infrastructure
6 // This file was developed by the LLVM research group and is distributed under
7 // the University of Illinois Open Source License. See LICENSE.TXT for details.
9 //===----------------------------------------------------------------------===*/
12 Xinclude "SparcV9InstrForest.h"
14 typedef llvm::InstrTreeNode* NODEPTR_TYPE;
15 Xdefine OP_LABEL(p) ((p)->opLabel)
16 Xdefine LEFT_CHILD(p) ((p)->LeftChild)
17 Xdefine RIGHT_CHILD(p) ((p)->RightChild)
18 Xdefine STATE_LABEL(p) ((p)->state)
21 // Get definitions for various instruction values that we will need...
22 #define HANDLE_TERM_INST(N, OPC, CLASS) Ydefine OPC##OPCODE N
23 #define HANDLE_UNARY_INST(N, OPC, CLASS) Ydefine OPC##OPCODE N
24 #define HANDLE_BINARY_INST(N, OPC, CLASS) Ydefine OPC##OPCODE N
25 #define HANDLE_MEMORY_INST(N, OPC, CLASS) Ydefine OPC##OPCODE N
26 #define HANDLE_OTHER_INST(N, OPC, CLASS) Ydefine OPC##OPCODE N
28 #include "llvm/Instruction.def"
34 %term Ret=RetOPCODE /* return void from a function */
35 %term RetValue=101 /* return a value from a function */
36 %term BrUncond=BrOPCODE
38 %term Switch=SwitchOPCODE
48 /* Use the next 4 to distinguish bitwise operators from
49 * logical operators. This is no longer used for SparcV9,
50 * but may be useful for other target machines.
51 * The last one is the bitwise Not(val) == XOR val, 11..1.
52 * Note that it is also a binary operator, not unary.
58 /* The next one is the boolean Not(val) == bool XOR val, true
59 * Note that it is also a binary operator, not unary.
63 %term SetCC=114 /* use this to match all SetCC instructions */
70 %term Malloc=MallocOPCODE
72 %term Alloca=AllocaOPCODE
73 %term AllocaN=122 /* alloca with arg N */
75 %term Store=StoreOPCODE
76 %term GetElemPtr=GetElementPtrOPCODE
77 %term GetElemPtrIdx=125 /* getElemPtr with index vector */
81 %term Cast=CastOPCODE /* cast that will be ignored. others are made explicit */
99 %term VANext=VANextOPCODE
100 %term VAArg=VAArgOPCODE
101 /* 33...46 are unused */
103 * The foll. values should match the constants in InstrForest.h
109 /* 50+i is a variant of i, as defined above */
113 /*-----------------------------------------------------------------------*
114 * The productions of the grammar.
115 * Note that all chain rules are numbered 101 and above.
116 * Also, a special case of production X is numbered 100+X, 200+X, etc.
117 * The cost of a 1-cycle operation is represented as 10, to allow
118 * finer comparisons of costs (effectively, fractions of 1/10).
119 *-----------------------------------------------------------------------*/
122 * The top-level statements
125 stmt: RetValue(reg) = 2 (30);
126 stmt: Store(reg,reg) = 3 (10);
127 stmt: Store(reg,ptrreg) = 4 (10);
128 stmt: BrUncond = 5 (20);
129 stmt: BrCond(setCC) = 6 (20); /* branch on cond. code */
130 stmt: BrCond(setCCconst) = 206 (10); /* may save one instruction */
131 stmt: BrCond(reg) = 8 (20); /* may avoid an extra instr */
132 stmt: BrCond(Constant) = 208 (20); /* may avoid an extra instr */
133 stmt: Switch(reg) = 9 (30); /* cost = load + branch */
138 * List node used for nodes with more than 2 children
140 reg: VRegList(reg,reg) = 10 (0);
143 * Special case non-terminals to help combine unary instructions.
144 * Eg1: zdouble <- todouble(xfloat) * todouble(yfloat)
145 * Eg2: c <- a AND (NOT b).
146 * Note that the costs are counted for the special non-terminals here,
147 * and should not be counted again for the reg productions later.
149 not: Not(reg,reg) = 21 (10);
150 tobool: ToBoolTy(reg) = 22 (10);
151 not: Not(tobool, reg) = 322 (10); // fold cast-to-bool into not
152 toubyte: ToUByteTy(reg) = 23 (10);
153 tosbyte: ToSByteTy(reg) = 24 (10);
154 toushort: ToUShortTy(reg) = 25 (10);
155 toshort: ToShortTy(reg) = 26 (10);
156 touint: ToUIntTy(reg) = 27 (10);
157 toint: ToIntTy(reg) = 28 (10);
158 toulong: ToULongTy(reg) = 29 (10);
159 tolong: ToLongTy(reg) = 30 (10);
160 tofloat: ToFloatTy(reg) = 31 (10);
161 todouble: ToDoubleTy(reg) = 32 (10);
162 todoubleConst: ToDoubleTy(Constant) = 232 (10);
165 * All the ways to produce a boolean value (Not and ToBoolTy are above):
166 * -- boolean operators: Not, And, Or, ..., ToBoolTy, SetCC
167 * -- an existing boolean register not in the same tree
168 * -- a boolean constant
170 * For And, Or, Xor, we add special cases for when:
171 * (a) one operand is a constant.
172 * (b) one operand is a NOT, to use the ANDN, ORN, and XORN instrns.
173 * We do not need the cases when both operands are constant
174 * because constant folding should take care of that beforehand.
176 reg: And(reg,reg) = 38 (10);
177 reg: And(reg,not) = 138 (0); /* cost is counted for not */
178 reg: And(reg,Constant) = 238 (10);
179 reg: Or (reg,reg) = 39 (10);
180 reg: Or (reg,not) = 139 (0); /* cost is counted for not */
181 reg: Or (reg,Constant) = 239 (10);
182 reg: Xor(reg,reg) = 40 (10);
183 reg: Xor(reg,not) = 140 (0); /* cost is counted for not */
184 reg: Xor(reg,Constant) = 240 (10);
186 /* Special case non-terms for BrCond(setCC) and BrCond(setCCconst) */
187 setCCconst: SetCC(reg,Constant) = 41 (5);
188 setCC: SetCC(reg,reg) = 42 (10);
191 reg: tobool = 222 (0);
192 reg: setCCconst = 241 (0);
193 reg: setCC = 242 (0);
196 * Special case non-terminals for the unary cast operators.
197 * Some of these can be folded into other operations (e.g., todouble).
198 * The rest are just for uniformity.
200 reg: toubyte = 123 (0);
201 reg: tosbyte = 124 (0);
202 reg: toushort = 125 (0);
203 reg: toshort = 126 (0);
204 reg: touint = 127 (0);
205 reg: toint = 128 (0);
206 reg: toulong = 129 (0);
207 reg: tolong = 130 (0);
208 reg: tofloat = 131 (0);
209 reg: todouble = 132 (0);
210 reg: todoubleConst = 133 (0);
212 reg: ToArrayTy(reg) = 19 (10);
213 reg: ToPointerTy(reg) = 20 (10);
216 * The binary arithmetic operators.
218 reg: Add(reg,reg) = 33 (10);
219 reg: Sub(reg,reg) = 34 (10);
220 reg: Mul(reg,reg) = 35 (30);
221 reg: Mul(todouble,todouble) = 135 (20); /* avoids 1-2 type converts */
222 reg: Div(reg,reg) = 36 (60);
223 reg: Rem(reg,reg) = 37 (60);
226 * The binary bitwise logical operators.
228 reg: BAnd(reg,reg) = 338 (10);
229 reg: BAnd(reg,bnot) = 438 ( 0); /* cost is counted for not */
230 reg: BOr( reg,reg) = 339 (10);
231 reg: BOr( reg,bnot) = 439 ( 0); /* cost is counted for not */
232 reg: BXor(reg,reg) = 340 (10);
233 reg: BXor(reg,bnot) = 440 ( 0); /* cost is counted for not */
235 reg: bnot = 321 ( 0);
236 bnot: BNot(reg,reg) = 421 (10);
239 * Special cases for the binary operators with one constant argument.
240 * Not and BNot are effectively just one argument, so not needed here.
242 reg: Add(reg,Constant) = 233 (10);
243 reg: Sub(reg,Constant) = 234 (10);
244 reg: Mul(reg,Constant) = 235 (30);
245 reg: Mul(todouble,todoubleConst) = 335 (20); /* avoids 1-2 type converts */
246 reg: Div(reg,Constant) = 236 (60);
247 reg: Rem(reg,Constant) = 237 (60);
249 reg: BAnd(reg,Constant) = 538 (0);
250 reg: BOr( reg,Constant) = 539 (0);
251 reg: BXor(reg,Constant) = 540 (0);
254 * Memory access instructions
256 reg: Load(reg) = 51 (30);
257 reg: Load(ptrreg) = 52 (20); /* 1 counted for ptrreg */
258 reg: ptrreg = 155 (0);
259 ptrreg: GetElemPtr(reg) = 55 (10);
260 ptrreg: GetElemPtrIdx(reg,reg) = 56 (10);
261 reg: Alloca = 57 (10);
262 reg: AllocaN(reg) = 58 (10);
265 * Other operators producing register values
267 reg: Call = 61 (20); /* just ignore the operands! */
268 reg: Shl(reg,reg) = 62 (20); /* 1 for issue restrictions */
269 reg: Shr(reg,reg) = 63 (20); /* 1 for issue restrictions */
270 reg: Phi(reg,reg) = 64 (0);
271 reg: VANext(reg) = 65 (40); /* incr stack slot pointer */
272 reg: VAArg(reg) = 66 (40); /* get a vararg */
275 * Finally, leaf nodes of expression trees.
278 reg: Constant = 72 (3); /* prefer direct use */
283 /*-----------------------------------------------------------------------*
284 * The rest of this file provides code to print the cover produced
285 * by BURG and information about computed tree cost and matches.
286 * This code was taken from sample.gr provided with BURG.
287 *-----------------------------------------------------------------------*/
289 void printcover(NODEPTR_TYPE p, int goalnt, int indent) {
290 int eruleno = burm_rule(STATE_LABEL(p), goalnt);
291 short *nts = burm_nts[eruleno];
292 NODEPTR_TYPE kids[10];
296 printf("no cover\n");
299 for (i = 0; i < indent; i++)
301 printf("%s\n", burm_string[eruleno]);
302 burm_kids(p, eruleno, kids);
303 for (i = 0; nts[i]; i++)
304 printcover(kids[i], nts[i], indent+1);
307 void printtree(NODEPTR_TYPE p) {
308 int op = burm_op_label(p);
310 printf("%s", burm_opname[op]);
311 switch (burm_arity[op]) {
316 printtree(burm_child(p, 0));
321 printtree(burm_child(p, 0));
323 printtree(burm_child(p, 1));
329 int treecost(NODEPTR_TYPE p, int goalnt, int costindex) {
330 int eruleno = burm_rule(STATE_LABEL(p), goalnt);
331 int cost = burm_cost[eruleno][costindex], i;
332 short *nts = burm_nts[eruleno];
333 NODEPTR_TYPE kids[10];
335 burm_kids(p, eruleno, kids);
336 for (i = 0; nts[i]; i++)
337 cost += treecost(kids[i], nts[i], costindex);
341 void printMatches(NODEPTR_TYPE p) {
345 printf("Node 0x%lx= ", (unsigned long)p);
347 printf(" matched rules:\n");
348 for (nt = 1; burm_ntname[nt] != (char*)NULL; nt++)
349 if ((eruleno = burm_rule(STATE_LABEL(p), nt)) != 0)
350 printf("\t%s\n", burm_string[eruleno]);