Lines Matching defs:clause
50 /* State of a single tuple and clause under construction */
72 /* Is this the last tuple in the clause */
106 /* Index of the constant into the clause */
308 struct bi_clause_state *clause, struct bi_tuple_state *tuple)
330 bi_lower_atom_c(bi_context *ctx, struct bi_clause_state *clause, struct
349 bi_lower_atom_c1(bi_context *ctx, struct bi_clause_state *clause, struct
371 struct bi_clause_state *clause, struct bi_tuple_state *tuple)
391 struct bi_clause_state *clause, struct bi_tuple_state *tuple)
552 * paired instructions) can run afoul of the "no two writes on the last clause"
721 /* Counts the number of 64-bit constants required by a clause. TODO: We
726 bi_nconstants(struct bi_clause_state *clause)
730 for (unsigned i = 0; i < ARRAY_SIZE(clause->consts); ++i)
731 count_32 += clause->consts[i].constant_count;
739 bi_space_for_more_constants(struct bi_clause_state *clause)
741 return (bi_nconstants(clause) < 13 - (clause->tuple_count + 1));
750 bi_update_fau(struct bi_clause_state *clause,
819 /* Constants per clause may be limited by tuple count */
821 bi_space_for_more_constants(clause);
978 struct bi_clause_state *clause,
987 /* There can only be one message-passing instruction per clause */
988 if (bi_must_message(instr) && clause->message)
999 * same clause (most likely they will not), so if a later instruction
1000 * in the clause accesses the destination, the message-passing
1007 for (unsigned i = 0; i < clause->access_count; ++i) {
1008 bi_index idx = clause->accesses[i];
1021 for (unsigned i = 0; i < clause->access_count; ++i) {
1022 bi_index idx = clause->accesses[i];
1032 if (!bi_update_fau(clause, tuple, instr, fma, false))
1048 /* Last tuple in a clause can only write a single value */
1064 can_spill_to_moves &= (bi_nconstants(clause) < 13 - (clause->tuple_count + 2));
1065 can_spill_to_moves &= (clause->tuple_count < 7);
1094 * later in the clause, so schedule them as late within a clause as
1109 struct bi_clause_state *clause,
1120 if (!bi_instr_schedulable(instr, clause, tuple, live_after_temp, fma))
1140 bi_pop_instr(struct bi_clause_state *clause, struct bi_tuple_state *tuple,
1143 bi_update_fau(clause, tuple, instr, fma, true);
1146 assert(clause->access_count + BI_MAX_SRCS + BI_MAX_DESTS <= ARRAY_SIZE(clause->accesses));
1147 memcpy(clause->accesses + clause->access_count, instr->src, sizeof(instr->src));
1148 clause->access_count += BI_MAX_SRCS;
1149 memcpy(clause->accesses + clause->access_count, instr->dest, sizeof(instr->dest));
1150 clause->access_count += BI_MAX_DESTS;
1164 struct bi_clause_state *clause,
1170 return bi_lower_cubeface(ctx, clause, tuple);
1172 return bi_lower_atom_c(ctx, clause, tuple);
1174 return bi_lower_atom_c1(ctx, clause, tuple);
1176 return bi_lower_seg_add(ctx, clause, tuple);
1178 return bi_lower_dtsel(ctx, clause, tuple);
1191 bi_pop_instr(clause, tuple, mov, live_after_temp, fma);
1201 unsigned idx = bi_choose_index(st, clause, tuple, live_after_temp, fma);
1211 bi_pop_instr(clause, tuple, instr, live_after_temp, fma);
1362 /* Merges constants in a clause, satisfying the following rules, assuming no
1497 * swapping all references so the meaning of the clause is preserved */
1536 * (with clause format 12), with M1 values computed from the pair */
1585 /* Schedule a single clause. If no instructions remain, return NULL. */
1591 bi_clause *clause = rzalloc(ctx, bi_clause);
1594 const unsigned max_tuples = ARRAY_SIZE(clause->tuples);
1597 clause->flow_control = BIFROST_FLOW_NBTB;
1599 /* The last clause can only write one instruction, so initialize that */
1615 .last = (clause->tuple_count == 0),
1625 unsigned idx = max_tuples - clause->tuple_count - 1;
1627 tuple = &clause->tuples[idx];
1629 if (clause->message && bi_opcode_props[clause->message->op].sr_read && !bi_is_null(clause->message->src[0])) {
1630 unsigned nr = bi_count_read_registers(clause->message, 0);
1631 live_after_temp |= (BITFIELD64_MASK(nr) << clause->message->src[0].value);
1650 /* We may have a message, but only one per clause */
1655 clause->message_type =
1657 clause->message = tuple->add;
1665 clause->dependencies |= (1 << BIFROST_SLOT_ELDEST_DEPTH);
1669 clause->dependencies |= (1 << BIFROST_SLOT_ELDEST_COLOUR);
1672 clause->dependencies |= (1 << BIFROST_SLOT_ELDEST_DEPTH);
1673 clause->dependencies |= (1 << BIFROST_SLOT_ELDEST_COLOUR);
1718 clause->tuple_count++;
1735 } while(clause->tuple_count < 8);
1737 /* Don't schedule an empty clause */
1738 if (!clause->tuple_count)
1742 for (unsigned i = max_tuples - clause->tuple_count; i < max_tuples; ++i) {
1743 bi_tuple *tuple = &clause->tuples[i];
1765 constant_pairs, &pcrel_idx, clause->tuple_count,
1768 clause->pcrel_idx = pcrel_idx;
1770 for (unsigned i = max_tuples - clause->tuple_count; i < max_tuples; ++i) {
1771 bi_tuple *tuple = &clause->tuples[i];
1792 clause->constant_count = constant_words;
1793 memcpy(clause->constants, constant_pairs, sizeof(constant_pairs));
1796 bi_instr *last = clause->tuples[max_tuples - 1].add;
1797 clause->next_clause_prefetch = !last || (last->op != BI_OPCODE_JUMP);
1798 clause->block = block;
1801 clause->dependencies |= (1 << 0);
1805 memmove(clause->tuples,
1806 clause->tuples + (max_tuples - clause->tuple_count),
1807 clause->tuple_count * sizeof(clause->tuples[0]));
1813 for (unsigned t = 1; t < clause->tuple_count; ++t)
1814 bi_rewrite_passthrough(clause->tuples[t - 1], clause->tuples[t]);
1816 return clause;
1842 /* Back-to-back bit affects only the last clause of a block,
1857 bi_foreach_clause_in_block(block, clause) {
1858 for (unsigned i = 0; i < clause->tuple_count; ++i) {
1859 bi_foreach_instr_in_tuple(&clause->tuples[i], ins) {
1953 * clause of a shader. v6 requires adding a NOP clause with the depedency. */
1965 /* Fetch the first clause of the shader */
1967 bi_clause *clause = bi_next_clause(ctx, block, NULL);
1969 if (!clause || !(clause->dependencies & ((1 << BIFROST_SLOT_ELDEST_DEPTH) |
1974 * clause */
1984 .block = clause->block,
1990 list_add(&new_clause->link, &clause->block->clauses);