1 #include "pipe/p_context.h"
2 #include "pipe/p_defines.h"
3 #include "pipe/p_state.h"
4 #include "util/u_inlines.h"
5 #include "util/u_debug.h"
7 #include "pipe/p_shader_tokens.h"
8 #include "tgsi/tgsi_parse.h"
9 #include "tgsi/tgsi_util.h"
10 #include "tgsi/tgsi_dump.h"
12 #include "nvfx_context.h"
13 #include "nvfx_shader.h"
14 #include "nvfx_resource.h"
16 #define MAX_CONSTS 128
20 struct nvfx_fragment_program
*fp
;
23 unsigned r_temps_discard
;
24 struct nvfx_reg r_result
[PIPE_MAX_SHADER_OUTPUTS
];
25 struct nvfx_reg
*r_temp
;
38 struct nvfx_reg imm
[MAX_IMM
];
41 unsigned char generic_to_slot
[256]; /* semantic idx for each input semantic */
43 struct util_dynarray if_stack
;
44 //struct util_dynarray loop_stack;
45 struct util_dynarray label_relocs
;
48 static INLINE
struct nvfx_reg
49 temp(struct nvfx_fpc
*fpc
)
51 int idx
= ffs(~fpc
->r_temps
) - 1;
54 NOUVEAU_ERR("out of temps!!\n");
56 return nvfx_reg(NVFXSR_TEMP
, 0);
59 fpc
->r_temps
|= (1 << idx
);
60 fpc
->r_temps_discard
|= (1 << idx
);
61 return nvfx_reg(NVFXSR_TEMP
, idx
);
65 release_temps(struct nvfx_fpc
*fpc
)
67 fpc
->r_temps
&= ~fpc
->r_temps_discard
;
68 fpc
->r_temps_discard
= 0;
71 static INLINE
struct nvfx_reg
72 constant(struct nvfx_fpc
*fpc
, int pipe
, float vals
[4])
76 if (fpc
->nr_consts
== MAX_CONSTS
)
78 idx
= fpc
->nr_consts
++;
80 fpc
->consts
[idx
].pipe
= pipe
;
82 memcpy(fpc
->consts
[idx
].vals
, vals
, 4 * sizeof(float));
83 return nvfx_reg(NVFXSR_CONST
, idx
);
87 grow_insns(struct nvfx_fpc
*fpc
, int size
)
89 struct nvfx_fragment_program
*fp
= fpc
->fp
;
92 fp
->insn
= realloc(fp
->insn
, sizeof(uint32_t) * fp
->insn_len
);
96 emit_src(struct nvfx_fpc
*fpc
, int pos
, struct nvfx_src src
)
98 struct nvfx_fragment_program
*fp
= fpc
->fp
;
99 uint32_t *hw
= &fp
->insn
[fpc
->inst_offset
];
102 switch (src
.reg
.type
) {
104 sr
|= (NVFX_FP_REG_TYPE_INPUT
<< NVFX_FP_REG_TYPE_SHIFT
);
105 hw
[0] |= (src
.reg
.index
<< NVFX_FP_OP_INPUT_SRC_SHIFT
);
108 sr
|= NVFX_FP_REG_SRC_HALF
;
111 sr
|= (NVFX_FP_REG_TYPE_TEMP
<< NVFX_FP_REG_TYPE_SHIFT
);
112 sr
|= (src
.reg
.index
<< NVFX_FP_REG_SRC_SHIFT
);
114 case NVFXSR_RELOCATED
:
115 sr
|= (NVFX_FP_REG_TYPE_INPUT
<< NVFX_FP_REG_TYPE_SHIFT
);
116 //printf("adding relocation at %x for %x\n", fpc->inst_offset, src.index);
117 util_dynarray_append(&fpc
->fp
->slot_relocations
[src
.reg
.index
], unsigned, fpc
->inst_offset
);
120 if (!fpc
->have_const
) {
125 hw
= &fp
->insn
[fpc
->inst_offset
];
126 if (fpc
->consts
[src
.reg
.index
].pipe
>= 0) {
127 struct nvfx_fragment_program_data
*fpd
;
129 fp
->consts
= realloc(fp
->consts
, ++fp
->nr_consts
*
131 fpd
= &fp
->consts
[fp
->nr_consts
- 1];
132 fpd
->offset
= fpc
->inst_offset
+ 4;
133 fpd
->index
= fpc
->consts
[src
.reg
.index
].pipe
;
134 memset(&fp
->insn
[fpd
->offset
], 0, sizeof(uint32_t) * 4);
136 memcpy(&fp
->insn
[fpc
->inst_offset
+ 4],
137 fpc
->consts
[src
.reg
.index
].vals
,
138 sizeof(uint32_t) * 4);
141 sr
|= (NVFX_FP_REG_TYPE_CONST
<< NVFX_FP_REG_TYPE_SHIFT
);
144 sr
|= (NVFX_FP_REG_TYPE_INPUT
<< NVFX_FP_REG_TYPE_SHIFT
);
151 sr
|= NVFX_FP_REG_NEGATE
;
154 hw
[1] |= (1 << (29 + pos
));
156 sr
|= ((src
.swz
[0] << NVFX_FP_REG_SWZ_X_SHIFT
) |
157 (src
.swz
[1] << NVFX_FP_REG_SWZ_Y_SHIFT
) |
158 (src
.swz
[2] << NVFX_FP_REG_SWZ_Z_SHIFT
) |
159 (src
.swz
[3] << NVFX_FP_REG_SWZ_W_SHIFT
));
165 emit_dst(struct nvfx_fpc
*fpc
, struct nvfx_reg dst
)
167 struct nvfx_fragment_program
*fp
= fpc
->fp
;
168 uint32_t *hw
= &fp
->insn
[fpc
->inst_offset
];
172 if (fpc
->num_regs
< (dst
.index
+ 1))
173 fpc
->num_regs
= dst
.index
+ 1;
176 if (dst
.index
== 1) {
177 fp
->fp_control
|= 0xe;
179 hw
[0] |= NVFX_FP_OP_OUT_REG_HALF
;
189 hw
[0] |= (dst
.index
<< NVFX_FP_OP_OUT_REG_SHIFT
);
193 nvfx_fp_emit(struct nvfx_fpc
*fpc
, struct nvfx_insn insn
)
195 struct nvfx_fragment_program
*fp
= fpc
->fp
;
198 fpc
->inst_offset
= fp
->insn_len
;
201 hw
= &fp
->insn
[fpc
->inst_offset
];
202 memset(hw
, 0, sizeof(uint32_t) * 4);
204 if (insn
.op
== NVFX_FP_OP_OPCODE_KIL
)
205 fp
->fp_control
|= NV34TCL_FP_CONTROL_USES_KIL
;
206 hw
[0] |= (insn
.op
<< NVFX_FP_OP_OPCODE_SHIFT
);
207 hw
[0] |= (insn
.mask
<< NVFX_FP_OP_OUTMASK_SHIFT
);
208 hw
[2] |= (insn
.scale
<< NVFX_FP_OP_DST_SCALE_SHIFT
);
211 hw
[0] |= NVFX_FP_OP_OUT_SAT
;
214 hw
[0] |= NVFX_FP_OP_COND_WRITE_ENABLE
;
215 hw
[1] |= (insn
.cc_test
<< NVFX_FP_OP_COND_SHIFT
);
216 hw
[1] |= ((insn
.cc_swz
[0] << NVFX_FP_OP_COND_SWZ_X_SHIFT
) |
217 (insn
.cc_swz
[1] << NVFX_FP_OP_COND_SWZ_Y_SHIFT
) |
218 (insn
.cc_swz
[2] << NVFX_FP_OP_COND_SWZ_Z_SHIFT
) |
219 (insn
.cc_swz
[3] << NVFX_FP_OP_COND_SWZ_W_SHIFT
));
223 hw
[0] |= (insn
.unit
<< NVFX_FP_OP_TEX_UNIT_SHIFT
);
224 fp
->samplers
|= (1 << insn
.unit
);
227 emit_dst(fpc
, insn
.dst
);
228 emit_src(fpc
, 0, insn
.src
[0]);
229 emit_src(fpc
, 1, insn
.src
[1]);
230 emit_src(fpc
, 2, insn
.src
[2]);
233 #define arith(s,o,d,m,s0,s1,s2) \
234 nvfx_insn((s), NVFX_FP_OP_OPCODE_##o, -1, \
235 (d), (m), (s0), (s1), (s2))
237 #define tex(s,o,u,d,m,s0,s1,s2) \
238 nvfx_insn((s), NVFX_FP_OP_OPCODE_##o, (u), \
239 (d), (m), (s0), none, none)
241 /* IF src.x != 0, as TGSI specifies */
243 nv40_fp_if(struct nvfx_fpc
*fpc
, struct nvfx_src src
)
245 const struct nvfx_src none
= nvfx_src(nvfx_reg(NVFXSR_NONE
, 0));
246 struct nvfx_insn insn
= arith(0, MOV
, none
.reg
, NVFX_FP_MASK_X
, src
, none
, none
);
248 nvfx_fp_emit(fpc
, insn
);
250 fpc
->inst_offset
= fpc
->fp
->insn_len
;
252 uint32_t *hw
= &fpc
->fp
->insn
[fpc
->inst_offset
];
253 /* I really wonder why fp16 precision is used. Presumably the hardware ignores it? */
254 hw
[0] = (NV40_FP_OP_BRA_OPCODE_IF
<< NVFX_FP_OP_OPCODE_SHIFT
) |
255 NV40_FP_OP_OUT_NONE
|
256 (NVFX_FP_PRECISION_FP16
<< NVFX_FP_OP_PRECISION_SHIFT
);
257 /* Use .xxxx swizzle so that we check only src[0].x*/
258 hw
[1] = (0 << NVFX_FP_OP_COND_SWZ_X_SHIFT
) |
259 (0 << NVFX_FP_OP_COND_SWZ_Y_SHIFT
) |
260 (0 << NVFX_FP_OP_COND_SWZ_Z_SHIFT
) |
261 (0 << NVFX_FP_OP_COND_SWZ_W_SHIFT
) |
262 (NVFX_FP_OP_COND_NE
<< NVFX_FP_OP_COND_SHIFT
);
263 hw
[2] = 0; /* | NV40_FP_OP_OPCODE_IS_BRANCH | else_offset */
264 hw
[3] = 0; /* | endif_offset */
265 util_dynarray_append(&fpc
->if_stack
, unsigned, fpc
->inst_offset
);
268 /* IF src.x != 0, as TGSI specifies */
270 nv40_fp_cal(struct nvfx_fpc
*fpc
, unsigned target
)
272 struct nvfx_label_relocation reloc
;
273 fpc
->inst_offset
= fpc
->fp
->insn_len
;
275 uint32_t *hw
= &fpc
->fp
->insn
[fpc
->inst_offset
];
276 /* I really wonder why fp16 precision is used. Presumably the hardware ignores it? */
277 hw
[0] = (NV40_FP_OP_BRA_OPCODE_CAL
<< NVFX_FP_OP_OPCODE_SHIFT
);
278 /* Use .xxxx swizzle so that we check only src[0].x*/
279 hw
[1] = (NVFX_SWZ_IDENTITY
<< NVFX_FP_OP_COND_SWZ_ALL_SHIFT
) |
280 (NVFX_FP_OP_COND_TR
<< NVFX_FP_OP_COND_SHIFT
);
281 hw
[2] = NV40_FP_OP_OPCODE_IS_BRANCH
; /* | call_offset */
283 reloc
.target
= target
;
284 reloc
.location
= fpc
->inst_offset
+ 2;
285 util_dynarray_append(&fpc
->label_relocs
, struct nvfx_label_relocation
, reloc
);
289 nv40_fp_ret(struct nvfx_fpc
*fpc
)
291 fpc
->inst_offset
= fpc
->fp
->insn_len
;
293 uint32_t *hw
= &fpc
->fp
->insn
[fpc
->inst_offset
];
294 /* I really wonder why fp16 precision is used. Presumably the hardware ignores it? */
295 hw
[0] = (NV40_FP_OP_BRA_OPCODE_RET
<< NVFX_FP_OP_OPCODE_SHIFT
);
296 /* Use .xxxx swizzle so that we check only src[0].x*/
297 hw
[1] = (NVFX_SWZ_IDENTITY
<< NVFX_FP_OP_COND_SWZ_ALL_SHIFT
) |
298 (NVFX_FP_OP_COND_TR
<< NVFX_FP_OP_COND_SHIFT
);
299 hw
[2] = NV40_FP_OP_OPCODE_IS_BRANCH
; /* | call_offset */
304 nv40_fp_rep(struct nvfx_fpc
*fpc
, unsigned count
, unsigned target
)
306 struct nvfx_label_relocation reloc
;
307 fpc
->inst_offset
= fpc
->fp
->insn_len
;
309 uint32_t *hw
= &fpc
->fp
->insn
[fpc
->inst_offset
];
310 /* I really wonder why fp16 precision is used. Presumably the hardware ignores it? */
311 hw
[0] = (NV40_FP_OP_BRA_OPCODE_REP
<< NVFX_FP_OP_OPCODE_SHIFT
) |
312 NV40_FP_OP_OUT_NONE
|
313 (NVFX_FP_PRECISION_FP16
<< NVFX_FP_OP_PRECISION_SHIFT
);
314 /* Use .xxxx swizzle so that we check only src[0].x*/
315 hw
[1] = (NVFX_SWZ_IDENTITY
<< NVFX_FP_OP_COND_SWZ_ALL_SHIFT
) |
316 (NVFX_FP_OP_COND_TR
<< NVFX_FP_OP_COND_SHIFT
);
317 hw
[2] = NV40_FP_OP_OPCODE_IS_BRANCH
|
318 (count
<< NV40_FP_OP_REP_COUNT1_SHIFT
) |
319 (count
<< NV40_FP_OP_REP_COUNT2_SHIFT
) |
320 (count
<< NV40_FP_OP_REP_COUNT3_SHIFT
);
321 hw
[3] = 0; /* | end_offset */
322 reloc
.target
= target
;
323 reloc
.location
= fpc
->inst_offset
+ 3;
324 util_dynarray_append(&fpc
->label_relocs
, struct nvfx_label_relocation
, reloc
);
325 //util_dynarray_append(&fpc->loop_stack, unsigned, target);
328 /* warning: this only works forward, and probably only if not inside any IF */
330 nv40_fp_bra(struct nvfx_fpc
*fpc
, unsigned target
)
332 struct nvfx_label_relocation reloc
;
333 fpc
->inst_offset
= fpc
->fp
->insn_len
;
335 uint32_t *hw
= &fpc
->fp
->insn
[fpc
->inst_offset
];
336 /* I really wonder why fp16 precision is used. Presumably the hardware ignores it? */
337 hw
[0] = (NV40_FP_OP_BRA_OPCODE_IF
<< NVFX_FP_OP_OPCODE_SHIFT
) |
338 NV40_FP_OP_OUT_NONE
|
339 (NVFX_FP_PRECISION_FP16
<< NVFX_FP_OP_PRECISION_SHIFT
);
340 /* Use .xxxx swizzle so that we check only src[0].x*/
341 hw
[1] = (NVFX_SWZ_IDENTITY
<< NVFX_FP_OP_COND_SWZ_X_SHIFT
) |
342 (NVFX_FP_OP_COND_FL
<< NVFX_FP_OP_COND_SHIFT
);
343 hw
[2] = NV40_FP_OP_OPCODE_IS_BRANCH
; /* | else_offset */
344 hw
[3] = 0; /* | endif_offset */
345 reloc
.target
= target
;
346 reloc
.location
= fpc
->inst_offset
+ 2;
347 util_dynarray_append(&fpc
->label_relocs
, struct nvfx_label_relocation
, reloc
);
348 reloc
.target
= target
;
349 reloc
.location
= fpc
->inst_offset
+ 3;
350 util_dynarray_append(&fpc
->label_relocs
, struct nvfx_label_relocation
, reloc
);
354 nv40_fp_brk(struct nvfx_fpc
*fpc
)
356 fpc
->inst_offset
= fpc
->fp
->insn_len
;
358 uint32_t *hw
= &fpc
->fp
->insn
[fpc
->inst_offset
];
359 /* I really wonder why fp16 precision is used. Presumably the hardware ignores it? */
360 hw
[0] = (NV40_FP_OP_BRA_OPCODE_BRK
<< NVFX_FP_OP_OPCODE_SHIFT
) |
362 /* Use .xxxx swizzle so that we check only src[0].x*/
363 hw
[1] = (NVFX_SWZ_IDENTITY
<< NVFX_FP_OP_COND_SWZ_X_SHIFT
) |
364 (NVFX_FP_OP_COND_TR
<< NVFX_FP_OP_COND_SHIFT
);
365 hw
[2] = NV40_FP_OP_OPCODE_IS_BRANCH
;
369 static INLINE
struct nvfx_src
370 tgsi_src(struct nvfx_fpc
*fpc
, const struct tgsi_full_src_register
*fsrc
)
374 switch (fsrc
->Register
.File
) {
375 case TGSI_FILE_INPUT
:
376 if(fpc
->fp
->info
.input_semantic_name
[fsrc
->Register
.Index
] == TGSI_SEMANTIC_POSITION
) {
377 assert(fpc
->fp
->info
.input_semantic_index
[fsrc
->Register
.Index
] == 0);
378 src
.reg
= nvfx_reg(NVFXSR_INPUT
, NVFX_FP_OP_INPUT_SRC_POSITION
);
379 } else if(fpc
->fp
->info
.input_semantic_name
[fsrc
->Register
.Index
] == TGSI_SEMANTIC_COLOR
) {
380 if(fpc
->fp
->info
.input_semantic_index
[fsrc
->Register
.Index
] == 0)
381 src
.reg
= nvfx_reg(NVFXSR_INPUT
, NVFX_FP_OP_INPUT_SRC_COL0
);
382 else if(fpc
->fp
->info
.input_semantic_index
[fsrc
->Register
.Index
] == 1)
383 src
.reg
= nvfx_reg(NVFXSR_INPUT
, NVFX_FP_OP_INPUT_SRC_COL1
);
386 } else if(fpc
->fp
->info
.input_semantic_name
[fsrc
->Register
.Index
] == TGSI_SEMANTIC_FOG
) {
387 assert(fpc
->fp
->info
.input_semantic_index
[fsrc
->Register
.Index
] == 0);
388 src
.reg
= nvfx_reg(NVFXSR_INPUT
, NVFX_FP_OP_INPUT_SRC_FOGC
);
389 } else if(fpc
->fp
->info
.input_semantic_name
[fsrc
->Register
.Index
] == TGSI_SEMANTIC_FACE
) {
390 /* TODO: check this has the correct values */
391 /* XXX: what do we do for nv30 here (assuming it lacks facing)?! */
392 assert(fpc
->fp
->info
.input_semantic_index
[fsrc
->Register
.Index
] == 0);
393 src
.reg
= nvfx_reg(NVFXSR_INPUT
, NV40_FP_OP_INPUT_SRC_FACING
);
395 assert(fpc
->fp
->info
.input_semantic_name
[fsrc
->Register
.Index
] == TGSI_SEMANTIC_GENERIC
);
396 src
.reg
= nvfx_reg(NVFXSR_RELOCATED
, fpc
->generic_to_slot
[fpc
->fp
->info
.input_semantic_index
[fsrc
->Register
.Index
]]);
399 case TGSI_FILE_CONSTANT
:
400 src
.reg
= constant(fpc
, fsrc
->Register
.Index
, NULL
);
402 case TGSI_FILE_IMMEDIATE
:
403 assert(fsrc
->Register
.Index
< fpc
->nr_imm
);
404 src
.reg
= fpc
->imm
[fsrc
->Register
.Index
];
406 case TGSI_FILE_TEMPORARY
:
407 src
.reg
= fpc
->r_temp
[fsrc
->Register
.Index
];
409 /* NV40 fragprog result regs are just temps, so this is simple */
410 case TGSI_FILE_OUTPUT
:
411 src
.reg
= fpc
->r_result
[fsrc
->Register
.Index
];
414 NOUVEAU_ERR("bad src file\n");
418 src
.abs
= fsrc
->Register
.Absolute
;
419 src
.negate
= fsrc
->Register
.Negate
;
420 src
.swz
[0] = fsrc
->Register
.SwizzleX
;
421 src
.swz
[1] = fsrc
->Register
.SwizzleY
;
422 src
.swz
[2] = fsrc
->Register
.SwizzleZ
;
423 src
.swz
[3] = fsrc
->Register
.SwizzleW
;
427 static INLINE
struct nvfx_reg
428 tgsi_dst(struct nvfx_fpc
*fpc
, const struct tgsi_full_dst_register
*fdst
) {
429 switch (fdst
->Register
.File
) {
430 case TGSI_FILE_OUTPUT
:
431 return fpc
->r_result
[fdst
->Register
.Index
];
432 case TGSI_FILE_TEMPORARY
:
433 return fpc
->r_temp
[fdst
->Register
.Index
];
435 return nvfx_reg(NVFXSR_NONE
, 0);
437 NOUVEAU_ERR("bad dst file %d\n", fdst
->Register
.File
);
438 return nvfx_reg(NVFXSR_NONE
, 0);
447 if (tgsi
& TGSI_WRITEMASK_X
) mask
|= NVFX_FP_MASK_X
;
448 if (tgsi
& TGSI_WRITEMASK_Y
) mask
|= NVFX_FP_MASK_Y
;
449 if (tgsi
& TGSI_WRITEMASK_Z
) mask
|= NVFX_FP_MASK_Z
;
450 if (tgsi
& TGSI_WRITEMASK_W
) mask
|= NVFX_FP_MASK_W
;
455 nvfx_fragprog_parse_instruction(struct nvfx_context
* nvfx
, struct nvfx_fpc
*fpc
,
456 const struct tgsi_full_instruction
*finst
)
458 const struct nvfx_src none
= nvfx_src(nvfx_reg(NVFXSR_NONE
, 0));
459 struct nvfx_insn insn
;
460 struct nvfx_src src
[3], tmp
, tmp2
;
462 int mask
, sat
, unit
= 0;
463 int ai
= -1, ci
= -1, ii
= -1;
466 if (finst
->Instruction
.Opcode
== TGSI_OPCODE_END
)
469 for (i
= 0; i
< finst
->Instruction
.NumSrcRegs
; i
++) {
470 const struct tgsi_full_src_register
*fsrc
;
472 fsrc
= &finst
->Src
[i
];
473 if (fsrc
->Register
.File
== TGSI_FILE_TEMPORARY
) {
474 src
[i
] = tgsi_src(fpc
, fsrc
);
478 for (i
= 0; i
< finst
->Instruction
.NumSrcRegs
; i
++) {
479 const struct tgsi_full_src_register
*fsrc
;
481 fsrc
= &finst
->Src
[i
];
483 switch (fsrc
->Register
.File
) {
484 case TGSI_FILE_INPUT
:
485 if (ai
== -1 || ai
== fsrc
->Register
.Index
) {
486 ai
= fsrc
->Register
.Index
;
487 src
[i
] = tgsi_src(fpc
, fsrc
);
489 src
[i
] = nvfx_src(temp(fpc
));
490 nvfx_fp_emit(fpc
, arith(0, MOV
, src
[i
].reg
, NVFX_FP_MASK_ALL
, tgsi_src(fpc
, fsrc
), none
, none
));
493 case TGSI_FILE_CONSTANT
:
494 if ((ci
== -1 && ii
== -1) ||
495 ci
== fsrc
->Register
.Index
) {
496 ci
= fsrc
->Register
.Index
;
497 src
[i
] = tgsi_src(fpc
, fsrc
);
499 src
[i
] = nvfx_src(temp(fpc
));
500 nvfx_fp_emit(fpc
, arith(0, MOV
, src
[i
].reg
, NVFX_FP_MASK_ALL
, tgsi_src(fpc
, fsrc
), none
, none
));
503 case TGSI_FILE_IMMEDIATE
:
504 if ((ci
== -1 && ii
== -1) ||
505 ii
== fsrc
->Register
.Index
) {
506 ii
= fsrc
->Register
.Index
;
507 src
[i
] = tgsi_src(fpc
, fsrc
);
509 src
[i
] = nvfx_src(temp(fpc
));
510 nvfx_fp_emit(fpc
, arith(0, MOV
, src
[i
].reg
, NVFX_FP_MASK_ALL
, tgsi_src(fpc
, fsrc
), none
, none
));
513 case TGSI_FILE_TEMPORARY
:
516 case TGSI_FILE_SAMPLER
:
517 unit
= fsrc
->Register
.Index
;
519 case TGSI_FILE_OUTPUT
:
522 NOUVEAU_ERR("bad src file\n");
527 dst
= tgsi_dst(fpc
, &finst
->Dst
[0]);
528 mask
= tgsi_mask(finst
->Dst
[0].Register
.WriteMask
);
529 sat
= (finst
->Instruction
.Saturate
== TGSI_SAT_ZERO_ONE
);
531 switch (finst
->Instruction
.Opcode
) {
532 case TGSI_OPCODE_ABS
:
533 nvfx_fp_emit(fpc
, arith(sat
, MOV
, dst
, mask
, abs(src
[0]), none
, none
));
535 case TGSI_OPCODE_ADD
:
536 nvfx_fp_emit(fpc
, arith(sat
, ADD
, dst
, mask
, src
[0], src
[1], none
));
538 case TGSI_OPCODE_CMP
:
539 insn
= arith(0, MOV
, none
.reg
, mask
, src
[0], none
, none
);
541 nvfx_fp_emit(fpc
, insn
);
543 insn
= arith(sat
, MOV
, dst
, mask
, src
[2], none
, none
);
544 insn
.cc_test
= NVFX_COND_GE
;
545 nvfx_fp_emit(fpc
, insn
);
547 insn
= arith(sat
, MOV
, dst
, mask
, src
[1], none
, none
);
548 insn
.cc_test
= NVFX_COND_LT
;
549 nvfx_fp_emit(fpc
, insn
);
551 case TGSI_OPCODE_COS
:
552 nvfx_fp_emit(fpc
, arith(sat
, COS
, dst
, mask
, src
[0], none
, none
));
554 case TGSI_OPCODE_DDX
:
555 if (mask
& (NVFX_FP_MASK_Z
| NVFX_FP_MASK_W
)) {
556 tmp
= nvfx_src(temp(fpc
));
557 nvfx_fp_emit(fpc
, arith(sat
, DDX
, tmp
.reg
, NVFX_FP_MASK_X
| NVFX_FP_MASK_Y
, swz(src
[0], Z
, W
, Z
, W
), none
, none
));
558 nvfx_fp_emit(fpc
, arith(0, MOV
, tmp
.reg
, NVFX_FP_MASK_Z
| NVFX_FP_MASK_W
, swz(tmp
, X
, Y
, X
, Y
), none
, none
));
559 nvfx_fp_emit(fpc
, arith(sat
, DDX
, tmp
.reg
, NVFX_FP_MASK_X
| NVFX_FP_MASK_Y
, src
[0], none
, none
));
560 nvfx_fp_emit(fpc
, arith(0, MOV
, dst
, mask
, tmp
, none
, none
));
562 nvfx_fp_emit(fpc
, arith(sat
, DDX
, dst
, mask
, src
[0], none
, none
));
565 case TGSI_OPCODE_DDY
:
566 if (mask
& (NVFX_FP_MASK_Z
| NVFX_FP_MASK_W
)) {
567 tmp
= nvfx_src(temp(fpc
));
568 nvfx_fp_emit(fpc
, arith(sat
, DDY
, tmp
.reg
, NVFX_FP_MASK_X
| NVFX_FP_MASK_Y
, swz(src
[0], Z
, W
, Z
, W
), none
, none
));
569 nvfx_fp_emit(fpc
, arith(0, MOV
, tmp
.reg
, NVFX_FP_MASK_Z
| NVFX_FP_MASK_W
, swz(tmp
, X
, Y
, X
, Y
), none
, none
));
570 nvfx_fp_emit(fpc
, arith(sat
, DDY
, tmp
.reg
, NVFX_FP_MASK_X
| NVFX_FP_MASK_Y
, src
[0], none
, none
));
571 nvfx_fp_emit(fpc
, arith(0, MOV
, dst
, mask
, tmp
, none
, none
));
573 nvfx_fp_emit(fpc
, arith(sat
, DDY
, dst
, mask
, src
[0], none
, none
));
576 case TGSI_OPCODE_DP2
:
577 tmp
= nvfx_src(temp(fpc
));
578 nvfx_fp_emit(fpc
, arith(0, MUL
, tmp
.reg
, NVFX_FP_MASK_X
| NVFX_FP_MASK_Y
, src
[0], src
[1], none
));
579 nvfx_fp_emit(fpc
, arith(0, ADD
, dst
, mask
, swz(tmp
, X
, X
, X
, X
), swz(tmp
, Y
, Y
, Y
, Y
), none
));
581 case TGSI_OPCODE_DP3
:
582 nvfx_fp_emit(fpc
, arith(sat
, DP3
, dst
, mask
, src
[0], src
[1], none
));
584 case TGSI_OPCODE_DP4
:
585 nvfx_fp_emit(fpc
, arith(sat
, DP4
, dst
, mask
, src
[0], src
[1], none
));
587 case TGSI_OPCODE_DPH
:
588 tmp
= nvfx_src(temp(fpc
));
589 nvfx_fp_emit(fpc
, arith(0, DP3
, tmp
.reg
, NVFX_FP_MASK_X
, src
[0], src
[1], none
));
590 nvfx_fp_emit(fpc
, arith(sat
, ADD
, dst
, mask
, swz(tmp
, X
, X
, X
, X
), swz(src
[1], W
, W
, W
, W
), none
));
592 case TGSI_OPCODE_DST
:
593 nvfx_fp_emit(fpc
, arith(sat
, DST
, dst
, mask
, src
[0], src
[1], none
));
595 case TGSI_OPCODE_EX2
:
596 nvfx_fp_emit(fpc
, arith(sat
, EX2
, dst
, mask
, src
[0], none
, none
));
598 case TGSI_OPCODE_FLR
:
599 nvfx_fp_emit(fpc
, arith(sat
, FLR
, dst
, mask
, src
[0], none
, none
));
601 case TGSI_OPCODE_FRC
:
602 nvfx_fp_emit(fpc
, arith(sat
, FRC
, dst
, mask
, src
[0], none
, none
));
604 case TGSI_OPCODE_KILP
:
605 nvfx_fp_emit(fpc
, arith(0, KIL
, none
.reg
, 0, none
, none
, none
));
607 case TGSI_OPCODE_KIL
:
608 insn
= arith(0, MOV
, none
.reg
, NVFX_FP_MASK_ALL
, src
[0], none
, none
);
610 nvfx_fp_emit(fpc
, insn
);
612 insn
= arith(0, KIL
, none
.reg
, 0, none
, none
, none
);
613 insn
.cc_test
= NVFX_COND_LT
;
614 nvfx_fp_emit(fpc
, insn
);
616 case TGSI_OPCODE_LG2
:
617 nvfx_fp_emit(fpc
, arith(sat
, LG2
, dst
, mask
, src
[0], none
, none
));
619 // case TGSI_OPCODE_LIT:
620 case TGSI_OPCODE_LRP
:
622 nvfx_fp_emit(fpc
, arith(sat
, LRP_NV30
, dst
, mask
, src
[0], src
[1], src
[2]));
624 tmp
= nvfx_src(temp(fpc
));
625 nvfx_fp_emit(fpc
, arith(0, MAD
, tmp
.reg
, mask
, neg(src
[0]), src
[2], src
[2]));
626 nvfx_fp_emit(fpc
, arith(sat
, MAD
, dst
, mask
, src
[0], src
[1], tmp
));
629 case TGSI_OPCODE_MAD
:
630 nvfx_fp_emit(fpc
, arith(sat
, MAD
, dst
, mask
, src
[0], src
[1], src
[2]));
632 case TGSI_OPCODE_MAX
:
633 nvfx_fp_emit(fpc
, arith(sat
, MAX
, dst
, mask
, src
[0], src
[1], none
));
635 case TGSI_OPCODE_MIN
:
636 nvfx_fp_emit(fpc
, arith(sat
, MIN
, dst
, mask
, src
[0], src
[1], none
));
638 case TGSI_OPCODE_MOV
:
639 nvfx_fp_emit(fpc
, arith(sat
, MOV
, dst
, mask
, src
[0], none
, none
));
641 case TGSI_OPCODE_MUL
:
642 nvfx_fp_emit(fpc
, arith(sat
, MUL
, dst
, mask
, src
[0], src
[1], none
));
644 case TGSI_OPCODE_NOP
:
646 case TGSI_OPCODE_POW
:
648 nvfx_fp_emit(fpc
, arith(sat
, POW_NV30
, dst
, mask
, src
[0], src
[1], none
));
650 tmp
= nvfx_src(temp(fpc
));
651 nvfx_fp_emit(fpc
, arith(0, LG2
, tmp
.reg
, NVFX_FP_MASK_X
, swz(src
[0], X
, X
, X
, X
), none
, none
));
652 nvfx_fp_emit(fpc
, arith(0, MUL
, tmp
.reg
, NVFX_FP_MASK_X
, swz(tmp
, X
, X
, X
, X
), swz(src
[1], X
, X
, X
, X
), none
));
653 nvfx_fp_emit(fpc
, arith(sat
, EX2
, dst
, mask
, swz(tmp
, X
, X
, X
, X
), none
, none
));
656 case TGSI_OPCODE_RCP
:
657 nvfx_fp_emit(fpc
, arith(sat
, RCP
, dst
, mask
, src
[0], none
, none
));
659 case TGSI_OPCODE_RFL
:
661 nvfx_fp_emit(fpc
, arith(0, RFL_NV30
, dst
, mask
, src
[0], src
[1], none
));
663 tmp
= nvfx_src(temp(fpc
));
664 nvfx_fp_emit(fpc
, arith(0, DP3
, tmp
.reg
, NVFX_FP_MASK_X
, src
[0], src
[0], none
));
665 nvfx_fp_emit(fpc
, arith(0, DP3
, tmp
.reg
, NVFX_FP_MASK_Y
, src
[0], src
[1], none
));
666 insn
= arith(0, DIV
, tmp
.reg
, NVFX_FP_MASK_Z
, swz(tmp
, Y
, Y
, Y
, Y
), swz(tmp
, X
, X
, X
, X
), none
);
667 insn
.scale
= NVFX_FP_OP_DST_SCALE_2X
;
668 nvfx_fp_emit(fpc
, insn
);
669 nvfx_fp_emit(fpc
, arith(sat
, MAD
, dst
, mask
, swz(tmp
, Z
, Z
, Z
, Z
), src
[0], neg(src
[1])));
672 case TGSI_OPCODE_RSQ
:
674 nvfx_fp_emit(fpc
, arith(sat
, RSQ_NV30
, dst
, mask
, abs(swz(src
[0], X
, X
, X
, X
)), none
, none
));
676 tmp
= nvfx_src(temp(fpc
));
677 insn
= arith(0, LG2
, tmp
.reg
, NVFX_FP_MASK_X
, abs(swz(src
[0], X
, X
, X
, X
)), none
, none
);
678 insn
.scale
= NVFX_FP_OP_DST_SCALE_INV_2X
;
679 nvfx_fp_emit(fpc
, insn
);
680 nvfx_fp_emit(fpc
, arith(sat
, EX2
, dst
, mask
, neg(swz(tmp
, X
, X
, X
, X
)), none
, none
));
683 case TGSI_OPCODE_SCS
:
684 /* avoid overwriting the source */
685 if(src
[0].swz
[NVFX_SWZ_X
] != NVFX_SWZ_X
)
687 if (mask
& NVFX_FP_MASK_X
)
688 nvfx_fp_emit(fpc
, arith(sat
, COS
, dst
, NVFX_FP_MASK_X
, swz(src
[0], X
, X
, X
, X
), none
, none
));
689 if (mask
& NVFX_FP_MASK_Y
)
690 nvfx_fp_emit(fpc
, arith(sat
, SIN
, dst
, NVFX_FP_MASK_Y
, swz(src
[0], X
, X
, X
, X
), none
, none
));
694 if (mask
& NVFX_FP_MASK_Y
)
695 nvfx_fp_emit(fpc
, arith(sat
, SIN
, dst
, NVFX_FP_MASK_Y
, swz(src
[0], X
, X
, X
, X
), none
, none
));
696 if (mask
& NVFX_FP_MASK_X
)
697 nvfx_fp_emit(fpc
, arith(sat
, COS
, dst
, NVFX_FP_MASK_X
, swz(src
[0], X
, X
, X
, X
), none
, none
));
700 case TGSI_OPCODE_SEQ
:
701 nvfx_fp_emit(fpc
, arith(sat
, SEQ
, dst
, mask
, src
[0], src
[1], none
));
703 case TGSI_OPCODE_SFL
:
704 nvfx_fp_emit(fpc
, arith(sat
, SFL
, dst
, mask
, src
[0], src
[1], none
));
706 case TGSI_OPCODE_SGE
:
707 nvfx_fp_emit(fpc
, arith(sat
, SGE
, dst
, mask
, src
[0], src
[1], none
));
709 case TGSI_OPCODE_SGT
:
710 nvfx_fp_emit(fpc
, arith(sat
, SGT
, dst
, mask
, src
[0], src
[1], none
));
712 case TGSI_OPCODE_SIN
:
713 nvfx_fp_emit(fpc
, arith(sat
, SIN
, dst
, mask
, src
[0], none
, none
));
715 case TGSI_OPCODE_SLE
:
716 nvfx_fp_emit(fpc
, arith(sat
, SLE
, dst
, mask
, src
[0], src
[1], none
));
718 case TGSI_OPCODE_SLT
:
719 nvfx_fp_emit(fpc
, arith(sat
, SLT
, dst
, mask
, src
[0], src
[1], none
));
721 case TGSI_OPCODE_SNE
:
722 nvfx_fp_emit(fpc
, arith(sat
, SNE
, dst
, mask
, src
[0], src
[1], none
));
724 case TGSI_OPCODE_SSG
:
725 tmp
= nvfx_src(temp(fpc
));
726 tmp2
= nvfx_src(temp(fpc
));
727 nvfx_fp_emit(fpc
, arith(0, SGT
, tmp
.reg
, mask
, src
[0], nvfx_src(nvfx_reg(NVFXSR_CONST
, 0)), none
));
728 nvfx_fp_emit(fpc
, arith(0, SLT
, tmp
.reg
, mask
, src
[0], nvfx_src(nvfx_reg(NVFXSR_CONST
, 0)), none
));
729 nvfx_fp_emit(fpc
, arith(sat
, ADD
, dst
, mask
, tmp
, neg(tmp2
), none
));
731 case TGSI_OPCODE_STR
:
732 nvfx_fp_emit(fpc
, arith(sat
, STR
, dst
, mask
, src
[0], src
[1], none
));
734 case TGSI_OPCODE_SUB
:
735 nvfx_fp_emit(fpc
, arith(sat
, ADD
, dst
, mask
, src
[0], neg(src
[1]), none
));
737 case TGSI_OPCODE_TEX
:
738 nvfx_fp_emit(fpc
, tex(sat
, TEX
, unit
, dst
, mask
, src
[0], none
, none
));
740 case TGSI_OPCODE_TRUNC
:
741 tmp
= nvfx_src(temp(fpc
));
742 insn
= arith(0, MOV
, none
.reg
, mask
, src
[0], none
, none
);
744 nvfx_fp_emit(fpc
, insn
);
746 nvfx_fp_emit(fpc
, arith(0, FLR
, tmp
.reg
, mask
, abs(src
[0]), none
, none
));
747 nvfx_fp_emit(fpc
, arith(sat
, MOV
, dst
, mask
, tmp
, none
, none
));
749 insn
= arith(sat
, MOV
, dst
, mask
, neg(tmp
), none
, none
);
750 insn
.cc_test
= NVFX_COND_LT
;
751 nvfx_fp_emit(fpc
, insn
);
753 case TGSI_OPCODE_TXB
:
754 nvfx_fp_emit(fpc
, tex(sat
, TXB
, unit
, dst
, mask
, src
[0], none
, none
));
756 case TGSI_OPCODE_TXL
:
758 nvfx_fp_emit(fpc
, tex(sat
, TXL_NV40
, unit
, dst
, mask
, src
[0], none
, none
));
759 else /* unsupported on nv30, use TEX and hope they like it */
760 nvfx_fp_emit(fpc
, tex(sat
, TEX
, unit
, dst
, mask
, src
[0], none
, none
));
762 case TGSI_OPCODE_TXP
:
763 nvfx_fp_emit(fpc
, tex(sat
, TXP
, unit
, dst
, mask
, src
[0], none
, none
));
765 case TGSI_OPCODE_XPD
:
766 tmp
= nvfx_src(temp(fpc
));
767 nvfx_fp_emit(fpc
, arith(0, MUL
, tmp
.reg
, mask
, swz(src
[0], Z
, X
, Y
, Y
), swz(src
[1], Y
, Z
, X
, X
), none
));
768 nvfx_fp_emit(fpc
, arith(sat
, MAD
, dst
, (mask
& ~NVFX_FP_MASK_W
), swz(src
[0], Y
, Z
, X
, X
), swz(src
[1], Z
, X
, Y
, Y
), neg(tmp
)));
772 // MOVRC0 R31 (TR0.xyzw), R<src>:
773 // IF (NE.xxxx) ELSE <else> END <end>
776 nv40_fp_if(fpc
, src
[0]);
779 case TGSI_OPCODE_ELSE
:
783 assert(util_dynarray_contains(&fpc
->if_stack
, unsigned));
784 uint32_t *hw
= &fpc
->fp
->insn
[util_dynarray_top(&fpc
->if_stack
, unsigned)];
785 hw
[2] = NV40_FP_OP_OPCODE_IS_BRANCH
| fpc
->fp
->insn_len
;
789 case TGSI_OPCODE_ENDIF
:
793 assert(util_dynarray_contains(&fpc
->if_stack
, unsigned));
794 uint32_t *hw
= &fpc
->fp
->insn
[util_dynarray_pop(&fpc
->if_stack
, unsigned)];
796 hw
[2] = NV40_FP_OP_OPCODE_IS_BRANCH
| fpc
->fp
->insn_len
;
797 hw
[3] = fpc
->fp
->insn_len
;
801 case TGSI_OPCODE_BRA
:
802 /* This can in limited cases be implemented with an IF with the else and endif labels pointing to the target */
803 /* no state tracker uses this, so don't implement this for now */
805 nv40_fp_bra(fpc
, finst
->Label
.Label
);
808 case TGSI_OPCODE_BGNSUB
:
809 case TGSI_OPCODE_ENDSUB
:
810 /* nothing to do here */
813 case TGSI_OPCODE_CAL
:
816 nv40_fp_cal(fpc
, finst
->Label
.Label
);
819 case TGSI_OPCODE_RET
:
825 case TGSI_OPCODE_BGNLOOP
:
828 /* TODO: we should support using two nested REPs to allow a > 255 iteration count */
829 nv40_fp_rep(fpc
, 255, finst
->Label
.Label
);
832 case TGSI_OPCODE_ENDLOOP
:
835 case TGSI_OPCODE_BRK
:
841 case TGSI_OPCODE_CONT
:
843 static int warned
= 0;
845 NOUVEAU_ERR("Sorry, the continue keyword is not implemented: ignoring it.\n");
852 NOUVEAU_ERR("invalid opcode %d\n", finst
->Instruction
.Opcode
);
861 static int warned
= 0;
864 "Sorry, control flow instructions are not supported in hardware on nv3x: ignoring them\n"
865 "If rendering is incorrect, try to disable GLSL support in the application.\n");
873 nvfx_fragprog_parse_decl_output(struct nvfx_context
* nvfx
, struct nvfx_fpc
*fpc
,
874 const struct tgsi_full_declaration
*fdec
)
876 unsigned idx
= fdec
->Range
.First
;
879 switch (fdec
->Semantic
.Name
) {
880 case TGSI_SEMANTIC_POSITION
:
883 case TGSI_SEMANTIC_COLOR
:
885 switch (fdec
->Semantic
.Index
) {
886 case 0: hw
= 0; break;
887 case 1: hw
= 2; break;
888 case 2: hw
= 3; break;
889 case 3: hw
= 4; break;
891 if(hw
> ((nvfx
->is_nv4x
) ? 4 : 2)) {
892 NOUVEAU_ERR("bad rcol index\n");
897 NOUVEAU_ERR("bad output semantic\n");
901 fpc
->r_result
[idx
] = nvfx_reg(NVFXSR_OUTPUT
, hw
);
902 fpc
->r_temps
|= (1 << hw
);
907 nvfx_fragprog_prepare(struct nvfx_context
* nvfx
, struct nvfx_fpc
*fpc
)
909 struct tgsi_parse_context p
;
910 int high_temp
= -1, i
;
911 struct util_semantic_set set
;
912 float const0v
[4] = {0, 0, 0, 0};
913 struct nvfx_reg const0
;
915 fpc
->fp
->num_slots
= util_semantic_set_from_program_file(&set
, fpc
->fp
->pipe
.tokens
, TGSI_FILE_INPUT
);
916 if(fpc
->fp
->num_slots
> 8)
918 util_semantic_layout_from_set(fpc
->fp
->slot_to_generic
, &set
, 0, 8);
919 util_semantic_table_from_layout(fpc
->generic_to_slot
, fpc
->fp
->slot_to_generic
, 0, 8);
921 memset(fpc
->fp
->slot_to_fp_input
, 0xff, sizeof(fpc
->fp
->slot_to_fp_input
));
923 const0
= constant(fpc
, -1, const0v
);
924 assert(const0
.index
== 0);
926 tgsi_parse_init(&p
, fpc
->fp
->pipe
.tokens
);
927 while (!tgsi_parse_end_of_tokens(&p
)) {
928 const union tgsi_full_token
*tok
= &p
.FullToken
;
930 tgsi_parse_token(&p
);
931 switch(tok
->Token
.Type
) {
932 case TGSI_TOKEN_TYPE_DECLARATION
:
934 const struct tgsi_full_declaration
*fdec
;
935 fdec
= &p
.FullToken
.FullDeclaration
;
936 switch (fdec
->Declaration
.File
) {
937 case TGSI_FILE_OUTPUT
:
938 if (!nvfx_fragprog_parse_decl_output(nvfx
, fpc
, fdec
))
941 case TGSI_FILE_TEMPORARY
:
942 if (fdec
->Range
.Last
> high_temp
) {
952 case TGSI_TOKEN_TYPE_IMMEDIATE
:
954 struct tgsi_full_immediate
*imm
;
957 imm
= &p
.FullToken
.FullImmediate
;
958 assert(imm
->Immediate
.DataType
== TGSI_IMM_FLOAT32
);
959 assert(fpc
->nr_imm
< MAX_IMM
);
961 vals
[0] = imm
->u
[0].Float
;
962 vals
[1] = imm
->u
[1].Float
;
963 vals
[2] = imm
->u
[2].Float
;
964 vals
[3] = imm
->u
[3].Float
;
965 fpc
->imm
[fpc
->nr_imm
++] = constant(fpc
, -1, vals
);
975 fpc
->r_temp
= CALLOC(high_temp
, sizeof(struct nvfx_reg
));
976 for (i
= 0; i
< high_temp
; i
++)
977 fpc
->r_temp
[i
] = temp(fpc
);
978 fpc
->r_temps_discard
= 0;
990 DEBUG_GET_ONCE_BOOL_OPTION(nvfx_dump_fp
, "NVFX_DUMP_FP", FALSE
)
993 nvfx_fragprog_translate(struct nvfx_context
*nvfx
,
994 struct nvfx_fragment_program
*fp
)
996 struct tgsi_parse_context parse
;
997 struct nvfx_fpc
*fpc
= NULL
;
998 struct util_dynarray insns
;
1000 fpc
= CALLOC(1, sizeof(struct nvfx_fpc
));
1006 if (!nvfx_fragprog_prepare(nvfx
, fpc
)) {
1011 tgsi_parse_init(&parse
, fp
->pipe
.tokens
);
1013 util_dynarray_init(&insns
);
1014 while (!tgsi_parse_end_of_tokens(&parse
)) {
1015 tgsi_parse_token(&parse
);
1017 switch (parse
.FullToken
.Token
.Type
) {
1018 case TGSI_TOKEN_TYPE_INSTRUCTION
:
1020 const struct tgsi_full_instruction
*finst
;
1022 util_dynarray_append(&insns
, unsigned, fp
->insn_len
);
1023 finst
= &parse
.FullToken
.FullInstruction
;
1024 if (!nvfx_fragprog_parse_instruction(nvfx
, fpc
, finst
))
1032 util_dynarray_append(&insns
, unsigned, fp
->insn_len
);
1034 for(unsigned i
= 0; i
< fpc
->label_relocs
.size
; i
+= sizeof(struct nvfx_label_relocation
))
1036 struct nvfx_label_relocation
* label_reloc
= (struct nvfx_label_relocation
*)((char*)fpc
->label_relocs
.data
+ i
);
1037 fp
->insn
[label_reloc
->location
] |= ((unsigned*)insns
.data
)[label_reloc
->target
];
1039 util_dynarray_fini(&insns
);
1042 fp
->fp_control
|= (fpc
->num_regs
-1)/2;
1044 fp
->fp_control
|= fpc
->num_regs
<< NV40TCL_FP_CONTROL_TEMP_COUNT_SHIFT
;
1046 /* Terminate final instruction */
1048 fp
->insn
[fpc
->inst_offset
] |= 0x00000001;
1050 /* Append NOP + END instruction for branches to the end of the program */
1051 fpc
->inst_offset
= fp
->insn_len
;
1053 fp
->insn
[fpc
->inst_offset
+ 0] = 0x00000001;
1054 fp
->insn
[fpc
->inst_offset
+ 1] = 0x00000000;
1055 fp
->insn
[fpc
->inst_offset
+ 2] = 0x00000000;
1056 fp
->insn
[fpc
->inst_offset
+ 3] = 0x00000000;
1058 if(debug_get_option_nvfx_dump_fp())
1061 tgsi_dump(fp
->pipe
.tokens
, 0);
1063 debug_printf("\n%s fragment program:\n", nvfx
->is_nv4x
? "nv4x" : "nv3x");
1064 for (unsigned i
= 0; i
< fp
->insn_len
; i
+= 4)
1065 debug_printf("%3u: %08x %08x %08x %08x\n", i
>> 2, fp
->insn
[i
], fp
->insn
[i
+ 1], fp
->insn
[i
+ 2], fp
->insn
[i
+ 3]);
1069 fp
->translated
= TRUE
;
1071 tgsi_parse_free(&parse
);
1074 util_dynarray_fini(&fpc
->if_stack
);
1075 util_dynarray_fini(&fpc
->label_relocs
);
1076 //util_dynarray_fini(&fpc->loop_stack);
1081 nvfx_fp_memcpy(void* dst
, const void* src
, size_t len
)
1083 #ifndef WORDS_BIGENDIAN
1084 memcpy(dst
, src
, len
);
1087 for(i
= 0; i
< len
; i
+= 4) {
1088 uint32_t v
= (uint32_t*)((char*)src
+ i
);
1089 *(uint32_t*)((char*)dst
+ i
) = (v
>> 16) | (v
<< 16);
1095 nvfx_fragprog_validate(struct nvfx_context
*nvfx
)
1097 struct nouveau_channel
* chan
= nvfx
->screen
->base
.channel
;
1098 struct nvfx_fragment_program
*fp
= nvfx
->fragprog
;
1101 if (!fp
->translated
)
1103 const int min_size
= 4096;
1105 nvfx_fragprog_translate(nvfx
, fp
);
1106 if (!fp
->translated
) {
1107 static unsigned dummy
[8] = {1, 0, 0, 0, 1, 0, 0, 0};
1108 static int warned
= 0;
1111 fprintf(stderr
, "nvfx: failed to translate fragment program!\n");
1115 /* use dummy program: we cannot fail here */
1116 fp
->translated
= TRUE
;
1117 fp
->insn
= malloc(sizeof(dummy
));
1118 memcpy(fp
->insn
, dummy
, sizeof(dummy
));
1119 fp
->insn_len
= sizeof(dummy
) / sizeof(dummy
[0]);
1123 fp
->prog_size
= (fp
->insn_len
* 4 + 63) & ~63;
1125 if(fp
->prog_size
>= min_size
)
1126 fp
->progs_per_bo
= 1;
1128 fp
->progs_per_bo
= min_size
/ fp
->prog_size
;
1129 fp
->bo_prog_idx
= fp
->progs_per_bo
- 1;
1132 /* we must update constants even on "just" fragprog changes, because
1133 we don't check whether the current constant buffer matches the latest
1134 one bound to this fragment program */
1135 if (nvfx
->dirty
& (NVFX_NEW_FRAGCONST
| NVFX_NEW_FRAGPROG
))
1138 struct nvfx_vertex_program
* vp
= nvfx
->render_mode
== HW
? nvfx
->vertprog
: nvfx
->swtnl
.vertprog
;
1139 if (fp
->last_vp_id
!= vp
->id
) {
1140 char* vp_sem_table
= vp
->generic_to_fp_input
;
1141 unsigned char* fp_semantics
= fp
->slot_to_generic
;
1143 fp
->last_vp_id
= nvfx
->vertprog
->id
;
1144 unsigned char* cur_slots
= fp
->slot_to_fp_input
;
1145 for(unsigned i
= 0; i
< fp
->num_slots
; ++i
) {
1146 unsigned char slot_mask
= vp_sem_table
[fp_semantics
[i
]];
1147 diff
|= (slot_mask
>> 4) & (slot_mask
^ cur_slots
[i
]);
1152 for(unsigned i
= 0; i
< fp
->num_slots
; ++i
) {
1153 /* if 0xff, then this will write to the dummy value at fp->last_layout_mask[0] */
1154 fp
->slot_to_fp_input
[i
] = vp_sem_table
[fp_semantics
[i
]] & 0xf;
1155 //printf("fp: GENERIC[%i] from fpreg %i\n", fp_semantics[i], fp->slot_to_fp_input[i]);
1158 fp
->progs_left_with_obsolete_slot_assignments
= fp
->progs
;
1163 // last_sprite_coord_enable
1164 unsigned sprite_coord_enable
= nvfx
->rasterizer
->pipe
.point_quad_rasterization
* nvfx
->rasterizer
->pipe
.sprite_coord_enable
;
1165 if(fp
->last_sprite_coord_enable
!= sprite_coord_enable
)
1167 unsigned texcoord_mask
= vp
->texcoord_ouput_mask
;
1168 fp
->last_sprite_coord_enable
= sprite_coord_enable
;
1169 fp
->point_sprite_control
= 0;
1170 for(unsigned i
= 0; i
< fp
->num_slots
; ++i
) {
1171 if((1 << fp
->slot_to_generic
[i
]) & sprite_coord_enable
)
1173 unsigned fpin
= fp
->slot_to_fp_input
[i
];
1174 //printf("sprite: slot %i generic %i had texcoord %i\n", i, fp->slot_to_generic[i], fpin - NVFX_FP_OP_INPUT_SRC_TC0);
1177 unsigned tc
= __builtin_ctz(~texcoord_mask
);
1178 texcoord_mask
|= (1 << tc
);
1179 fp
->slot_to_fp_input
[i
] = fpin
= NVFX_FP_OP_INPUT_SRC_TC(tc
);
1181 fp
->progs_left_with_obsolete_slot_assignments
= fp
->progs
;
1184 //printf("sprite: slot %i texcoord %i\n", i, fpin - NVFX_FP_OP_INPUT_SRC_TC0);
1185 fp
->point_sprite_control
|= (1 << (fpin
- NVFX_FP_OP_INPUT_SRC_TC0
+ 8));
1189 unsigned fpin
= fp
->slot_to_fp_input
[i
];
1190 if(!(vp
->texcoord_ouput_mask
& (1 << (fpin
- NVFX_FP_OP_INPUT_SRC_TC0
))))
1192 fp
->slot_to_fp_input
[i
] = 0x0f;
1194 fp
->progs_left_with_obsolete_slot_assignments
= fp
->progs
;
1203 if(fp
->bo_prog_idx
>= fp
->progs_per_bo
)
1205 if(fp
->fpbo
&& !nouveau_bo_busy(fp
->fpbo
->next
->bo
, NOUVEAU_BO_WR
))
1207 fp
->fpbo
= fp
->fpbo
->next
;
1211 struct nvfx_fragment_program_bo
* fpbo
= os_malloc_aligned(sizeof(struct nvfx_fragment_program
) + (fp
->prog_size
+ 8) * fp
->progs_per_bo
, 16);
1212 fpbo
->slots
= (unsigned char*)&fpbo
->insn
[(fp
->prog_size
) * fp
->progs_per_bo
];
1213 memset(fpbo
->slots
, 0, 8 * fp
->progs_per_bo
);
1216 fpbo
->next
= fp
->fpbo
->next
;
1217 fp
->fpbo
->next
= fpbo
;
1223 fp
->progs
+= fp
->progs_per_bo
;
1224 fp
->progs_left_with_obsolete_slot_assignments
+= fp
->progs_per_bo
;
1225 nouveau_bo_new(nvfx
->screen
->base
.device
, NOUVEAU_BO_VRAM
| NOUVEAU_BO_MAP
, 64, fp
->prog_size
* fp
->progs_per_bo
, &fpbo
->bo
);
1226 nouveau_bo_map(fpbo
->bo
, NOUVEAU_BO_NOSYNC
);
1228 uint8_t* map
= fpbo
->bo
->map
;
1229 uint8_t* buf
= (uint8_t*)fpbo
->insn
;
1230 for(unsigned i
= 0; i
< fp
->progs_per_bo
; ++i
)
1232 memcpy(buf
, fp
->insn
, fp
->insn_len
* 4);
1233 nvfx_fp_memcpy(map
, fp
->insn
, fp
->insn_len
* 4);
1234 map
+= fp
->prog_size
;
1235 buf
+= fp
->prog_size
;
1238 fp
->bo_prog_idx
= 0;
1241 int offset
= fp
->bo_prog_idx
* fp
->prog_size
;
1242 uint32_t* fpmap
= (uint32_t*)((char*)fp
->fpbo
->bo
->map
+ offset
);
1244 if(nvfx
->constbuf
[PIPE_SHADER_FRAGMENT
]) {
1245 struct pipe_resource
* constbuf
= nvfx
->constbuf
[PIPE_SHADER_FRAGMENT
];
1246 uint32_t* map
= (uint32_t*)nvfx_buffer(constbuf
)->data
;
1247 uint32_t* fpmap
= (uint32_t*)((char*)fp
->fpbo
->bo
->map
+ offset
);
1248 uint32_t* buf
= (uint32_t*)((char*)fp
->fpbo
->insn
+ offset
);
1250 for (i
= 0; i
< fp
->nr_consts
; ++i
) {
1251 unsigned off
= fp
->consts
[i
].offset
;
1252 unsigned idx
= fp
->consts
[i
].index
* 4;
1254 /* TODO: is checking a good idea? */
1255 if(memcmp(&buf
[off
], &map
[idx
], 4 * sizeof(uint32_t))) {
1256 memcpy(&buf
[off
], &map
[idx
], 4 * sizeof(uint32_t));
1257 nvfx_fp_memcpy(&fpmap
[off
], &map
[idx
], 4 * sizeof(uint32_t));
1262 if(fp
->progs_left_with_obsolete_slot_assignments
) {
1263 unsigned char* fpbo_slots
= &fp
->fpbo
->slots
[fp
->bo_prog_idx
* 8];
1264 for(unsigned i
= 0; i
< fp
->num_slots
; ++i
) {
1265 unsigned value
= fp
->slot_to_fp_input
[i
];;
1266 if(value
!= fpbo_slots
[i
]) {
1267 unsigned* p
= (unsigned*)fp
->slot_relocations
[i
].data
;
1268 unsigned* pend
= (unsigned*)((char*)fp
->slot_relocations
[i
].data
+ fp
->slot_relocations
[i
].size
);
1269 for(; p
!= pend
; ++p
) {
1271 unsigned dw
= fp
->insn
[off
];
1272 dw
= (dw
& ~NVFX_FP_OP_INPUT_SRC_MASK
) | (value
<< NVFX_FP_OP_INPUT_SRC_SHIFT
);
1273 nvfx_fp_memcpy(&fpmap
[*p
], &dw
, sizeof(dw
));
1275 fpbo_slots
[i
] = value
;
1278 --fp
->progs_left_with_obsolete_slot_assignments
;
1282 if(update
|| (nvfx
->dirty
& NVFX_NEW_FRAGPROG
)) {
1283 int offset
= fp
->bo_prog_idx
* fp
->prog_size
;
1284 MARK_RING(chan
, 8, 1);
1285 OUT_RING(chan
, RING_3D(NV34TCL_FP_ACTIVE_PROGRAM
, 1));
1286 OUT_RELOC(chan
, fp
->fpbo
->bo
, offset
, NOUVEAU_BO_VRAM
|
1287 NOUVEAU_BO_GART
| NOUVEAU_BO_RD
| NOUVEAU_BO_LOW
|
1288 NOUVEAU_BO_OR
, NV34TCL_FP_ACTIVE_PROGRAM_DMA0
,
1289 NV34TCL_FP_ACTIVE_PROGRAM_DMA1
);
1290 OUT_RING(chan
, RING_3D(NV34TCL_FP_CONTROL
, 1));
1291 OUT_RING(chan
, fp
->fp_control
);
1292 if(!nvfx
->is_nv4x
) {
1293 OUT_RING(chan
, RING_3D(NV34TCL_FP_REG_CONTROL
, 1));
1294 OUT_RING(chan
, (1<<16)|0x4);
1295 OUT_RING(chan
, RING_3D(NV34TCL_TX_UNITS_ENABLE
, 1));
1296 OUT_RING(chan
, fp
->samplers
);
1300 if(nvfx
->dirty
& (NVFX_NEW_FRAGPROG
| NVFX_NEW_SPRITE
))
1303 OUT_RING(chan
, RING_3D(NV34TCL_POINT_SPRITE
, 1));
1304 OUT_RING(chan
, fp
->point_sprite_control
| nvfx
->rasterizer
->pipe
.point_quad_rasterization
);
1309 nvfx_fragprog_relocate(struct nvfx_context
*nvfx
)
1311 struct nouveau_channel
* chan
= nvfx
->screen
->base
.channel
;
1312 struct nvfx_fragment_program
*fp
= nvfx
->fragprog
;
1313 struct nouveau_bo
* bo
= fp
->fpbo
->bo
;
1314 int offset
= fp
->bo_prog_idx
* fp
->prog_size
;
1315 unsigned fp_flags
= NOUVEAU_BO_VRAM
| NOUVEAU_BO_RD
; // TODO: GART?
1316 fp_flags
|= NOUVEAU_BO_DUMMY
;
1317 MARK_RING(chan
, 2, 2);
1318 OUT_RELOC(chan
, bo
, RING_3D(NV34TCL_FP_ACTIVE_PROGRAM
, 1), fp_flags
, 0, 0);
1319 OUT_RELOC(chan
, bo
, offset
, fp_flags
| NOUVEAU_BO_LOW
|
1320 NOUVEAU_BO_OR
, NV34TCL_FP_ACTIVE_PROGRAM_DMA0
,
1321 NV34TCL_FP_ACTIVE_PROGRAM_DMA1
);
1325 nvfx_fragprog_destroy(struct nvfx_context
*nvfx
,
1326 struct nvfx_fragment_program
*fp
)
1329 struct nvfx_fragment_program_bo
* fpbo
= fp
->fpbo
;
1334 struct nvfx_fragment_program_bo
* next
= fpbo
->next
;
1335 nouveau_bo_unmap(fpbo
->bo
);
1336 nouveau_bo_ref(0, &fpbo
->bo
);
1340 while(fpbo
!= fp
->fpbo
);
1343 for(i
= 0; i
< 8; ++i
)
1344 util_dynarray_fini(&fp
->slot_relocations
[i
]);