← Back to branch summary

~ubuntu-branches/ubuntu/precise/mesa/precise-updates

« back to all changes in this revision

Viewing changes to src/gallium/drivers/r300/compiler/r3xx_fragprog.c

  • Committer: Package Import Robot
  • Author(s): Robert Hooker
  • Date: 2012-02-02 12:05:48 UTC
  • mfrom: (1.7.1) (3.3.27 sid)
  • Revision ID: package-import@ubuntu.com-20120202120548-nvkma85jq0h4coix
Tags: 8.0~rc2-0ubuntu4
Drop drisearchdir handling, it is no longer needed with multiarch
and dri-alternates being removed.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/gallium/drivers/r300/compiler/r3xx_fragprog.c
 
1
/*
 
2
 * Copyright 2009 Nicolai Hähnle <nhaehnle@gmail.com>
 
3
 *
 
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
 * on the rights to use, copy, modify, merge, publish, distribute, sub
 
8
 * license, and/or sell copies of the Software, and to permit persons to whom
 
9
 * the Software is furnished to do so, subject to the following conditions:
 
10
 *
 
11
 * The above copyright notice and this permission notice (including the next
 
12
 * paragraph) shall be included in all copies or substantial portions of the
 
13
 * Software.
 
14
 *
 
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 NON-INFRINGEMENT. IN NO EVENT SHALL
 
18
 * THE AUTHOR(S) AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
 
19
 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
 
20
 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
 
21
 * USE OR OTHER DEALINGS IN THE SOFTWARE. */
 
22
 
 
23
#include "radeon_compiler.h"
 
24
 
 
25
#include <stdio.h>
 
26
 
 
27
#include "radeon_compiler_util.h"
 
28
#include "radeon_dataflow.h"
 
29
#include "radeon_emulate_branches.h"
 
30
#include "radeon_emulate_loops.h"
 
31
#include "radeon_program_alu.h"
 
32
#include "radeon_program_tex.h"
 
33
#include "radeon_rename_regs.h"
 
34
#include "radeon_remove_constants.h"
 
35
#include "r300_fragprog.h"
 
36
#include "r300_fragprog_swizzle.h"
 
37
#include "r500_fragprog.h"
 
38
 
 
39
 
 
40
static void dataflow_outputs_mark_use(void * userdata, void * data,
 
41
                void (*callback)(void *, unsigned int, unsigned int))
 
42
{
 
43
        struct r300_fragment_program_compiler * c = userdata;
 
44
        callback(data, c->OutputColor[0], RC_MASK_XYZW);
 
45
        callback(data, c->OutputColor[1], RC_MASK_XYZW);
 
46
        callback(data, c->OutputColor[2], RC_MASK_XYZW);
 
47
        callback(data, c->OutputColor[3], RC_MASK_XYZW);
 
48
        callback(data, c->OutputDepth, RC_MASK_W);
 
49
}
 
50
 
 
51
static void rc_rewrite_depth_out(struct radeon_compiler *cc, void *user)
 
52
{
 
53
        struct r300_fragment_program_compiler *c = (struct r300_fragment_program_compiler*)cc;
 
54
        struct rc_instruction *rci;
 
55
 
 
56
        for (rci = c->Base.Program.Instructions.Next; rci != &c->Base.Program.Instructions; rci = rci->Next) {
 
57
                struct rc_sub_instruction * inst = &rci->U.I;
 
58
                unsigned i;
 
59
                const struct rc_opcode_info *info = rc_get_opcode_info(inst->Opcode);
 
60
 
 
61
                if (inst->DstReg.File != RC_FILE_OUTPUT || inst->DstReg.Index != c->OutputDepth)
 
62
                        continue;
 
63
 
 
64
                if (inst->DstReg.WriteMask & RC_MASK_Z) {
 
65
                        inst->DstReg.WriteMask = RC_MASK_W;
 
66
                } else {
 
67
                        inst->DstReg.WriteMask = 0;
 
68
                        continue;
 
69
                }
 
70
 
 
71
                if (!info->IsComponentwise) {
 
72
                        continue;
 
73
                }
 
74
 
 
75
                for (i = 0; i < info->NumSrcRegs; i++) {
 
76
                        inst->SrcReg[i] = lmul_swizzle(RC_SWIZZLE_ZZZZ, inst->SrcReg[i]);
 
77
                }
 
78
        }
 
79
}
 
80
 
 
81
static int radeon_saturate_output(
 
82
                struct radeon_compiler * c,
 
83
                struct rc_instruction * inst,
 
84
                void* data)
 
85
{
 
86
        const struct rc_opcode_info *info = rc_get_opcode_info(inst->U.I.Opcode);
 
87
 
 
88
        if (!info->HasDstReg || inst->U.I.DstReg.File != RC_FILE_OUTPUT)
 
89
                return 0;
 
90
 
 
91
        inst->U.I.SaturateMode = RC_SATURATE_ZERO_ONE;
 
92
        return 1;
 
93
}
 
94
 
 
95
void r3xx_compile_fragment_program(struct r300_fragment_program_compiler* c)
 
96
{
 
97
        int is_r500 = c->Base.is_r500;
 
98
        int opt = !c->Base.disable_optimizations;
 
99
        int sat_out = c->state.frag_clamp;
 
100
 
 
101
        /* Lists of instruction transformations. */
 
102
        struct radeon_program_transformation saturate_output[] = {
 
103
                { &radeon_saturate_output, c },
 
104
                { 0, 0 }
 
105
        };
 
106
 
 
107
        struct radeon_program_transformation rewrite_tex[] = {
 
108
                { &radeonTransformTEX, c },
 
109
                { 0, 0 }
 
110
        };
 
111
 
 
112
        struct radeon_program_transformation rewrite_if[] = {
 
113
                { &r500_transform_IF, 0 },
 
114
                {0, 0}
 
115
        };
 
116
 
 
117
        struct radeon_program_transformation native_rewrite_r500[] = {
 
118
                { &radeonTransformALU, 0 },
 
119
                { &radeonTransformDeriv, 0 },
 
120
                { &radeonTransformTrigScale, 0 },
 
121
                { 0, 0 }
 
122
        };
 
123
 
 
124
        struct radeon_program_transformation native_rewrite_r300[] = {
 
125
                { &radeonTransformALU, 0 },
 
126
                { &r300_transform_trig_simple, 0 },
 
127
                { 0, 0 }
 
128
        };
 
129
 
 
130
        /* List of compiler passes. */
 
131
        struct radeon_compiler_pass fs_list[] = {
 
132
                /* NAME                         DUMP PREDICATE  FUNCTION                        PARAM */
 
133
                {"rewrite depth out",           1, 1,           rc_rewrite_depth_out,           NULL},
 
134
                /* This transformation needs to be done before any of the IF
 
135
                 * instructions are modified. */
 
136
                {"transform KILP",              1, 1,           rc_transform_KILP,              NULL},
 
137
                {"unroll loops",                1, is_r500,     rc_unroll_loops,                NULL},
 
138
                {"transform loops",             1, !is_r500,    rc_transform_loops,             NULL},
 
139
                {"emulate branches",            1, !is_r500,    rc_emulate_branches,            NULL},
 
140
                {"saturate output writes",      1, sat_out,     rc_local_transform,             saturate_output},
 
141
                {"transform TEX",               1, 1,           rc_local_transform,             rewrite_tex},
 
142
                {"transform IF",                1, is_r500,     rc_local_transform,             rewrite_if},
 
143
                {"native rewrite",              1, is_r500,     rc_local_transform,             native_rewrite_r500},
 
144
                {"native rewrite",              1, !is_r500,    rc_local_transform,             native_rewrite_r300},
 
145
                {"deadcode",                    1, opt,         rc_dataflow_deadcode,           dataflow_outputs_mark_use},
 
146
                {"emulate loops",               1, !is_r500,    rc_emulate_loops,               NULL},
 
147
                {"register rename",             1, !is_r500 || opt,             rc_rename_regs,                 NULL},
 
148
                {"dataflow optimize",           1, opt,         rc_optimize,                    NULL},
 
149
                {"dataflow swizzles",           1, 1,           rc_dataflow_swizzles,           NULL},
 
150
                {"dead constants",              1, 1,           rc_remove_unused_constants,     &c->code->constants_remap_table},
 
151
                {"pair translate",              1, 1,           rc_pair_translate,              NULL},
 
152
                {"pair scheduling",             1, 1,           rc_pair_schedule,               &opt},
 
153
                {"dead sources",                1, 1,           rc_pair_remove_dead_sources, NULL},
 
154
                {"register allocation",         1, 1,           rc_pair_regalloc,               &opt},
 
155
                {"final code validation",       0, 1,           rc_validate_final_shader,       NULL},
 
156
                {"machine code generation",     0, is_r500,     r500BuildFragmentProgramHwCode, NULL},
 
157
                {"machine code generation",     0, !is_r500,    r300BuildFragmentProgramHwCode, NULL},
 
158
                {"dump machine code",           0, is_r500  && (c->Base.Debug & RC_DBG_LOG), r500FragmentProgramDump, NULL},
 
159
                {"dump machine code",           0, !is_r500 && (c->Base.Debug & RC_DBG_LOG), r300FragmentProgramDump, NULL},
 
160
                {NULL, 0, 0, NULL, NULL}
 
161
        };
 
162
 
 
163
        c->Base.type = RC_FRAGMENT_PROGRAM;
 
164
        c->Base.SwizzleCaps = c->Base.is_r500 ? &r500_swizzle_caps : &r300_swizzle_caps;
 
165
 
 
166
        rc_run_compiler(&c->Base, fs_list);
 
167
 
 
168
        rc_constants_copy(&c->code->constants, &c->Base.Program.Constants);
 
169
}