2 * Copyright (C) 2008 Nicolai Haehnle.
6 * Permission is hereby granted, free of charge, to any person obtaining
7 * a copy of this software and associated documentation files (the
8 * "Software"), to deal in the Software without restriction, including
9 * without limitation the rights to use, copy, modify, merge, publish,
10 * distribute, sublicense, and/or sell copies of the Software, and to
11 * permit persons to whom the Software is furnished to do so, subject to
12 * the following conditions:
14 * The above copyright notice and this permission notice (including the
15 * next paragraph) shall be included in all copies or substantial
16 * portions of the Software.
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
19 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
20 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
21 * IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
22 * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
23 * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
24 * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
31 * Shareable transformations that transform "special" ALU instructions
32 * into ALU instructions that are supported by hardware.
36 #include "radeon_program_alu.h"
38 #include "radeon_compiler.h"
41 static struct rc_instruction
*emit1(
42 struct radeon_compiler
* c
, struct rc_instruction
* after
,
43 rc_opcode Opcode
, rc_saturate_mode Saturate
, struct rc_dst_register DstReg
,
44 struct rc_src_register SrcReg
)
46 struct rc_instruction
*fpi
= rc_insert_new_instruction(c
, after
);
48 fpi
->U
.I
.Opcode
= Opcode
;
49 fpi
->U
.I
.SaturateMode
= Saturate
;
50 fpi
->U
.I
.DstReg
= DstReg
;
51 fpi
->U
.I
.SrcReg
[0] = SrcReg
;
55 static struct rc_instruction
*emit2(
56 struct radeon_compiler
* c
, struct rc_instruction
* after
,
57 rc_opcode Opcode
, rc_saturate_mode Saturate
, struct rc_dst_register DstReg
,
58 struct rc_src_register SrcReg0
, struct rc_src_register SrcReg1
)
60 struct rc_instruction
*fpi
= rc_insert_new_instruction(c
, after
);
62 fpi
->U
.I
.Opcode
= Opcode
;
63 fpi
->U
.I
.SaturateMode
= Saturate
;
64 fpi
->U
.I
.DstReg
= DstReg
;
65 fpi
->U
.I
.SrcReg
[0] = SrcReg0
;
66 fpi
->U
.I
.SrcReg
[1] = SrcReg1
;
70 static struct rc_instruction
*emit3(
71 struct radeon_compiler
* c
, struct rc_instruction
* after
,
72 rc_opcode Opcode
, rc_saturate_mode Saturate
, struct rc_dst_register DstReg
,
73 struct rc_src_register SrcReg0
, struct rc_src_register SrcReg1
,
74 struct rc_src_register SrcReg2
)
76 struct rc_instruction
*fpi
= rc_insert_new_instruction(c
, after
);
78 fpi
->U
.I
.Opcode
= Opcode
;
79 fpi
->U
.I
.SaturateMode
= Saturate
;
80 fpi
->U
.I
.DstReg
= DstReg
;
81 fpi
->U
.I
.SrcReg
[0] = SrcReg0
;
82 fpi
->U
.I
.SrcReg
[1] = SrcReg1
;
83 fpi
->U
.I
.SrcReg
[2] = SrcReg2
;
87 static struct rc_dst_register
dstreg(int file
, int index
)
89 struct rc_dst_register dst
;
92 dst
.WriteMask
= RC_MASK_XYZW
;
97 static struct rc_dst_register
dstregtmpmask(int index
, int mask
)
99 struct rc_dst_register dst
= {0};
100 dst
.File
= RC_FILE_TEMPORARY
;
102 dst
.WriteMask
= mask
;
107 static const struct rc_src_register builtin_zero
= {
108 .File
= RC_FILE_NONE
,
110 .Swizzle
= RC_SWIZZLE_0000
112 static const struct rc_src_register builtin_one
= {
113 .File
= RC_FILE_NONE
,
115 .Swizzle
= RC_SWIZZLE_1111
117 static const struct rc_src_register srcreg_undefined
= {
118 .File
= RC_FILE_NONE
,
120 .Swizzle
= RC_SWIZZLE_XYZW
123 static struct rc_src_register
srcreg(int file
, int index
)
125 struct rc_src_register src
= srcreg_undefined
;
131 static struct rc_src_register
srcregswz(int file
, int index
, int swz
)
133 struct rc_src_register src
= srcreg_undefined
;
140 static struct rc_src_register
absolute(struct rc_src_register reg
)
142 struct rc_src_register newreg
= reg
;
144 newreg
.Negate
= RC_MASK_NONE
;
148 static struct rc_src_register
negate(struct rc_src_register reg
)
150 struct rc_src_register newreg
= reg
;
151 newreg
.Negate
= newreg
.Negate
^ RC_MASK_XYZW
;
155 static struct rc_src_register
swizzle(struct rc_src_register reg
,
156 rc_swizzle x
, rc_swizzle y
, rc_swizzle z
, rc_swizzle w
)
158 struct rc_src_register swizzled
= reg
;
159 swizzled
.Swizzle
= combine_swizzles4(reg
.Swizzle
, x
, y
, z
, w
);
163 static struct rc_src_register
scalar(struct rc_src_register reg
)
165 return swizzle(reg
, RC_SWIZZLE_X
, RC_SWIZZLE_X
, RC_SWIZZLE_X
, RC_SWIZZLE_X
);
168 static void transform_ABS(struct radeon_compiler
* c
,
169 struct rc_instruction
* inst
)
171 struct rc_src_register src
= inst
->U
.I
.SrcReg
[0];
173 src
.Negate
= RC_MASK_NONE
;
174 emit1(c
, inst
->Prev
, RC_OPCODE_MOV
, inst
->U
.I
.SaturateMode
, inst
->U
.I
.DstReg
, src
);
175 rc_remove_instruction(inst
);
178 static void transform_CEIL(struct radeon_compiler
* c
,
179 struct rc_instruction
* inst
)
182 * ceil(x) = -floor(-x)
184 * After inlining floor:
185 * ceil(x) = -(-x-frac(-x))
187 * After simplification:
188 * ceil(x) = x+frac(-x)
191 int tempreg
= rc_find_free_temporary(c
);
192 emit1(c
, inst
->Prev
, RC_OPCODE_FRC
, 0, dstreg(RC_FILE_TEMPORARY
, tempreg
), negate(inst
->U
.I
.SrcReg
[0]));
193 emit2(c
, inst
->Prev
, RC_OPCODE_ADD
, inst
->U
.I
.SaturateMode
, inst
->U
.I
.DstReg
,
194 inst
->U
.I
.SrcReg
[0], srcreg(RC_FILE_TEMPORARY
, tempreg
));
195 rc_remove_instruction(inst
);
198 static void transform_DP3(struct radeon_compiler
* c
,
199 struct rc_instruction
* inst
)
201 struct rc_src_register src0
= inst
->U
.I
.SrcReg
[0];
202 struct rc_src_register src1
= inst
->U
.I
.SrcReg
[1];
203 src0
.Negate
&= ~RC_MASK_W
;
204 src0
.Swizzle
&= ~(7 << (3 * 3));
205 src0
.Swizzle
|= RC_SWIZZLE_ZERO
<< (3 * 3);
206 src1
.Negate
&= ~RC_MASK_W
;
207 src1
.Swizzle
&= ~(7 << (3 * 3));
208 src1
.Swizzle
|= RC_SWIZZLE_ZERO
<< (3 * 3);
209 emit2(c
, inst
->Prev
, RC_OPCODE_DP4
, inst
->U
.I
.SaturateMode
, inst
->U
.I
.DstReg
, src0
, src1
);
210 rc_remove_instruction(inst
);
213 static void transform_DPH(struct radeon_compiler
* c
,
214 struct rc_instruction
* inst
)
216 struct rc_src_register src0
= inst
->U
.I
.SrcReg
[0];
217 src0
.Negate
&= ~RC_MASK_W
;
218 src0
.Swizzle
&= ~(7 << (3 * 3));
219 src0
.Swizzle
|= RC_SWIZZLE_ONE
<< (3 * 3);
220 emit2(c
, inst
->Prev
, RC_OPCODE_DP4
, inst
->U
.I
.SaturateMode
, inst
->U
.I
.DstReg
, src0
, inst
->U
.I
.SrcReg
[1]);
221 rc_remove_instruction(inst
);
225 * [1, src0.y*src1.y, src0.z, src1.w]
226 * So basically MUL with lotsa swizzling.
228 static void transform_DST(struct radeon_compiler
* c
,
229 struct rc_instruction
* inst
)
231 emit2(c
, inst
->Prev
, RC_OPCODE_MUL
, inst
->U
.I
.SaturateMode
, inst
->U
.I
.DstReg
,
232 swizzle(inst
->U
.I
.SrcReg
[0], RC_SWIZZLE_ONE
, RC_SWIZZLE_Y
, RC_SWIZZLE_Z
, RC_SWIZZLE_ONE
),
233 swizzle(inst
->U
.I
.SrcReg
[1], RC_SWIZZLE_ONE
, RC_SWIZZLE_Y
, RC_SWIZZLE_ONE
, RC_SWIZZLE_W
));
234 rc_remove_instruction(inst
);
237 static void transform_FLR(struct radeon_compiler
* c
,
238 struct rc_instruction
* inst
)
240 int tempreg
= rc_find_free_temporary(c
);
241 emit1(c
, inst
->Prev
, RC_OPCODE_FRC
, 0, dstreg(RC_FILE_TEMPORARY
, tempreg
), inst
->U
.I
.SrcReg
[0]);
242 emit2(c
, inst
->Prev
, RC_OPCODE_ADD
, inst
->U
.I
.SaturateMode
, inst
->U
.I
.DstReg
,
243 inst
->U
.I
.SrcReg
[0], negate(srcreg(RC_FILE_TEMPORARY
, tempreg
)));
244 rc_remove_instruction(inst
);
248 * Definition of LIT (from ARB_fragment_program):
250 * tmp = VectorLoad(op0);
251 * if (tmp.x < 0) tmp.x = 0;
252 * if (tmp.y < 0) tmp.y = 0;
253 * if (tmp.w < -(128.0-epsilon)) tmp.w = -(128.0-epsilon);
254 * else if (tmp.w > 128-epsilon) tmp.w = 128-epsilon;
257 * result.z = (tmp.x > 0) ? RoughApproxPower(tmp.y, tmp.w) : 0.0;
260 * The longest path of computation is the one leading to result.z,
261 * consisting of 5 operations. This implementation of LIT takes
262 * 5 slots, if the subsequent optimization passes are clever enough
263 * to pair instructions correctly.
265 static void transform_LIT(struct radeon_compiler
* c
,
266 struct rc_instruction
* inst
)
268 unsigned int constant
;
269 unsigned int constant_swizzle
;
271 struct rc_src_register srctemp
;
273 constant
= rc_constants_add_immediate_scalar(&c
->Program
.Constants
, -127.999999, &constant_swizzle
);
275 if (inst
->U
.I
.DstReg
.WriteMask
!= RC_MASK_XYZW
|| inst
->U
.I
.DstReg
.File
!= RC_FILE_TEMPORARY
) {
276 struct rc_instruction
* inst_mov
;
278 inst_mov
= emit1(c
, inst
,
279 RC_OPCODE_MOV
, 0, inst
->U
.I
.DstReg
,
280 srcreg(RC_FILE_TEMPORARY
, rc_find_free_temporary(c
)));
282 inst
->U
.I
.DstReg
.File
= RC_FILE_TEMPORARY
;
283 inst
->U
.I
.DstReg
.Index
= inst_mov
->U
.I
.SrcReg
[0].Index
;
284 inst
->U
.I
.DstReg
.WriteMask
= RC_MASK_XYZW
;
287 temp
= inst
->U
.I
.DstReg
.Index
;
288 srctemp
= srcreg(RC_FILE_TEMPORARY
, temp
);
290 /* tmp.x = max(0.0, Src.x); */
291 /* tmp.y = max(0.0, Src.y); */
292 /* tmp.w = clamp(Src.z, -128+eps, 128-eps); */
293 emit2(c
, inst
->Prev
, RC_OPCODE_MAX
, 0,
294 dstregtmpmask(temp
, RC_MASK_XYW
),
296 swizzle(srcreg(RC_FILE_CONSTANT
, constant
),
297 RC_SWIZZLE_ZERO
, RC_SWIZZLE_ZERO
, RC_SWIZZLE_ZERO
, constant_swizzle
&3));
298 emit2(c
, inst
->Prev
, RC_OPCODE_MIN
, 0,
299 dstregtmpmask(temp
, RC_MASK_Z
),
300 swizzle(srctemp
, RC_SWIZZLE_W
, RC_SWIZZLE_W
, RC_SWIZZLE_W
, RC_SWIZZLE_W
),
301 negate(srcregswz(RC_FILE_CONSTANT
, constant
, constant_swizzle
)));
303 /* tmp.w = Pow(tmp.y, tmp.w) */
304 emit1(c
, inst
->Prev
, RC_OPCODE_LG2
, 0,
305 dstregtmpmask(temp
, RC_MASK_W
),
306 swizzle(srctemp
, RC_SWIZZLE_Y
, RC_SWIZZLE_Y
, RC_SWIZZLE_Y
, RC_SWIZZLE_Y
));
307 emit2(c
, inst
->Prev
, RC_OPCODE_MUL
, 0,
308 dstregtmpmask(temp
, RC_MASK_W
),
309 swizzle(srctemp
, RC_SWIZZLE_W
, RC_SWIZZLE_W
, RC_SWIZZLE_W
, RC_SWIZZLE_W
),
310 swizzle(srctemp
, RC_SWIZZLE_Z
, RC_SWIZZLE_Z
, RC_SWIZZLE_Z
, RC_SWIZZLE_Z
));
311 emit1(c
, inst
->Prev
, RC_OPCODE_EX2
, 0,
312 dstregtmpmask(temp
, RC_MASK_W
),
313 swizzle(srctemp
, RC_SWIZZLE_W
, RC_SWIZZLE_W
, RC_SWIZZLE_W
, RC_SWIZZLE_W
));
315 /* tmp.z = (tmp.x > 0) ? tmp.w : 0.0 */
316 emit3(c
, inst
->Prev
, RC_OPCODE_CMP
, inst
->U
.I
.SaturateMode
,
317 dstregtmpmask(temp
, RC_MASK_Z
),
318 negate(swizzle(srctemp
, RC_SWIZZLE_X
, RC_SWIZZLE_X
, RC_SWIZZLE_X
, RC_SWIZZLE_X
)),
319 swizzle(srctemp
, RC_SWIZZLE_W
, RC_SWIZZLE_W
, RC_SWIZZLE_W
, RC_SWIZZLE_W
),
322 /* tmp.x, tmp.y, tmp.w = 1.0, tmp.x, 1.0 */
323 emit1(c
, inst
->Prev
, RC_OPCODE_MOV
, inst
->U
.I
.SaturateMode
,
324 dstregtmpmask(temp
, RC_MASK_XYW
),
325 swizzle(srctemp
, RC_SWIZZLE_ONE
, RC_SWIZZLE_X
, RC_SWIZZLE_ONE
, RC_SWIZZLE_ONE
));
327 rc_remove_instruction(inst
);
330 static void transform_LRP(struct radeon_compiler
* c
,
331 struct rc_instruction
* inst
)
333 int tempreg
= rc_find_free_temporary(c
);
335 emit2(c
, inst
->Prev
, RC_OPCODE_ADD
, 0,
336 dstreg(RC_FILE_TEMPORARY
, tempreg
),
337 inst
->U
.I
.SrcReg
[1], negate(inst
->U
.I
.SrcReg
[2]));
338 emit3(c
, inst
->Prev
, RC_OPCODE_MAD
, inst
->U
.I
.SaturateMode
,
340 inst
->U
.I
.SrcReg
[0], srcreg(RC_FILE_TEMPORARY
, tempreg
), inst
->U
.I
.SrcReg
[2]);
342 rc_remove_instruction(inst
);
345 static void transform_POW(struct radeon_compiler
* c
,
346 struct rc_instruction
* inst
)
348 int tempreg
= rc_find_free_temporary(c
);
349 struct rc_dst_register tempdst
= dstreg(RC_FILE_TEMPORARY
, tempreg
);
350 struct rc_src_register tempsrc
= srcreg(RC_FILE_TEMPORARY
, tempreg
);
351 tempdst
.WriteMask
= RC_MASK_W
;
352 tempsrc
.Swizzle
= RC_SWIZZLE_WWWW
;
354 emit1(c
, inst
->Prev
, RC_OPCODE_LG2
, 0, tempdst
, scalar(inst
->U
.I
.SrcReg
[0]));
355 emit2(c
, inst
->Prev
, RC_OPCODE_MUL
, 0, tempdst
, tempsrc
, scalar(inst
->U
.I
.SrcReg
[1]));
356 emit1(c
, inst
->Prev
, RC_OPCODE_EX2
, inst
->U
.I
.SaturateMode
, inst
->U
.I
.DstReg
, tempsrc
);
358 rc_remove_instruction(inst
);
361 static void transform_RSQ(struct radeon_compiler
* c
,
362 struct rc_instruction
* inst
)
364 inst
->U
.I
.SrcReg
[0] = absolute(inst
->U
.I
.SrcReg
[0]);
367 static void transform_SEQ(struct radeon_compiler
* c
,
368 struct rc_instruction
* inst
)
370 int tempreg
= rc_find_free_temporary(c
);
372 emit2(c
, inst
->Prev
, RC_OPCODE_ADD
, 0, dstreg(RC_FILE_TEMPORARY
, tempreg
), inst
->U
.I
.SrcReg
[0], negate(inst
->U
.I
.SrcReg
[1]));
373 emit3(c
, inst
->Prev
, RC_OPCODE_CMP
, inst
->U
.I
.SaturateMode
, inst
->U
.I
.DstReg
,
374 negate(absolute(srcreg(RC_FILE_TEMPORARY
, tempreg
))), builtin_zero
, builtin_one
);
376 rc_remove_instruction(inst
);
379 static void transform_SFL(struct radeon_compiler
* c
,
380 struct rc_instruction
* inst
)
382 emit1(c
, inst
->Prev
, RC_OPCODE_MOV
, inst
->U
.I
.SaturateMode
, inst
->U
.I
.DstReg
, builtin_zero
);
383 rc_remove_instruction(inst
);
386 static void transform_SGE(struct radeon_compiler
* c
,
387 struct rc_instruction
* inst
)
389 int tempreg
= rc_find_free_temporary(c
);
391 emit2(c
, inst
->Prev
, RC_OPCODE_ADD
, 0, dstreg(RC_FILE_TEMPORARY
, tempreg
), inst
->U
.I
.SrcReg
[0], negate(inst
->U
.I
.SrcReg
[1]));
392 emit3(c
, inst
->Prev
, RC_OPCODE_CMP
, inst
->U
.I
.SaturateMode
, inst
->U
.I
.DstReg
,
393 srcreg(RC_FILE_TEMPORARY
, tempreg
), builtin_zero
, builtin_one
);
395 rc_remove_instruction(inst
);
398 static void transform_SGT(struct radeon_compiler
* c
,
399 struct rc_instruction
* inst
)
401 int tempreg
= rc_find_free_temporary(c
);
403 emit2(c
, inst
->Prev
, RC_OPCODE_ADD
, 0, dstreg(RC_FILE_TEMPORARY
, tempreg
), negate(inst
->U
.I
.SrcReg
[0]), inst
->U
.I
.SrcReg
[1]);
404 emit3(c
, inst
->Prev
, RC_OPCODE_CMP
, inst
->U
.I
.SaturateMode
, inst
->U
.I
.DstReg
,
405 srcreg(RC_FILE_TEMPORARY
, tempreg
), builtin_one
, builtin_zero
);
407 rc_remove_instruction(inst
);
410 static void transform_SLE(struct radeon_compiler
* c
,
411 struct rc_instruction
* inst
)
413 int tempreg
= rc_find_free_temporary(c
);
415 emit2(c
, inst
->Prev
, RC_OPCODE_ADD
, 0, dstreg(RC_FILE_TEMPORARY
, tempreg
), negate(inst
->U
.I
.SrcReg
[0]), inst
->U
.I
.SrcReg
[1]);
416 emit3(c
, inst
->Prev
, RC_OPCODE_CMP
, inst
->U
.I
.SaturateMode
, inst
->U
.I
.DstReg
,
417 srcreg(RC_FILE_TEMPORARY
, tempreg
), builtin_zero
, builtin_one
);
419 rc_remove_instruction(inst
);
422 static void transform_SLT(struct radeon_compiler
* c
,
423 struct rc_instruction
* inst
)
425 int tempreg
= rc_find_free_temporary(c
);
427 emit2(c
, inst
->Prev
, RC_OPCODE_ADD
, 0, dstreg(RC_FILE_TEMPORARY
, tempreg
), inst
->U
.I
.SrcReg
[0], negate(inst
->U
.I
.SrcReg
[1]));
428 emit3(c
, inst
->Prev
, RC_OPCODE_CMP
, inst
->U
.I
.SaturateMode
, inst
->U
.I
.DstReg
,
429 srcreg(RC_FILE_TEMPORARY
, tempreg
), builtin_one
, builtin_zero
);
431 rc_remove_instruction(inst
);
434 static void transform_SNE(struct radeon_compiler
* c
,
435 struct rc_instruction
* inst
)
437 int tempreg
= rc_find_free_temporary(c
);
439 emit2(c
, inst
->Prev
, RC_OPCODE_ADD
, 0, dstreg(RC_FILE_TEMPORARY
, tempreg
), inst
->U
.I
.SrcReg
[0], negate(inst
->U
.I
.SrcReg
[1]));
440 emit3(c
, inst
->Prev
, RC_OPCODE_CMP
, inst
->U
.I
.SaturateMode
, inst
->U
.I
.DstReg
,
441 negate(absolute(srcreg(RC_FILE_TEMPORARY
, tempreg
))), builtin_one
, builtin_zero
);
443 rc_remove_instruction(inst
);
446 static void transform_SUB(struct radeon_compiler
* c
,
447 struct rc_instruction
* inst
)
449 inst
->U
.I
.Opcode
= RC_OPCODE_ADD
;
450 inst
->U
.I
.SrcReg
[1] = negate(inst
->U
.I
.SrcReg
[1]);
453 static void transform_SWZ(struct radeon_compiler
* c
,
454 struct rc_instruction
* inst
)
456 inst
->U
.I
.Opcode
= RC_OPCODE_MOV
;
459 static void transform_XPD(struct radeon_compiler
* c
,
460 struct rc_instruction
* inst
)
462 int tempreg
= rc_find_free_temporary(c
);
464 emit2(c
, inst
->Prev
, RC_OPCODE_MUL
, 0, dstreg(RC_FILE_TEMPORARY
, tempreg
),
465 swizzle(inst
->U
.I
.SrcReg
[0], RC_SWIZZLE_Z
, RC_SWIZZLE_X
, RC_SWIZZLE_Y
, RC_SWIZZLE_W
),
466 swizzle(inst
->U
.I
.SrcReg
[1], RC_SWIZZLE_Y
, RC_SWIZZLE_Z
, RC_SWIZZLE_X
, RC_SWIZZLE_W
));
467 emit3(c
, inst
->Prev
, RC_OPCODE_MAD
, inst
->U
.I
.SaturateMode
, inst
->U
.I
.DstReg
,
468 swizzle(inst
->U
.I
.SrcReg
[0], RC_SWIZZLE_Y
, RC_SWIZZLE_Z
, RC_SWIZZLE_X
, RC_SWIZZLE_W
),
469 swizzle(inst
->U
.I
.SrcReg
[1], RC_SWIZZLE_Z
, RC_SWIZZLE_X
, RC_SWIZZLE_Y
, RC_SWIZZLE_W
),
470 negate(srcreg(RC_FILE_TEMPORARY
, tempreg
)));
472 rc_remove_instruction(inst
);
477 * Can be used as a transformation for @ref radeonClauseLocalTransform,
478 * no userData necessary.
480 * Eliminates the following ALU instructions:
481 * ABS, CEIL, DPH, DST, FLR, LIT, LRP, POW, SEQ, SFL, SGE, SGT, SLE, SLT, SNE, SUB, SWZ, XPD
483 * MOV, ADD, MUL, MAD, FRC, DP3, LG2, EX2, CMP
485 * Transforms RSQ to Radeon's native RSQ by explicitly setting
488 * @note should be applicable to R300 and R500 fragment programs.
490 int radeonTransformALU(
491 struct radeon_compiler
* c
,
492 struct rc_instruction
* inst
,
495 switch(inst
->U
.I
.Opcode
) {
496 case RC_OPCODE_ABS
: transform_ABS(c
, inst
); return 1;
497 case RC_OPCODE_CEIL
: transform_CEIL(c
, inst
); return 1;
498 case RC_OPCODE_DPH
: transform_DPH(c
, inst
); return 1;
499 case RC_OPCODE_DST
: transform_DST(c
, inst
); return 1;
500 case RC_OPCODE_FLR
: transform_FLR(c
, inst
); return 1;
501 case RC_OPCODE_LIT
: transform_LIT(c
, inst
); return 1;
502 case RC_OPCODE_LRP
: transform_LRP(c
, inst
); return 1;
503 case RC_OPCODE_POW
: transform_POW(c
, inst
); return 1;
504 case RC_OPCODE_RSQ
: transform_RSQ(c
, inst
); return 1;
505 case RC_OPCODE_SEQ
: transform_SEQ(c
, inst
); return 1;
506 case RC_OPCODE_SFL
: transform_SFL(c
, inst
); return 1;
507 case RC_OPCODE_SGE
: transform_SGE(c
, inst
); return 1;
508 case RC_OPCODE_SGT
: transform_SGT(c
, inst
); return 1;
509 case RC_OPCODE_SLE
: transform_SLE(c
, inst
); return 1;
510 case RC_OPCODE_SLT
: transform_SLT(c
, inst
); return 1;
511 case RC_OPCODE_SNE
: transform_SNE(c
, inst
); return 1;
512 case RC_OPCODE_SUB
: transform_SUB(c
, inst
); return 1;
513 case RC_OPCODE_SWZ
: transform_SWZ(c
, inst
); return 1;
514 case RC_OPCODE_XPD
: transform_XPD(c
, inst
); return 1;
521 static void transform_r300_vertex_ABS(struct radeon_compiler
* c
,
522 struct rc_instruction
* inst
)
524 /* Note: r500 can take absolute values, but r300 cannot. */
525 inst
->U
.I
.Opcode
= RC_OPCODE_MAX
;
526 inst
->U
.I
.SrcReg
[1] = inst
->U
.I
.SrcReg
[0];
527 inst
->U
.I
.SrcReg
[1].Negate
^= RC_MASK_XYZW
;
530 static void transform_r300_vertex_CMP(struct radeon_compiler
* c
,
531 struct rc_instruction
* inst
)
533 /* There is no decent CMP available, so let's rig one up.
534 * CMP is defined as dst = src0 < 0.0 ? src1 : src2
535 * The following sequence consumes two temps and two extra slots
536 * (the second temp and the second slot is consumed by transform_LRP),
537 * but should be equivalent:
539 * SLT tmp0, src0, 0.0
540 * LRP dst, tmp0, src1, src2
542 * Yes, I know, I'm a mad scientist. ~ C. & M. */
543 int tempreg0
= rc_find_free_temporary(c
);
545 /* SLT tmp0, src0, 0.0 */
546 emit2(c
, inst
->Prev
, RC_OPCODE_SLT
, 0,
547 dstreg(RC_FILE_TEMPORARY
, tempreg0
),
548 inst
->U
.I
.SrcReg
[0], builtin_zero
);
550 /* LRP dst, tmp0, src1, src2 */
552 emit3(c
, inst
->Prev
, RC_OPCODE_LRP
, 0,
554 srcreg(RC_FILE_TEMPORARY
, tempreg0
), inst
->U
.I
.SrcReg
[1], inst
->U
.I
.SrcReg
[2]));
556 rc_remove_instruction(inst
);
560 * For use with radeonLocalTransform, this transforms non-native ALU
561 * instructions of the r300 up to r500 vertex engine.
563 int r300_transform_vertex_alu(
564 struct radeon_compiler
* c
,
565 struct rc_instruction
* inst
,
568 switch(inst
->U
.I
.Opcode
) {
569 case RC_OPCODE_ABS
: transform_r300_vertex_ABS(c
, inst
); return 1;
570 case RC_OPCODE_CEIL
: transform_CEIL(c
, inst
); return 1;
571 case RC_OPCODE_CMP
: transform_r300_vertex_CMP(c
, inst
); return 1;
572 case RC_OPCODE_DP3
: transform_DP3(c
, inst
); return 1;
573 case RC_OPCODE_DPH
: transform_DPH(c
, inst
); return 1;
574 case RC_OPCODE_FLR
: transform_FLR(c
, inst
); return 1;
575 case RC_OPCODE_LRP
: transform_LRP(c
, inst
); return 1;
576 case RC_OPCODE_SUB
: transform_SUB(c
, inst
); return 1;
577 case RC_OPCODE_SWZ
: transform_SWZ(c
, inst
); return 1;
578 case RC_OPCODE_XPD
: transform_XPD(c
, inst
); return 1;
584 static void sincos_constants(struct radeon_compiler
* c
, unsigned int *constants
)
586 static const float SinCosConsts
[2][4] = {
588 1.273239545, /* 4/PI */
589 -0.405284735, /* -4/(PI*PI) */
590 3.141592654, /* PI */
596 0.159154943, /* 1/(2*PI) */
597 6.283185307 /* 2*PI */
602 for(i
= 0; i
< 2; ++i
)
603 constants
[i
] = rc_constants_add_immediate_vec4(&c
->Program
.Constants
, SinCosConsts
[i
]);
607 * Approximate sin(x), where x is clamped to (-pi/2, pi/2).
609 * MUL tmp.xy, src, { 4/PI, -4/(PI^2) }
610 * MAD tmp.x, tmp.y, |src|, tmp.x
611 * MAD tmp.y, tmp.x, |tmp.x|, -tmp.x
612 * MAD dest, tmp.y, weight, tmp.x
614 static void sin_approx(
615 struct radeon_compiler
* c
, struct rc_instruction
* inst
,
616 struct rc_dst_register dst
, struct rc_src_register src
, const unsigned int* constants
)
618 unsigned int tempreg
= rc_find_free_temporary(c
);
620 emit2(c
, inst
->Prev
, RC_OPCODE_MUL
, 0, dstregtmpmask(tempreg
, RC_MASK_XY
),
621 swizzle(src
, RC_SWIZZLE_X
, RC_SWIZZLE_X
, RC_SWIZZLE_X
, RC_SWIZZLE_X
),
622 srcreg(RC_FILE_CONSTANT
, constants
[0]));
623 emit3(c
, inst
->Prev
, RC_OPCODE_MAD
, 0, dstregtmpmask(tempreg
, RC_MASK_X
),
624 swizzle(srcreg(RC_FILE_TEMPORARY
, tempreg
), RC_SWIZZLE_Y
, RC_SWIZZLE_Y
, RC_SWIZZLE_Y
, RC_SWIZZLE_Y
),
625 absolute(swizzle(src
, RC_SWIZZLE_X
, RC_SWIZZLE_X
, RC_SWIZZLE_X
, RC_SWIZZLE_X
)),
626 swizzle(srcreg(RC_FILE_TEMPORARY
, tempreg
), RC_SWIZZLE_X
, RC_SWIZZLE_X
, RC_SWIZZLE_X
, RC_SWIZZLE_X
));
627 emit3(c
, inst
->Prev
, RC_OPCODE_MAD
, 0, dstregtmpmask(tempreg
, RC_MASK_Y
),
628 swizzle(srcreg(RC_FILE_TEMPORARY
, tempreg
), RC_SWIZZLE_X
, RC_SWIZZLE_X
, RC_SWIZZLE_X
, RC_SWIZZLE_X
),
629 absolute(swizzle(srcreg(RC_FILE_TEMPORARY
, tempreg
), RC_SWIZZLE_X
, RC_SWIZZLE_X
, RC_SWIZZLE_X
, RC_SWIZZLE_X
)),
630 negate(swizzle(srcreg(RC_FILE_TEMPORARY
, tempreg
), RC_SWIZZLE_X
, RC_SWIZZLE_X
, RC_SWIZZLE_X
, RC_SWIZZLE_X
)));
631 emit3(c
, inst
->Prev
, RC_OPCODE_MAD
, 0, dst
,
632 swizzle(srcreg(RC_FILE_TEMPORARY
, tempreg
), RC_SWIZZLE_Y
, RC_SWIZZLE_Y
, RC_SWIZZLE_Y
, RC_SWIZZLE_Y
),
633 swizzle(srcreg(RC_FILE_CONSTANT
, constants
[0]), RC_SWIZZLE_W
, RC_SWIZZLE_W
, RC_SWIZZLE_W
, RC_SWIZZLE_W
),
634 swizzle(srcreg(RC_FILE_TEMPORARY
, tempreg
), RC_SWIZZLE_X
, RC_SWIZZLE_X
, RC_SWIZZLE_X
, RC_SWIZZLE_X
));
638 * Translate the trigonometric functions COS, SIN, and SCS
639 * using only the basic instructions
640 * MOV, ADD, MUL, MAD, FRC
642 int radeonTransformTrigSimple(struct radeon_compiler
* c
,
643 struct rc_instruction
* inst
,
646 if (inst
->U
.I
.Opcode
!= RC_OPCODE_COS
&&
647 inst
->U
.I
.Opcode
!= RC_OPCODE_SIN
&&
648 inst
->U
.I
.Opcode
!= RC_OPCODE_SCS
)
651 unsigned int constants
[2];
652 unsigned int tempreg
= rc_find_free_temporary(c
);
654 sincos_constants(c
, constants
);
656 if (inst
->U
.I
.Opcode
== RC_OPCODE_COS
) {
657 /* MAD tmp.x, src, 1/(2*PI), 0.75 */
658 /* FRC tmp.x, tmp.x */
659 /* MAD tmp.z, tmp.x, 2*PI, -PI */
660 emit3(c
, inst
->Prev
, RC_OPCODE_MAD
, 0, dstregtmpmask(tempreg
, RC_MASK_W
),
661 swizzle(inst
->U
.I
.SrcReg
[0], RC_SWIZZLE_X
, RC_SWIZZLE_X
, RC_SWIZZLE_X
, RC_SWIZZLE_X
),
662 swizzle(srcreg(RC_FILE_CONSTANT
, constants
[1]), RC_SWIZZLE_Z
, RC_SWIZZLE_Z
, RC_SWIZZLE_Z
, RC_SWIZZLE_Z
),
663 swizzle(srcreg(RC_FILE_CONSTANT
, constants
[1]), RC_SWIZZLE_X
, RC_SWIZZLE_X
, RC_SWIZZLE_X
, RC_SWIZZLE_X
));
664 emit1(c
, inst
->Prev
, RC_OPCODE_FRC
, 0, dstregtmpmask(tempreg
, RC_MASK_W
),
665 swizzle(srcreg(RC_FILE_TEMPORARY
, tempreg
), RC_SWIZZLE_W
, RC_SWIZZLE_W
, RC_SWIZZLE_W
, RC_SWIZZLE_W
));
666 emit3(c
, inst
->Prev
, RC_OPCODE_MAD
, 0, dstregtmpmask(tempreg
, RC_MASK_W
),
667 swizzle(srcreg(RC_FILE_TEMPORARY
, tempreg
), RC_SWIZZLE_W
, RC_SWIZZLE_W
, RC_SWIZZLE_W
, RC_SWIZZLE_W
),
668 swizzle(srcreg(RC_FILE_CONSTANT
, constants
[1]), RC_SWIZZLE_W
, RC_SWIZZLE_W
, RC_SWIZZLE_W
, RC_SWIZZLE_W
),
669 negate(swizzle(srcreg(RC_FILE_CONSTANT
, constants
[0]), RC_SWIZZLE_Z
, RC_SWIZZLE_Z
, RC_SWIZZLE_Z
, RC_SWIZZLE_Z
)));
671 sin_approx(c
, inst
, inst
->U
.I
.DstReg
,
672 swizzle(srcreg(RC_FILE_TEMPORARY
, tempreg
), RC_SWIZZLE_W
, RC_SWIZZLE_W
, RC_SWIZZLE_W
, RC_SWIZZLE_W
),
674 } else if (inst
->U
.I
.Opcode
== RC_OPCODE_SIN
) {
675 emit3(c
, inst
->Prev
, RC_OPCODE_MAD
, 0, dstregtmpmask(tempreg
, RC_MASK_W
),
676 swizzle(inst
->U
.I
.SrcReg
[0], RC_SWIZZLE_X
, RC_SWIZZLE_X
, RC_SWIZZLE_X
, RC_SWIZZLE_X
),
677 swizzle(srcreg(RC_FILE_CONSTANT
, constants
[1]), RC_SWIZZLE_Z
, RC_SWIZZLE_Z
, RC_SWIZZLE_Z
, RC_SWIZZLE_Z
),
678 swizzle(srcreg(RC_FILE_CONSTANT
, constants
[1]), RC_SWIZZLE_Y
, RC_SWIZZLE_Y
, RC_SWIZZLE_Y
, RC_SWIZZLE_Y
));
679 emit1(c
, inst
->Prev
, RC_OPCODE_FRC
, 0, dstregtmpmask(tempreg
, RC_MASK_W
),
680 swizzle(srcreg(RC_FILE_TEMPORARY
, tempreg
), RC_SWIZZLE_W
, RC_SWIZZLE_W
, RC_SWIZZLE_W
, RC_SWIZZLE_W
));
681 emit3(c
, inst
->Prev
, RC_OPCODE_MAD
, 0, dstregtmpmask(tempreg
, RC_MASK_W
),
682 swizzle(srcreg(RC_FILE_TEMPORARY
, tempreg
), RC_SWIZZLE_W
, RC_SWIZZLE_W
, RC_SWIZZLE_W
, RC_SWIZZLE_W
),
683 swizzle(srcreg(RC_FILE_CONSTANT
, constants
[1]), RC_SWIZZLE_W
, RC_SWIZZLE_W
, RC_SWIZZLE_W
, RC_SWIZZLE_W
),
684 negate(swizzle(srcreg(RC_FILE_CONSTANT
, constants
[0]), RC_SWIZZLE_Z
, RC_SWIZZLE_Z
, RC_SWIZZLE_Z
, RC_SWIZZLE_Z
)));
686 sin_approx(c
, inst
, inst
->U
.I
.DstReg
,
687 swizzle(srcreg(RC_FILE_TEMPORARY
, tempreg
), RC_SWIZZLE_W
, RC_SWIZZLE_W
, RC_SWIZZLE_W
, RC_SWIZZLE_W
),
690 emit3(c
, inst
->Prev
, RC_OPCODE_MAD
, 0, dstregtmpmask(tempreg
, RC_MASK_XY
),
691 swizzle(inst
->U
.I
.SrcReg
[0], RC_SWIZZLE_X
, RC_SWIZZLE_X
, RC_SWIZZLE_X
, RC_SWIZZLE_X
),
692 swizzle(srcreg(RC_FILE_CONSTANT
, constants
[1]), RC_SWIZZLE_Z
, RC_SWIZZLE_Z
, RC_SWIZZLE_Z
, RC_SWIZZLE_Z
),
693 swizzle(srcreg(RC_FILE_CONSTANT
, constants
[1]), RC_SWIZZLE_X
, RC_SWIZZLE_Y
, RC_SWIZZLE_Z
, RC_SWIZZLE_W
));
694 emit1(c
, inst
->Prev
, RC_OPCODE_FRC
, 0, dstregtmpmask(tempreg
, RC_MASK_XY
),
695 srcreg(RC_FILE_TEMPORARY
, tempreg
));
696 emit3(c
, inst
->Prev
, RC_OPCODE_MAD
, 0, dstregtmpmask(tempreg
, RC_MASK_XY
),
697 srcreg(RC_FILE_TEMPORARY
, tempreg
),
698 swizzle(srcreg(RC_FILE_CONSTANT
, constants
[1]), RC_SWIZZLE_W
, RC_SWIZZLE_W
, RC_SWIZZLE_W
, RC_SWIZZLE_W
),
699 negate(swizzle(srcreg(RC_FILE_CONSTANT
, constants
[0]), RC_SWIZZLE_Z
, RC_SWIZZLE_Z
, RC_SWIZZLE_Z
, RC_SWIZZLE_Z
)));
701 struct rc_dst_register dst
= inst
->U
.I
.DstReg
;
703 dst
.WriteMask
= inst
->U
.I
.DstReg
.WriteMask
& RC_MASK_X
;
704 sin_approx(c
, inst
, dst
,
705 swizzle(srcreg(RC_FILE_TEMPORARY
, tempreg
), RC_SWIZZLE_X
, RC_SWIZZLE_X
, RC_SWIZZLE_X
, RC_SWIZZLE_X
),
708 dst
.WriteMask
= inst
->U
.I
.DstReg
.WriteMask
& RC_MASK_Y
;
709 sin_approx(c
, inst
, dst
,
710 swizzle(srcreg(RC_FILE_TEMPORARY
, tempreg
), RC_SWIZZLE_Y
, RC_SWIZZLE_Y
, RC_SWIZZLE_Y
, RC_SWIZZLE_Y
),
714 rc_remove_instruction(inst
);
721 * Transform the trigonometric functions COS, SIN, and SCS
722 * to include pre-scaling by 1/(2*PI) and taking the fractional
723 * part, so that the input to COS and SIN is always in the range [0,1).
724 * SCS is replaced by one COS and one SIN instruction.
726 * @warning This transformation implicitly changes the semantics of SIN and COS!
728 int radeonTransformTrigScale(struct radeon_compiler
* c
,
729 struct rc_instruction
* inst
,
732 if (inst
->U
.I
.Opcode
!= RC_OPCODE_COS
&&
733 inst
->U
.I
.Opcode
!= RC_OPCODE_SIN
&&
734 inst
->U
.I
.Opcode
!= RC_OPCODE_SCS
)
737 static const float RCP_2PI
= 0.15915494309189535;
739 unsigned int constant
;
740 unsigned int constant_swizzle
;
742 temp
= rc_find_free_temporary(c
);
743 constant
= rc_constants_add_immediate_scalar(&c
->Program
.Constants
, RCP_2PI
, &constant_swizzle
);
745 emit2(c
, inst
->Prev
, RC_OPCODE_MUL
, 0, dstregtmpmask(temp
, RC_MASK_W
),
746 swizzle(inst
->U
.I
.SrcReg
[0], RC_SWIZZLE_X
, RC_SWIZZLE_X
, RC_SWIZZLE_X
, RC_SWIZZLE_X
),
747 srcregswz(RC_FILE_CONSTANT
, constant
, constant_swizzle
));
748 emit1(c
, inst
->Prev
, RC_OPCODE_FRC
, 0, dstregtmpmask(temp
, RC_MASK_W
),
749 srcreg(RC_FILE_TEMPORARY
, temp
));
751 if (inst
->U
.I
.Opcode
== RC_OPCODE_COS
) {
752 emit1(c
, inst
->Prev
, RC_OPCODE_COS
, inst
->U
.I
.SaturateMode
, inst
->U
.I
.DstReg
,
753 srcregswz(RC_FILE_TEMPORARY
, temp
, RC_SWIZZLE_WWWW
));
754 } else if (inst
->U
.I
.Opcode
== RC_OPCODE_SIN
) {
755 emit1(c
, inst
->Prev
, RC_OPCODE_SIN
, inst
->U
.I
.SaturateMode
,
756 inst
->U
.I
.DstReg
, srcregswz(RC_FILE_TEMPORARY
, temp
, RC_SWIZZLE_WWWW
));
757 } else if (inst
->U
.I
.Opcode
== RC_OPCODE_SCS
) {
758 struct rc_dst_register moddst
= inst
->U
.I
.DstReg
;
760 if (inst
->U
.I
.DstReg
.WriteMask
& RC_MASK_X
) {
761 moddst
.WriteMask
= RC_MASK_X
;
762 emit1(c
, inst
->Prev
, RC_OPCODE_COS
, inst
->U
.I
.SaturateMode
, moddst
,
763 srcregswz(RC_FILE_TEMPORARY
, temp
, RC_SWIZZLE_WWWW
));
765 if (inst
->U
.I
.DstReg
.WriteMask
& RC_MASK_Y
) {
766 moddst
.WriteMask
= RC_MASK_Y
;
767 emit1(c
, inst
->Prev
, RC_OPCODE_SIN
, inst
->U
.I
.SaturateMode
, moddst
,
768 srcregswz(RC_FILE_TEMPORARY
, temp
, RC_SWIZZLE_WWWW
));
772 rc_remove_instruction(inst
);
778 * Rewrite DDX/DDY instructions to properly work with r5xx shaders.
779 * The r5xx MDH/MDV instruction provides per-quad partial derivatives.
780 * It takes the form A*B+C. A and C are set by setting src0. B should be -1.
782 * @warning This explicitly changes the form of DDX and DDY!
785 int radeonTransformDeriv(struct radeon_compiler
* c
,
786 struct rc_instruction
* inst
,
789 if (inst
->U
.I
.Opcode
!= RC_OPCODE_DDX
&& inst
->U
.I
.Opcode
!= RC_OPCODE_DDY
)
792 inst
->U
.I
.SrcReg
[1].Swizzle
= RC_MAKE_SWIZZLE(RC_SWIZZLE_ONE
, RC_SWIZZLE_ONE
, RC_SWIZZLE_ONE
, RC_SWIZZLE_ONE
);
793 inst
->U
.I
.SrcReg
[1].Negate
= RC_MASK_XYZW
;