projects / OpenSPARC-T2-DV / blame
? search:
summary | tags | clone url | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Initial commit of OpenSPARC T2 design and verification files.
[OpenSPARC-T2-DV] / verif / diag / assembly / include / RF_8win_macros.h
CommitLineData
86530b38
AT		 1/*
2* ========== Copyright Header Begin ==========================================
3*
4* OpenSPARC T2 Processor File: RF_8win_macros.h
5* Copyright (C) 1995-2007 Sun Microsystems, Inc. All Rights Reserved
6* 4150 Network Circle, Santa Clara, California 95054, U.S.A.
7*
8* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
9*
10* This program is free software; you can redistribute it and/or modify
11* it under the terms of the GNU General Public License as published by
12* the Free Software Foundation; version 2 of the License.
13*
14* This program is distributed in the hope that it will be useful,
15* but WITHOUT ANY WARRANTY; without even the implied warranty of
16* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17* GNU General Public License for more details.
18*
19* You should have received a copy of the GNU General Public License
20* along with this program; if not, write to the Free Software
21* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22*
23* For the avoidance of doubt, and except that if any non-GPL license
24* choice is available it will apply instead, Sun elects to use only
25* the General Public License version 2 (GPLv2) at this time for any
26* software where a choice of GPL license versions is made
27* available with the language indicating that GPLv2 or any later version
28* may be used, or where a choice of which version of the GPL is applied is
29* otherwise unspecified.
30*
31* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
32* CA 95054 USA or visit www.sun.com if you need additional information or
33* have any questions.
34*
35*
36* ========== Copyright Header End ============================================
37*/
38!----------------------------------------------------------------------
39! These macros read out a block of registers by using store inst
40
41#define read_locals(reg) \
42 st %l0, [reg]; \
43 st %l1, [reg]; \
44 st %l2, [reg]; \
45 st %l3, [reg]; \
46 st %l4, [reg]; \
47 st %l5, [reg]; \
48 st %l6, [reg]; \
49 st %l7, [reg]
50
51#define read_globals(reg) \
52 st %g0, [reg]; \
53 st %g1, [reg]; \
54 st %g2, [reg]; \
55 st %g3, [reg]; \
56 st %g4, [reg]; \
57 st %g5, [reg]; \
58 st %g6, [reg]; \
59 st %g7, [reg]
60
61#define read_ins(reg) \
62 st %i0, [reg]; \
63 st %i1, [reg]; \
64 st %i2, [reg]; \
65 st %i3, [reg]; \
66 st %i4, [reg]; \
67 st %i5, [reg]; \
68 st %i6, [reg]; \
69 st %i7, [reg]
70
71#define read_outs(reg) \
72 st %o0, [reg]; \
73 st %o1, [reg]; \
74 st %o2, [reg]; \
75 st %o3, [reg]; \
76 st %o4, [reg]; \
77 st %o5, [reg]; \
78 st %o6, [reg]; \
79 st %o7, [reg]
80
81!----------------------------------------------------------------------
82! This macro loads a register file block from memory
83
84#define load_local_block(addr) \
85 ldd [addr], %l0; \
86 ldd [addr + 8], %l2; \
87 ldd [addr + 16], %l4; \
88 ldd [addr + 24], %l6; \
89
90#define load_global_block(addr) \
91 ldd [addr], %g0; \
92 ldd [addr + 8], %g2; \
93 ldd [addr + 16], %g4; \
94 ldd [addr + 24], %g6; \
95
96#define load_out_block(addr) \
97 ldd [addr], %o0; \
98 ldd [addr + 8], %o2; \
99 ldd [addr + 16], %o4; \
100 ldd [addr + 24], %o6; \
101
102#define load_in_block(addr) \
103 ldd [addr], %i0; \
104 ldd [addr + 8], %i2; \
105 ldd [addr + 16], %i4; \
106 ldd [addr + 24], %i6; \
107
108!----------------------------------------------------------------------
109! This macro loads up all of the visible registers including globals
110! from the address supplied in the "reg". %g1 is assumed to be
111! this register. This will not map in a block.
112
113#define ld_no_incr_mapped(reg) \
114 mov 0x1,%l1; \
115 mov 0x2,%l2; \
116 wrpr %l1,%l2,%cansave; \
117 wrpr %l1,%l2,%canrestore; \
118 load_out_block(reg); \
119 load_local_block(reg); \
120 load_in_block(reg); \
121 mov 0x1,%l1; \
122 mov 0x2,%l2; \
123 wrpr %l1,%l2,%cansave; \
124 wrpr %l1,%l2,%canrestore; \
125 restore %g0, %g0, %g0; \
126 load_local_block(reg); \
127 load_in_block(reg); \
128 mov 0x1,%l1; \
129 mov 0x2,%l2; \
130 wrpr %l1,%l2,%cansave; \
131 wrpr %l1,%l2,%canrestore; \
132 restore %g0, %g0, %g0; \
133 load_local_block(reg); \
134 load_in_block(reg); \
135 mov 0x1,%l1; \
136 mov 0x2,%l2; \
137 wrpr %l1,%l2,%cansave; \
138 wrpr %l1,%l2,%canrestore; \
139 restore %g0, %g0, %g0; \
140 load_local_block(reg); \
141 load_in_block(reg); \
142 mov 0x1,%l1; \
143 mov 0x2,%l2; \
144 wrpr %l1,%l2,%cansave; \
145 wrpr %l1,%l2,%canrestore; \
146 restore %g0, %g0, %g0; \
147 load_local_block(reg); \
148 load_in_block(reg); \
149 mov 0x1,%l1; \
150 mov 0x2,%l2; \
151 wrpr %l1,%l2,%cansave; \
152 wrpr %l1,%l2,%canrestore; \
153 restore %g0, %g0, %g0; \
154 load_local_block(reg); \
155 load_in_block(reg); \
156 mov 0x1,%l1; \
157 mov 0x2,%l2; \
158 wrpr %l1,%l2,%cansave; \
159 wrpr %l1,%l2,%canrestore; \
160 restore %g0, %g0, %g0; \
161 load_local_block(reg); \
162 load_in_block(reg); \
163 mov 0x1,%l1; \
164 mov 0x2,%l2; \
165 wrpr %l1,%l2,%cansave; \
166 wrpr %l1,%l2,%canrestore; \
167 restore %g0, %g0, %g0; \
168 load_local_block(reg); \
169 mov 0x1,%l1; \
170 mov 0x2,%l2; \
171 wrpr %l1,%l2,%cansave; \
172 wrpr %l1,%l2,%canrestore; \
173 restore %g0, %g0, %g0; \
174 ldd [reg + 8], %g2; \
175 ldd [reg + 16], %g4; \
176 ldd [reg + 24], %g6; \
177 ldd [reg], %g0
178
179
180!----------------------------------------------------------------------
181! This macro does the read out of the specified register by
182! doing stores
183
184#define read_em_out(reg) \
185 st reg, [%l0]; \
186 or reg, reg, %g1; \
187 ld [%l0],%l1; \
188 cmp %l1,%g1; \
189 tne %icc,BAD_TRAP; \
190 st %g1, [%l0]; \
191 and reg, reg, %g1; \
192 st %g1, [%l0]
193
194!-------------------------------------------------------------------
195! These macros read all of the registers out in a block
196! Because of the way Read_em_out works, %g1 must be the first one
197! that is read out using these macros (otherwise it will get clobbered)
198
199#define read_locals_out() \
200 read_em_out(%l0); \
201 read_em_out(%l1); \
202 read_em_out(%l2); \
203 read_em_out(%l3); \
204 read_em_out(%l4); \
205 read_em_out(%l5); \
206 read_em_out(%l6); \
207 read_em_out(%l7)
208
209#define read_outs_out() \
210 read_em_out(%o0); \
211 read_em_out(%o1); \
212 read_em_out(%o2); \
213 read_em_out(%o3); \
214 read_em_out(%o4); \
215 read_em_out(%o5); \
216 read_em_out(%o6); \
217 read_em_out(%o7)
218
219#define read_ins_out() \
220 read_em_out(%i0); \
221 read_em_out(%i1); \
222 read_em_out(%i2); \
223 read_em_out(%i3); \
224 read_em_out(%i4); \
225 read_em_out(%i5); \
226 read_em_out(%i6); \
227 read_em_out(%i7)
228
229#define read_globals_out() \
230 read_em_out(%g1); \
231 read_em_out(%g0); \
232 read_em_out(%g2); \
233 read_em_out(%g3); \
234 read_em_out(%g4); \
235 read_em_out(%g5); \
236 read_em_out(%g6); \
237 read_em_out(%g7)
238
239!----------------------------------------------------------------------
240! This macro reads out the entire register file (except for any
241! blocks that are mapped out). read the globals out first
242
243#define read_em_all() \
244 mov 0x1,%l1; \
245 mov 0x2,%l2; \
246 wrpr %l1,%l2,%cansave; \
247 wrpr %l1,%l2,%canrestore; \
248 read_globals_out(); \
249 read_outs_out(); \
250 read_locals_out(); \
251 read_ins_out(); \
252 mov 0x1,%l1; \
253 mov 0x2,%l2; \
254 wrpr %l1,%l2,%cansave; \
255 wrpr %l1,%l2,%canrestore; \
256 restore %g0, %g0, %g0; \
257 read_locals_out(); \
258 read_ins_out(); \
259 mov 0x1,%l1; \
260 mov 0x2,%l2; \
261 wrpr %l1,%l2,%cansave; \
262 wrpr %l1,%l2,%canrestore; \
263 restore %g0, %g0, %g0; \
264 read_locals_out(); \
265 read_ins_out(); \
266 mov 0x1,%l1; \
267 mov 0x2,%l2; \
268 wrpr %l1,%l2,%cansave; \
269 wrpr %l1,%l2,%canrestore; \
270 restore %g0, %g0, %g0; \
271 read_locals_out(); \
272 read_ins_out(); \
273 mov 0x1,%l1; \
274 mov 0x2,%l2; \
275 wrpr %l1,%l2,%cansave; \
276 wrpr %l1,%l2,%canrestore; \
277 restore %g0, %g0, %g0; \
278 read_locals_out(); \
279 read_ins_out(); \
280 mov 0x1,%l1; \
281 mov 0x2,%l2; \
282 wrpr %l1,%l2,%cansave; \
283 wrpr %l1,%l2,%canrestore; \
284 restore %g0, %g0, %g0; \
285 read_locals_out(); \
286 read_ins_out(); \
287 mov 0x1,%l1; \
288 mov 0x2,%l2; \
289 wrpr %l1,%l2,%cansave; \
290 wrpr %l1,%l2,%canrestore; \
291 restore %g0, %g0, %g0; \
292 read_locals_out(); \
293 read_ins_out(); \
294 mov 0x1,%l1; \
295 mov 0x2,%l2; \
296 wrpr %l1,%l2,%cansave; \
297 wrpr %l1,%l2,%canrestore; \
298 restore %g0, %g0, %g0; \
299 read_locals_out(); \
300 mov 0x1,%l1; \
301 mov 0x2,%l2; \
302 wrpr %l1,%l2,%cansave; \
303 wrpr %l1,%l2,%canrestore; \
304 restore %g0, %g0, %g0
305
306!----------------------------------------------------------------------
307! These macros load up registers with the cumulative sum of the two
308! specified registers.
309
310#define load_local_sum(reg1, reg2) \
311 mov reg1, %l0; \
312 add reg1, reg2, reg1; \
313 mov reg1, %l1; \
314 add reg1, reg2, reg1; \
315 mov reg1, %l2; \
316 add reg1, reg2, reg1; \
317 mov reg1, %l3; \
318 add reg1, reg2, reg1; \
319 mov reg1, %l4; \
320 add reg1, reg2, reg1; \
321 mov reg1, %l5; \
322 add reg1, reg2, reg1; \
323 mov reg1, %l6; \
324 add reg1, reg2, reg1; \
325 mov reg1, %l7; \
326 add reg1, reg2, reg1
327
328#define load_global_sum(reg1, reg2) \
329 mov reg1, %g0; \
330 add reg1, reg2, reg1; \
331 mov reg1, %g1; \
332 add reg1, reg2, reg1; \
333 mov reg1, %g2; \
334 add reg1, reg2, reg1; \
335 mov reg1, %g3; \
336 add reg1, reg2, reg1; \
337 mov reg1, %g4; \
338 add reg1, reg2, reg1; \
339 mov reg1, %g5; \
340 add reg1, reg2, reg1; \
341 mov reg1, %g6; \
342 add reg1, reg2, reg1; \
343 mov reg1, %g7; \
344 add reg1, reg2, reg1
345
346#define load_in_sum(reg1, reg2) \
347 mov reg1, %i0; \
348 add reg1, reg2, reg1; \
349 mov reg1, %i1; \
350 add reg1, reg2, reg1; \
351 mov reg1, %i2; \
352 add reg1, reg2, reg1; \
353 mov reg1, %i3; \
354 add reg1, reg2, reg1; \
355 mov reg1, %i4; \
356 add reg1, reg2, reg1; \
357 mov reg1, %i5; \
358 add reg1, reg2, reg1; \
359 mov reg1, %i6; \
360 add reg1, reg2, reg1; \
361 mov reg1, %i7; \
362 add reg1, reg2, reg1
363
364#define load_out_sum(reg1, reg2) \
365 mov reg1, %o0; \
366 add reg1, reg2, reg1; \
367 mov reg1, %o1; \
368 add reg1, reg2, reg1; \
369 mov reg1, %o2; \
370 add reg1, reg2, reg1; \
371 mov reg1, %o3; \
372 add reg1, reg2, reg1; \
373 mov reg1, %o4; \
374 add reg1, reg2, reg1; \
375 mov reg1, %o5; \
376 add reg1, reg2, reg1; \
377 mov reg1, %o6; \
378 add reg1, reg2, reg1; \
379 mov reg1, %o7; \
380 add reg1, reg2, reg1
381
382! same as above 4 macros but also forces a read immediately
383! after the write
384
385#define load_local_sum_read(reg1, reg2) \
386 mov reg1, %l0; \
387 add reg1, reg2, reg1; \
388 mov reg1, %l1; \
389 add reg1, reg2, reg1; \
390 add %l0, %l0, %g0; \
391 mov reg1, %l2; \
392 add %l1, %l1, %g0; \
393 add reg1, reg2, reg1; \
394 mov reg1, %l3; \
395 add %l2, %l2, %g0; \
396 add reg1, reg2, reg1; \
397 mov reg1, %l4; \
398 add %l3, %l3, %g0; \
399 add reg1, reg2, reg1; \
400 mov reg1, %l5; \
401 add %l4, %l4, %g0; \
402 add reg1, reg2, reg1; \
403 mov reg1, %l6; \
404 add %l5, %l5, %g0; \
405 add reg1, reg2, reg1; \
406 mov reg1, %l7; \
407 add %l6, %l6, %g0; \
408 add reg1, reg2, reg1; \
409 nop; \
410 add %l7, %l7, %g0
411
412
413#define load_global_sum_read(reg1, reg2) \
414 mov reg1, %g0; \
415 add reg1, reg2, reg1; \
416 mov reg1, %g1; \
417 add reg1, reg2, reg1; \
418 add %g0, %g0, %g0; \
419 mov reg1, %g2; \
420 add %g1, %g1, %g0; \
421 add reg1, reg2, reg1; \
422 mov reg1, %g3; \
423 add %g2, %g2, %g0; \
424 add reg1, reg2, reg1; \
425 mov reg1, %g4; \
426 add %g3, %g3, %g0; \
427 add reg1, reg2, reg1; \
428 mov reg1, %g5; \
429 add %g4, %g4, %g0; \
430 add reg1, reg2, reg1; \
431 mov reg1, %g6; \
432 add %g5, %g5, %g0; \
433 add reg1, reg2, reg1; \
434 mov reg1, %g7; \
435 add %g6, %g6, %g0; \
436 add reg1, reg2, reg1; \
437 nop; \
438 add %g7, %g7, %g0
439
440#define load_in_sum_read(reg1, reg2) \
441 mov reg1, %i0; \
442 add reg1, reg2, reg1; \
443 mov reg1, %i1; \
444 add reg1, reg2, reg1; \
445 add %i0, %i0, %g0; \
446 mov reg1, %i2; \
447 add %i1, %i1, %g0; \
448 add reg1, reg2, reg1; \
449 mov reg1, %i3; \
450 add %i2, %i2, %g0; \
451 add reg1, reg2, reg1; \
452 mov reg1, %i4; \
453 add %i3, %i3, %g0; \
454 add reg1, reg2, reg1; \
455 mov reg1, %i5; \
456 add %i4, %i4, %g0; \
457 add reg1, reg2, reg1; \
458 mov reg1, %i6; \
459 add %i5, %i5, %g0; \
460 add reg1, reg2, reg1; \
461 mov reg1, %i7; \
462 add %i6, %i6, %g0; \
463 add reg1, reg2, reg1; \
464 nop; \
465 add %i7, %i7, %g0
466
467#define load_out_sum_read(reg1, reg2) \
468 mov reg1, %o0; \
469 add reg1, reg2, reg1; \
470 mov reg1, %o1; \
471 add reg1, reg2, reg1; \
472 add %o0, %o0, %g0; \
473 mov reg1, %o2; \
474 add %o1, %o1, %g0; \
475 add reg1, reg2, reg1; \
476 mov reg1, %o3; \
477 add %o2, %o2, %g0; \
478 add reg1, reg2, reg1; \
479 mov reg1, %o4; \
480 add %o3, %o3, %g0; \
481 add reg1, reg2, reg1; \
482 mov reg1, %o5; \
483 add %o4, %o4, %g0; \
484 add reg1, reg2, reg1; \
485 mov reg1, %o6; \
486 add %o5, %o5, %g0; \
487 add reg1, reg2, reg1; \
488 mov reg1, %o7; \
489 add %o6, %o6, %g0; \
490 add reg1, reg2, reg1; \
491 nop; \
492 add %o7, %o7, %g0
493
494!----------------------------------------------------------------------
495! This macro loads up all the visible registers (including globals)
496! using a accumulating sum.
497
498#define ld_sum_mapped(accum, incr, dum1) \
499 mov 0x1,%l1; \
500 mov 0x2,%l2; \
501 wrpr %l1,%l2,%cansave; \
502 wrpr %l1,%l2,%canrestore; \
503 mov accum, %l0; \
504 mov incr, %l1; \
505 mov dum1, %l2; \
506 load_global_sum(accum, incr); \
507 mov %l0, accum; \
508 mov %l1, incr; \
509 mov %l2, dum1; \
510 load_out_sum(accum, incr); \
511 load_local_sum(accum, incr); \
512 load_in_sum(accum, incr); \
513 set 6, dum1; \
514 3: mov 0x1,%l1; \
515 mov 0x2,%l2; \
516 wrpr %l1,%l2,%cansave; \
517 wrpr %l1,%l2,%canrestore; \
518 restore %g0, %g0, %g0; \
519 load_local_sum(accum, incr); \
520 load_in_sum(accum, incr); \
521 subcc dum1, 1, dum1; \
522 bne 3b; \
523 nop; \
524 mov 0x1,%l1; \
525 mov 0x2,%l2; \
526 wrpr %l1,%l2,%cansave; \
527 wrpr %l1,%l2,%canrestore; \
528 restore %g0, %g0, %g0; \
529 load_local_sum(accum, incr)
530
531! Same as above, but uses the macros that cause a read to
532! the just written register
533
534#define ld_sum_mapped_read(accum, incr, dum1) \
535 mov 0x1,%l1; \
536 mov 0x2,%l2; \
537 wrpr %l1,%l2,%cansave; \
538 wrpr %l1,%l2,%canrestore; \
539 mov accum, %l0; \
540 mov incr, %l1; \
541 mov dum1, %l2; \
542 load_global_sum_read(accum, incr); \
543 mov %l0, accum; \
544 mov %l1, incr; \
545 mov %l2, dum1; \
546 load_out_sum_read(accum, incr); \
547 load_local_sum_read(accum, incr); \
548 load_in_sum_read(accum, incr); \
549 set 6, dum1; \
550 3: mov 0x1,%l1; \
551 mov 0x2,%l2; \
552 wrpr %l1,%l2,%cansave; \
553 wrpr %l1,%l2,%canrestore; \
554 restore %g0, %g0, %g0; \
555 load_local_sum_read(accum, incr); \
556 load_in_sum_read(accum, incr); \
557 subcc dum1, 1, dum1; \
558 bne 3b; \
559 nop; \
560 mov 0x1,%l1; \
561 mov 0x2,%l2; \
562 wrpr %l1,%l2,%cansave; \
563 wrpr %l1,%l2,%canrestore; \
564 restore %g0, %g0, %g0; \
565 load_local_sum_read(accum, incr)
Full OpenSPARC design & verification tarball including full HDL.