2 * Copyright 2010 Christoph Bumiller
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
11 * The above copyright notice and this permission notice shall be included in
12 * all copies or substantial portions of the Software.
14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
17 * THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
18 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
19 * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
23 #ifndef __NVC0_COMPILER_H__
24 #define __NVC0_COMPILER_H__
30 # define NOUVEAU_DBG(args...) debug_printf(args);
32 # define NOUVEAU_DBG(args...)
37 #define NOUVEAU_ERR(fmt, args...) \
38 fprintf(stderr, "%s:%d - "fmt, __FUNCTION__, __LINE__, ##args);
41 #include "pipe/p_defines.h"
42 #include "util/u_inlines.h"
43 #include "util/u_memory.h"
44 #include "util/u_double_list.h"
51 #define NV_OP_SELECT 4
55 * BIND forces source operand i into the same register as destination operand i,
56 * and the operands will be assigned consecutive registers (needed for TEX)
57 * SELECT forces its multiple source operands and its destination operand into
58 * one and the same register.
82 #define NV_OP_FLOOR 26
83 #define NV_OP_TRUNC 27
87 #define NV_OP_VFETCH 29
88 #define NV_OP_PFETCH 30
89 #define NV_OP_EXPORT 31
90 #define NV_OP_LINTERP 32
91 #define NV_OP_PINTERP 33
93 #define NV_OP_RESTART 35
99 #define NV_OP_QUADOP 41
100 #define NV_OP_DFDX 42
101 #define NV_OP_DFDY 43
104 /* control flow opcodes */
106 #define NV_OP_CALL 46
108 #define NV_OP_EXIT 48
109 #define NV_OP_BREAK 49
110 #define NV_OP_BREAKADDR 50
111 #define NV_OP_JOINAT 51
112 #define NV_OP_JOIN 52
115 #define NV_OP_ADD_F32 NV_OP_ADD
116 #define NV_OP_ADD_B32 53
117 #define NV_OP_MUL_F32 NV_OP_MUL
118 #define NV_OP_MUL_B32 54
119 #define NV_OP_ABS_F32 NV_OP_ABS
120 #define NV_OP_ABS_S32 55
121 #define NV_OP_NEG_F32 NV_OP_NEG
122 #define NV_OP_NEG_S32 56
123 #define NV_OP_MAX_F32 NV_OP_MAX
124 #define NV_OP_MAX_S32 57
125 #define NV_OP_MAX_U32 58
126 #define NV_OP_MIN_F32 NV_OP_MIN
127 #define NV_OP_MIN_S32 59
128 #define NV_OP_MIN_U32 60
129 #define NV_OP_SET_F32 61
130 #define NV_OP_SET_S32 62
131 #define NV_OP_SET_U32 63
139 #define NV_OP_PRESIN 71
140 #define NV_OP_PREEX2 72
143 /* newly added opcodes */
144 #define NV_OP_SET_F32_AND 74
145 #define NV_OP_SET_F32_OR 75
146 #define NV_OP_SET_F32_XOR 76
147 #define NV_OP_SELP 77
148 #define NV_OP_SLCT 78
149 #define NV_OP_SLCT_F32 NV_OP_SLCT
150 #define NV_OP_SLCT_S32 79
151 #define NV_OP_SLCT_U32 80
152 #define NV_OP_SUB_F32 NV_OP_SUB
153 #define NV_OP_SUB_S32 81
154 #define NV_OP_MAD_F32 NV_OP_MAD
155 #define NV_OP_FSET_F32 82
158 #define NV_OP_COUNT 84
160 /* nv50 files omitted */
161 #define NV_FILE_GPR 0
162 #define NV_FILE_COND 1
163 #define NV_FILE_PRED 2
164 #define NV_FILE_IMM 16
165 #define NV_FILE_MEM_S 32
166 #define NV_FILE_MEM_V 34
167 #define NV_FILE_MEM_A 35
168 #define NV_FILE_MEM_L 48
169 #define NV_FILE_MEM_G 64
170 #define NV_FILE_MEM_C(i) (80 + i)
172 #define NV_IS_MEMORY_FILE(f) ((f) >= NV_FILE_MEM_S)
179 #define NV_TYPE_U8 0x00
180 #define NV_TYPE_S8 0x01
181 #define NV_TYPE_U16 0x02
182 #define NV_TYPE_S16 0x03
183 #define NV_TYPE_U32 0x04
184 #define NV_TYPE_S32 0x05
185 #define NV_TYPE_P32 0x07
186 #define NV_TYPE_F32 0x09
187 #define NV_TYPE_F64 0x0b
188 #define NV_TYPE_VEC(x, n) (NV_TYPE_##x | (n << 4))
189 #define NV_TYPE_ANY 0xff
191 #define NV_TYPE_ISINT(t) ((t) < 7)
192 #define NV_TYPE_ISSGD(t) ((t) & 1)
208 #define NV_PC_MAX_INSTRUCTIONS 2048
209 #define NV_PC_MAX_VALUES (NV_PC_MAX_INSTRUCTIONS * 4)
211 #define NV_PC_MAX_BASIC_BLOCKS 1024
214 uint base
; /* e.g. ADD_S32 -> ADD */
219 unsigned commutative
: 1;
221 unsigned predicate
: 1;
223 unsigned immediate
: 3;
227 extern struct nv_op_info nvc0_op_info_table
[];
229 #define NV_BASEOP(op) (nvc0_op_info_table[op].base)
230 #define NV_OPTYPE(op) (nvc0_op_info_table[op].type)
233 nv_op_base(uint opcode
)
235 return nvc0_op_info_table
[opcode
].base
;
238 static INLINE boolean
239 nv_is_texture_op(uint opcode
)
241 return (opcode
>= NV_OP_TEX
&& opcode
<= NV_OP_TXQ
);
244 static INLINE boolean
245 nv_is_vector_op(uint opcode
)
247 return nvc0_op_info_table
[opcode
].vector
? TRUE
: FALSE
;
250 static INLINE boolean
251 nv_op_commutative(uint opcode
)
253 return nvc0_op_info_table
[opcode
].commutative
? TRUE
: FALSE
;
256 static INLINE
uint8_t
257 nv_op_supported_src_mods(uint opcode
)
259 return nvc0_op_info_table
[opcode
].mods
;
262 static INLINE boolean
263 nv_op_predicateable(uint opcode
)
265 return nvc0_op_info_table
[opcode
].predicate
? TRUE
: FALSE
;
269 nv_type_order(ubyte type
)
271 switch (type
& 0xf) {
291 nv_type_sizeof(ubyte type
)
294 return (1 << nv_type_order(type
)) * (type
>> 4);
295 return 1 << nv_type_order(type
);
299 nv_type_sizeof_base(ubyte type
)
301 return 1 << nv_type_order(type
);
305 uint32_t address
; /* for memory locations */
306 int id
; /* for registers */
320 struct nv_range
*next
;
329 struct nv_instruction
*insn
;
330 struct nv_value
*join
;
331 struct nv_ref
*last_use
;
333 struct nv_range
*livei
;
335 struct nv_value
*next
;
336 struct nv_value
*prev
;
340 struct nv_value
*value
;
341 struct nv_instruction
*insn
;
342 struct list_head list
; /* connects uses of the same value */
347 struct nv_basic_block
;
349 struct nv_instruction
{
350 struct nv_instruction
*next
;
351 struct nv_instruction
*prev
;
355 struct nv_value
*def
[5];
356 struct nv_ref
*src
[6];
358 int8_t predicate
; /* index of predicate src */
359 int8_t indirect
; /* index of pointer src */
363 uint8_t t
; /* TIC binding */
364 uint8_t s
; /* TSC binding */
367 uint8_t d
; /* output type */
368 uint8_t s
; /* input type */
372 struct nv_basic_block
*bb
;
373 struct nv_basic_block
*target
; /* target block of control flow insn */
375 unsigned cc
: 5; /* condition code */
376 unsigned fixed
: 1; /* don't optimize away (prematurely) */
377 unsigned terminator
: 1;
379 unsigned set_cond
: 4; /* 2nd byte */
380 unsigned saturate
: 1;
381 unsigned centroid
: 1;
384 unsigned lanes
: 4; /* 3rd byte */
385 unsigned tex_dim
: 2;
386 unsigned tex_array
: 1;
387 unsigned tex_cube
: 1;
388 unsigned tex_shadow
: 1; /* 4th byte */
389 unsigned tex_live
: 1;
390 unsigned tex_mask
: 4;
396 nvi_vector_size(struct nv_instruction
*nvi
)
400 for (i
= 0; i
< 5 && nvi
->def
[i
]; ++i
);
404 #define CFG_EDGE_FORWARD 0
405 #define CFG_EDGE_BACK 1
406 #define CFG_EDGE_LOOP_ENTER 2
407 #define CFG_EDGE_LOOP_LEAVE 4
408 #define CFG_EDGE_FAKE 8
410 /* 'WALL' edge means where reachability check doesn't follow */
411 /* 'LOOP' edge means just having to do with loops */
412 #define IS_LOOP_EDGE(k) ((k) & 7)
413 #define IS_WALL_EDGE(k) ((k) & 9)
415 struct nv_basic_block
{
416 struct nv_instruction
*entry
; /* first non-phi instruction */
417 struct nv_instruction
*exit
;
418 struct nv_instruction
*phi
; /* very first instruction */
419 int num_instructions
;
421 struct nv_basic_block
*out
[2]; /* no indirect branches -> 2 */
422 struct nv_basic_block
*in
[8]; /* hope that suffices */
429 uint priv
; /* reset to 0 after you're done */
432 uint32_t emit_pos
; /* position, size in emitted code (in bytes) */
435 uint32_t live_set
[NV_PC_MAX_VALUES
/ 32];
438 struct nvc0_translation_info
;
441 struct nv_basic_block
**root
;
442 struct nv_basic_block
*current_block
;
443 struct nv_basic_block
*parent_block
;
445 int loop_nesting_bound
;
448 struct nv_value values
[NV_PC_MAX_VALUES
];
449 struct nv_instruction instructions
[NV_PC_MAX_INSTRUCTIONS
];
450 struct nv_ref
**refs
;
451 struct nv_basic_block
*bb_list
[NV_PC_MAX_BASIC_BLOCKS
];
453 int num_instructions
;
460 uint32_t *immd_buf
; /* populated on emit */
470 /* optimization enables */
471 boolean opt_reload_elim
;
475 void nvc0_insn_append(struct nv_basic_block
*, struct nv_instruction
*);
476 void nvc0_insn_insert_after(struct nv_instruction
*, struct nv_instruction
*);
478 static INLINE
struct nv_instruction
*
479 nv_alloc_instruction(struct nv_pc
*pc
, uint opcode
)
481 struct nv_instruction
*insn
;
483 insn
= &pc
->instructions
[pc
->num_instructions
++];
484 assert(pc
->num_instructions
< NV_PC_MAX_INSTRUCTIONS
);
486 insn
->opcode
= opcode
;
489 insn
->predicate
= -1;
494 static INLINE
struct nv_instruction
*
495 new_instruction(struct nv_pc
*pc
, uint opcode
)
497 struct nv_instruction
*insn
= nv_alloc_instruction(pc
, opcode
);
499 nvc0_insn_append(pc
->current_block
, insn
);
503 static INLINE
struct nv_instruction
*
504 new_instruction_at(struct nv_pc
*pc
, struct nv_instruction
*at
, uint opcode
)
506 struct nv_instruction
*insn
= nv_alloc_instruction(pc
, opcode
);
508 nvc0_insn_insert_after(at
, insn
);
512 static INLINE
struct nv_value
*
513 new_value(struct nv_pc
*pc
, ubyte file
, ubyte size
)
515 struct nv_value
*value
= &pc
->values
[pc
->num_values
];
517 assert(pc
->num_values
< NV_PC_MAX_VALUES
- 1);
519 value
->n
= pc
->num_values
++;
522 value
->reg
.file
= file
;
523 value
->reg
.size
= size
;
527 static INLINE
struct nv_value
*
528 new_value_like(struct nv_pc
*pc
, struct nv_value
*like
)
530 return new_value(pc
, like
->reg
.file
, like
->reg
.size
);
533 static INLINE
struct nv_ref
*
534 new_ref(struct nv_pc
*pc
, struct nv_value
*val
)
539 if ((pc
->num_refs
% 64) == 0) {
540 const unsigned old_size
= pc
->num_refs
* sizeof(struct nv_ref
*);
541 const unsigned new_size
= (pc
->num_refs
+ 64) * sizeof(struct nv_ref
*);
543 pc
->refs
= REALLOC(pc
->refs
, old_size
, new_size
);
545 ref
= CALLOC(64, sizeof(struct nv_ref
));
546 for (i
= 0; i
< 64; ++i
)
547 pc
->refs
[pc
->num_refs
+ i
] = &ref
[i
];
550 ref
= pc
->refs
[pc
->num_refs
++];
553 LIST_INITHEAD(&ref
->list
);
559 static INLINE
struct nv_basic_block
*
560 new_basic_block(struct nv_pc
*pc
)
562 struct nv_basic_block
*bb
;
564 if (pc
->num_blocks
>= NV_PC_MAX_BASIC_BLOCKS
)
567 bb
= CALLOC_STRUCT(nv_basic_block
);
569 bb
->id
= pc
->num_blocks
;
570 pc
->bb_list
[pc
->num_blocks
++] = bb
;
575 nv_reference(struct nv_pc
*pc
,
576 struct nv_instruction
*nvi
, int c
, struct nv_value
*s
)
578 struct nv_ref
**d
= &nvi
->src
[c
];
583 LIST_DEL(&(*d
)->list
);
591 LIST_DEL(&(*d
)->list
);
598 LIST_ADDTAIL(&s
->last_use
->list
, &(*d
)->list
);
608 void nvc0_emit_instruction(struct nv_pc
*, struct nv_instruction
*);
611 const char *nvc0_opcode_name(uint opcode
);
612 void nvc0_print_instruction(struct nv_instruction
*);
615 void nvc0_print_function(struct nv_basic_block
*root
);
616 void nvc0_print_program(struct nv_pc
*);
618 boolean
nvc0_insn_can_load(struct nv_instruction
*, int s
,
619 struct nv_instruction
*);
620 boolean
nvc0_insn_is_predicateable(struct nv_instruction
*);
622 int nvc0_insn_refcount(struct nv_instruction
*);
623 void nvc0_insn_delete(struct nv_instruction
*);
624 void nvc0_insns_permute(struct nv_instruction
*prev
, struct nv_instruction
*);
626 void nvc0_bblock_attach(struct nv_basic_block
*parent
,
627 struct nv_basic_block
*child
, ubyte edge_kind
);
628 boolean
nvc0_bblock_dominated_by(struct nv_basic_block
*,
629 struct nv_basic_block
*);
630 boolean
nvc0_bblock_reachable_by(struct nv_basic_block
*future
,
631 struct nv_basic_block
*past
,
632 struct nv_basic_block
*final
);
633 struct nv_basic_block
*nvc0_bblock_dom_frontier(struct nv_basic_block
*);
635 int nvc0_pc_replace_value(struct nv_pc
*pc
,
636 struct nv_value
*old_val
,
637 struct nv_value
*new_val
);
639 struct nv_value
*nvc0_pc_find_immediate(struct nv_ref
*);
640 struct nv_value
*nvc0_pc_find_constant(struct nv_ref
*);
642 typedef void (*nv_pc_pass_func
)(void *priv
, struct nv_basic_block
*b
);
644 void nvc0_pc_pass_in_order(struct nv_basic_block
*, nv_pc_pass_func
, void *);
646 int nvc0_pc_exec_pass0(struct nv_pc
*pc
);
647 int nvc0_pc_exec_pass1(struct nv_pc
*pc
);
648 int nvc0_pc_exec_pass2(struct nv_pc
*pc
);
650 int nvc0_tgsi_to_nc(struct nv_pc
*, struct nvc0_translation_info
*);
652 #endif // NV50_COMPILER_H