2 * Copyright (c) 2017 Lima Project
3 * Copyright (c) 2013 Connor Abbott
5 * Permission is hereby granted, free of charge, to any person obtaining a copy
6 * of this software and associated documentation files (the "Software"), to deal
7 * in the Software without restriction, including without limitation the rights
8 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
9 * copies of the Software, and to permit persons to whom the Software is
10 * furnished to do so, subject to the following conditions:
12 * The above copyright notice and this permission notice shall be included in
13 * all copies or substantial portions of the Software.
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
25 #ifndef LIMA_IR_PP_PPIR_H
26 #define LIMA_IR_PP_PPIR_H
28 #include "util/u_math.h"
29 #include "util/list.h"
32 #include "ir/lima_ir.h"
100 ppir_op_load_varying
,
102 ppir_op_load_coords_reg
,
103 ppir_op_load_fragcoord
,
104 ppir_op_load_pointcoord
,
105 ppir_op_load_frontface
,
106 ppir_op_load_texture
,
124 ppir_node_type_const
,
126 ppir_node_type_store
,
127 ppir_node_type_load_texture
,
128 ppir_node_type_discard
,
129 ppir_node_type_branch
,
138 extern const ppir_op_info ppir_op_infos
[];
142 ppir_dep_write_after_read
,
149 struct list_head pred_link
;
150 struct list_head succ_link
;
153 typedef struct ppir_node
{
154 struct list_head list
;
160 struct ppir_instr
*instr
;
162 struct ppir_block
*block
;
166 struct list_head succ_list
;
167 struct list_head pred_list
;
171 ppir_pipeline_reg_const0
,
172 ppir_pipeline_reg_const1
,
173 ppir_pipeline_reg_sampler
,
174 ppir_pipeline_reg_uniform
,
175 ppir_pipeline_reg_vmul
,
176 ppir_pipeline_reg_fmul
,
177 ppir_pipeline_reg_discard
, /* varying load */
180 typedef struct ppir_reg
{
181 struct list_head list
;
186 /* whether this reg has to start from the x component
187 * of a full physical reg, this is true for reg used
188 * in load/store instr which has no swizzle field */
196 ppir_target_pipeline
,
197 ppir_target_register
,
200 typedef struct ppir_src
{
207 ppir_pipeline pipeline
;
211 bool absolute
, negate
;
216 ppir_outmod_clamp_fraction
,
217 ppir_outmod_clamp_positive
,
221 typedef struct ppir_dest
{
227 ppir_pipeline pipeline
;
230 ppir_outmod modifier
;
231 unsigned write_mask
: 4;
239 int shift
: 3; /* Only used for ppir_op_mul */
242 typedef struct ppir_const
{
272 ppir_src src
[2]; /* src[0] temporarily stores src_coords,
273 not to be used after lowering */
279 } ppir_load_texture_node
;
285 enum ppir_instr_slot
{
286 PPIR_INSTR_SLOT_VARYING
,
287 PPIR_INSTR_SLOT_TEXLD
,
288 PPIR_INSTR_SLOT_UNIFORM
,
289 PPIR_INSTR_SLOT_ALU_VEC_MUL
,
290 PPIR_INSTR_SLOT_ALU_SCL_MUL
,
291 PPIR_INSTR_SLOT_ALU_VEC_ADD
,
292 PPIR_INSTR_SLOT_ALU_SCL_ADD
,
293 PPIR_INSTR_SLOT_ALU_COMBINE
,
294 PPIR_INSTR_SLOT_STORE_TEMP
,
295 PPIR_INSTR_SLOT_BRANCH
,
298 PPIR_INSTR_SLOT_ALU_START
= PPIR_INSTR_SLOT_ALU_VEC_MUL
,
299 PPIR_INSTR_SLOT_ALU_END
= PPIR_INSTR_SLOT_ALU_COMBINE
,
302 struct ppir_liveness
{
307 typedef struct ppir_instr
{
308 struct list_head list
;
311 int seq
; /* command sequence after schedule */
313 ppir_node
*slots
[PPIR_INSTR_SLOT_NUM
];
314 ppir_const constant
[2];
318 struct list_head succ_list
;
319 struct list_head pred_list
;
321 int est
; /* earliest start time */
327 /* for liveness analysis */
328 struct ppir_liveness
*live_in
;
329 struct ppir_liveness
*live_out
;
330 /* live_internal is to mark registers only live within an
331 * instruction, without propagation */
332 struct ppir_liveness
*live_internal
;
333 struct set
*live_in_set
;
334 struct set
*live_out_set
;
335 struct set
*live_internal_set
;
338 typedef struct ppir_block
{
339 struct list_head list
;
340 struct list_head node_list
;
341 struct list_head instr_list
;
343 struct ppir_block
*successors
[2];
345 struct ppir_compiler
*comp
;
348 int sched_instr_index
;
349 int sched_instr_base
;
352 /* for liveness analysis */
353 struct ppir_liveness
*live_in
;
354 struct ppir_liveness
*live_out
;
355 struct set
*live_in_set
;
356 struct set
*live_out_set
;
371 struct lima_fs_shader_state
;
373 typedef struct ppir_compiler
{
374 struct list_head block_list
;
375 struct hash_table_u64
*blocks
;
379 struct list_head reg_list
;
381 /* array for searching ssa/reg node */
382 ppir_node
**var_nodes
;
386 struct lima_fs_shader_state
*prog
;
390 int sched_instr_base
;
392 /* for regalloc spilling debug */
400 ppir_block
*discard_block
;
401 ppir_block
*current_block
;
402 ppir_block
*loop_break_block
;
403 ppir_block
*loop_cont_block
;
406 void *ppir_node_create(ppir_block
*block
, ppir_op op
, int index
, unsigned mask
);
407 void ppir_node_add_dep(ppir_node
*succ
, ppir_node
*pred
, ppir_dep_type type
);
408 void ppir_node_remove_dep(ppir_dep
*dep
);
409 void ppir_node_delete(ppir_node
*node
);
410 void ppir_node_print_prog(ppir_compiler
*comp
);
411 void ppir_node_replace_child(ppir_node
*parent
, ppir_node
*old_child
, ppir_node
*new_child
);
412 void ppir_node_replace_all_succ(ppir_node
*dst
, ppir_node
*src
);
413 void ppir_node_replace_pred(ppir_dep
*dep
, ppir_node
*new_pred
);
414 ppir_dep
*ppir_dep_for_pred(ppir_node
*node
, ppir_node
*pred
);
415 /* Assumes that node successors are in the same block */
416 ppir_node
*ppir_node_insert_mov(ppir_node
*node
);
417 ppir_node
*ppir_node_insert_mov_all_blocks(ppir_node
*node
);
419 static inline bool ppir_node_is_root(ppir_node
*node
)
421 return list_is_empty(&node
->succ_list
);
424 static inline bool ppir_node_is_leaf(ppir_node
*node
)
426 return list_is_empty(&node
->pred_list
);
429 static inline bool ppir_node_has_single_succ(ppir_node
*node
)
431 return list_is_singular(&node
->succ_list
);
434 bool ppir_node_has_single_src_succ(ppir_node
*node
);
436 static inline ppir_node
*ppir_node_first_succ(ppir_node
*node
)
438 return list_first_entry(&node
->succ_list
, ppir_dep
, succ_link
)->succ
;
441 static inline bool ppir_node_has_single_pred(ppir_node
*node
)
443 return list_is_singular(&node
->pred_list
);
446 static inline ppir_node
*ppir_node_first_pred(ppir_node
*node
)
448 return list_first_entry(&node
->pred_list
, ppir_dep
, pred_link
)->pred
;
451 #define ppir_node_foreach_succ(node, dep) \
452 list_for_each_entry(ppir_dep, dep, &node->succ_list, succ_link)
453 #define ppir_node_foreach_succ_safe(node, dep) \
454 list_for_each_entry_safe(ppir_dep, dep, &node->succ_list, succ_link)
455 #define ppir_node_foreach_pred(node, dep) \
456 list_for_each_entry(ppir_dep, dep, &node->pred_list, pred_link)
457 #define ppir_node_foreach_pred_safe(node, dep) \
458 list_for_each_entry_safe(ppir_dep, dep, &node->pred_list, pred_link)
460 #define ppir_node_to_alu(node) ((ppir_alu_node *)(node))
461 #define ppir_node_to_const(node) ((ppir_const_node *)(node))
462 #define ppir_node_to_load(node) ((ppir_load_node *)(node))
463 #define ppir_node_to_store(node) ((ppir_store_node *)(node))
464 #define ppir_node_to_load_texture(node) ((ppir_load_texture_node *)(node))
465 #define ppir_node_to_discard(node) ((ppir_discard_node *)(node))
466 #define ppir_node_to_branch(node) ((ppir_branch_node *)(node))
468 static inline ppir_dest
*ppir_node_get_dest(ppir_node
*node
)
470 switch (node
->type
) {
471 case ppir_node_type_alu
:
472 return &ppir_node_to_alu(node
)->dest
;
473 case ppir_node_type_load
:
474 return &ppir_node_to_load(node
)->dest
;
475 case ppir_node_type_const
:
476 return &ppir_node_to_const(node
)->dest
;
477 case ppir_node_type_load_texture
:
478 return &ppir_node_to_load_texture(node
)->dest
;
484 static inline int ppir_node_get_src_num(ppir_node
*node
)
486 switch (node
->type
) {
487 case ppir_node_type_alu
:
488 return ppir_node_to_alu(node
)->num_src
;
489 case ppir_node_type_branch
:
490 return ppir_node_to_branch(node
)->num_src
;
491 case ppir_node_type_load
:
492 return ppir_node_to_load(node
)->num_src
;
493 case ppir_node_type_load_texture
:
494 return ppir_node_to_load_texture(node
)->num_src
;
495 case ppir_node_type_store
:
504 static inline ppir_src
*ppir_node_get_src(ppir_node
*node
, int idx
)
506 if (idx
< 0 || idx
>= ppir_node_get_src_num(node
))
509 switch (node
->type
) {
510 case ppir_node_type_alu
:
511 return &ppir_node_to_alu(node
)->src
[idx
];
512 case ppir_node_type_branch
:
513 return &ppir_node_to_branch(node
)->src
[idx
];
514 case ppir_node_type_load_texture
:
515 return &ppir_node_to_load_texture(node
)->src
[idx
];
516 case ppir_node_type_load
:
517 return &ppir_node_to_load(node
)->src
;
518 case ppir_node_type_store
:
519 return &ppir_node_to_store(node
)->src
;
527 static inline ppir_reg
*ppir_src_get_reg(ppir_src
*src
)
530 case ppir_target_ssa
:
532 case ppir_target_register
:
539 static inline ppir_reg
*ppir_dest_get_reg(ppir_dest
*dest
)
541 switch (dest
->type
) {
542 case ppir_target_ssa
:
544 case ppir_target_register
:
551 static inline void ppir_node_target_assign(ppir_src
*src
, ppir_node
*node
)
553 ppir_dest
*dest
= ppir_node_get_dest(node
);
554 src
->type
= dest
->type
;
556 case ppir_target_ssa
:
557 src
->ssa
= &dest
->ssa
;
560 case ppir_target_register
:
561 src
->reg
= dest
->reg
;
562 /* Registers can be assigned from multiple nodes, so don't keep
563 * pointer to the node here
567 case ppir_target_pipeline
:
568 src
->pipeline
= dest
->pipeline
;
574 static inline bool ppir_node_target_equal(ppir_src
*src
, ppir_dest
*dest
)
576 if (src
->type
!= dest
->type
||
577 (src
->type
== ppir_target_ssa
&& src
->ssa
!= &dest
->ssa
) ||
578 (src
->type
== ppir_target_register
&& src
->reg
!= dest
->reg
) ||
579 (src
->type
== ppir_target_pipeline
&& src
->pipeline
!= dest
->pipeline
))
585 static inline int ppir_target_get_src_reg_index(ppir_src
*src
)
588 case ppir_target_ssa
:
590 return src
->ssa
->index
;
592 case ppir_target_register
:
594 return src
->reg
->index
;
596 case ppir_target_pipeline
:
597 if (src
->pipeline
== ppir_pipeline_reg_discard
)
599 return (src
->pipeline
+ 12) * 4;
605 static inline int ppir_target_get_dest_reg_index(ppir_dest
*dest
)
607 switch (dest
->type
) {
608 case ppir_target_ssa
:
609 return dest
->ssa
.index
;
610 case ppir_target_register
:
611 return dest
->reg
->index
;
612 case ppir_target_pipeline
:
613 if (dest
->pipeline
== ppir_pipeline_reg_discard
)
615 return (dest
->pipeline
+ 12) * 4;
621 static inline int ppir_src_get_mask(ppir_src
*src
)
623 ppir_reg
*reg
= ppir_src_get_reg(src
);
626 for (int i
= 0; i
< reg
->num_components
; i
++)
627 mask
|= (1 << src
->swizzle
[i
]);
632 static inline bool ppir_target_is_scalar(ppir_dest
*dest
)
634 switch (dest
->type
) {
635 case ppir_target_ssa
:
636 return dest
->ssa
.num_components
== 1;
637 case ppir_target_register
:
638 /* only one bit in mask is set */
639 if ((dest
->write_mask
& 0x3) == 0x3 ||
640 (dest
->write_mask
& 0x5) == 0x5 ||
641 (dest
->write_mask
& 0x9) == 0x9 ||
642 (dest
->write_mask
& 0x6) == 0x6 ||
643 (dest
->write_mask
& 0xa) == 0xa ||
644 (dest
->write_mask
& 0xc) == 0xc)
648 case ppir_target_pipeline
:
649 if (dest
->pipeline
== ppir_pipeline_reg_fmul
)
658 static inline bool ppir_node_schedulable_slot(ppir_node
*node
,
659 enum ppir_instr_slot slot
)
661 int *slots
= ppir_op_infos
[node
->op
].slots
;
662 for (int i
= 0; slots
[i
] != PPIR_INSTR_SLOT_END
; i
++)
663 if (slots
[i
] == slot
)
669 ppir_instr
*ppir_instr_create(ppir_block
*block
);
670 bool ppir_instr_insert_node(ppir_instr
*instr
, ppir_node
*node
);
671 void ppir_instr_add_dep(ppir_instr
*succ
, ppir_instr
*pred
);
672 void ppir_instr_print_list(ppir_compiler
*comp
);
673 void ppir_instr_print_dep(ppir_compiler
*comp
);
674 void ppir_instr_insert_mul_node(ppir_node
*add
, ppir_node
*mul
);
676 #define ppir_instr_foreach_succ(instr, dep) \
677 list_for_each_entry(ppir_dep, dep, &instr->succ_list, succ_link)
678 #define ppir_instr_foreach_succ_safe(instr, dep) \
679 list_for_each_entry_safe(ppir_dep, dep, &instr->succ_list, succ_link)
680 #define ppir_instr_foreach_pred(instr, dep) \
681 list_for_each_entry(ppir_dep, dep, &instr->pred_list, pred_link)
682 #define ppir_instr_foreach_pred_safe(instr, dep) \
683 list_for_each_entry_safe(ppir_dep, dep, &instr->pred_list, pred_link)
685 static inline bool ppir_instr_is_root(ppir_instr
*instr
)
687 return list_is_empty(&instr
->succ_list
);
690 static inline bool ppir_instr_is_leaf(ppir_instr
*instr
)
692 return list_is_empty(&instr
->pred_list
);
695 bool ppir_lower_prog(ppir_compiler
*comp
);
696 bool ppir_node_to_instr(ppir_compiler
*comp
);
697 bool ppir_schedule_prog(ppir_compiler
*comp
);
698 bool ppir_regalloc_prog(ppir_compiler
*comp
);
699 bool ppir_codegen_prog(ppir_compiler
*comp
);
700 void ppir_liveness_analysis(ppir_compiler
*comp
);