• Home
  • History
  • Annotate
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1  /**************************************************************************
2   *
3   * Copyright 2008 Tungsten Graphics, Inc., Cedar Park, Texas.
4   * All Rights Reserved.
5   *
6   * Permission is hereby granted, free of charge, to any person obtaining a
7   * 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, sub license, 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:
13   *
14   * The above copyright notice and this permission notice (including the
15   * next paragraph) shall be included in all copies or substantial portions
16   * of the Software.
17   *
18   * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
19   * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
20   * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
21   * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
22   * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
23   * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
24   * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
25   *
26   **************************************************************************/
27  
28  /**
29   * TGSI program transformation utility.
30   *
31   * Authors:  Brian Paul
32   */
33  
34  #include "util/u_debug.h"
35  
36  #include "tgsi_transform.h"
37  
38  
39  
40  static void
emit_instruction(struct tgsi_transform_context * ctx,const struct tgsi_full_instruction * inst)41  emit_instruction(struct tgsi_transform_context *ctx,
42                   const struct tgsi_full_instruction *inst)
43  {
44     uint ti = ctx->ti;
45  
46     ti += tgsi_build_full_instruction(inst,
47                                       ctx->tokens_out + ti,
48                                       ctx->header,
49                                       ctx->max_tokens_out - ti);
50     ctx->ti = ti;
51  }
52  
53  
54  static void
emit_declaration(struct tgsi_transform_context * ctx,const struct tgsi_full_declaration * decl)55  emit_declaration(struct tgsi_transform_context *ctx,
56                   const struct tgsi_full_declaration *decl)
57  {
58     uint ti = ctx->ti;
59  
60     ti += tgsi_build_full_declaration(decl,
61                                       ctx->tokens_out + ti,
62                                       ctx->header,
63                                       ctx->max_tokens_out - ti);
64     ctx->ti = ti;
65  }
66  
67  
68  static void
emit_immediate(struct tgsi_transform_context * ctx,const struct tgsi_full_immediate * imm)69  emit_immediate(struct tgsi_transform_context *ctx,
70                 const struct tgsi_full_immediate *imm)
71  {
72     uint ti = ctx->ti;
73  
74     ti += tgsi_build_full_immediate(imm,
75                                     ctx->tokens_out + ti,
76                                     ctx->header,
77                                     ctx->max_tokens_out - ti);
78     ctx->ti = ti;
79  }
80  
81  
82  static void
emit_property(struct tgsi_transform_context * ctx,const struct tgsi_full_property * prop)83  emit_property(struct tgsi_transform_context *ctx,
84                const struct tgsi_full_property *prop)
85  {
86     uint ti = ctx->ti;
87  
88     ti += tgsi_build_full_property(prop,
89                                    ctx->tokens_out + ti,
90                                    ctx->header,
91                                    ctx->max_tokens_out - ti);
92     ctx->ti = ti;
93  }
94  
95  
96  /**
97   * Apply user-defined transformations to the input shader to produce
98   * the output shader.
99   * For example, a register search-and-replace operation could be applied
100   * by defining a transform_instruction() callback that examined and changed
101   * the instruction src/dest regs.
102   *
103   * \return number of tokens emitted
104   */
105  int
tgsi_transform_shader(const struct tgsi_token * tokens_in,struct tgsi_token * tokens_out,uint max_tokens_out,struct tgsi_transform_context * ctx)106  tgsi_transform_shader(const struct tgsi_token *tokens_in,
107                        struct tgsi_token *tokens_out,
108                        uint max_tokens_out,
109                        struct tgsi_transform_context *ctx)
110  {
111     uint procType;
112  
113     /* input shader */
114     struct tgsi_parse_context parse;
115  
116     /* output shader */
117     struct tgsi_processor *processor;
118  
119  
120     /**
121      ** callback context init
122      **/
123     ctx->emit_instruction = emit_instruction;
124     ctx->emit_declaration = emit_declaration;
125     ctx->emit_immediate = emit_immediate;
126     ctx->emit_property = emit_property;
127     ctx->tokens_out = tokens_out;
128     ctx->max_tokens_out = max_tokens_out;
129  
130  
131     /**
132      ** Setup to begin parsing input shader
133      **/
134     if (tgsi_parse_init( &parse, tokens_in ) != TGSI_PARSE_OK) {
135        debug_printf("tgsi_parse_init() failed in tgsi_transform_shader()!\n");
136        return -1;
137     }
138     procType = parse.FullHeader.Processor.Processor;
139     assert(procType == TGSI_PROCESSOR_FRAGMENT ||
140            procType == TGSI_PROCESSOR_VERTEX ||
141            procType == TGSI_PROCESSOR_GEOMETRY);
142  
143  
144     /**
145      **  Setup output shader
146      **/
147     ctx->header = (struct tgsi_header *)tokens_out;
148     *ctx->header = tgsi_build_header();
149  
150     processor = (struct tgsi_processor *) (tokens_out + 1);
151     *processor = tgsi_build_processor( procType, ctx->header );
152  
153     ctx->ti = 2;
154  
155  
156     /**
157      ** Loop over incoming program tokens/instructions
158      */
159     while( !tgsi_parse_end_of_tokens( &parse ) ) {
160  
161        tgsi_parse_token( &parse );
162  
163        switch( parse.FullToken.Token.Type ) {
164        case TGSI_TOKEN_TYPE_INSTRUCTION:
165           {
166              struct tgsi_full_instruction *fullinst
167                 = &parse.FullToken.FullInstruction;
168  
169              if (ctx->transform_instruction)
170                 ctx->transform_instruction(ctx, fullinst);
171              else
172                 ctx->emit_instruction(ctx, fullinst);
173           }
174           break;
175  
176        case TGSI_TOKEN_TYPE_DECLARATION:
177           {
178              struct tgsi_full_declaration *fulldecl
179                 = &parse.FullToken.FullDeclaration;
180  
181              if (ctx->transform_declaration)
182                 ctx->transform_declaration(ctx, fulldecl);
183              else
184                 ctx->emit_declaration(ctx, fulldecl);
185           }
186           break;
187  
188        case TGSI_TOKEN_TYPE_IMMEDIATE:
189           {
190              struct tgsi_full_immediate *fullimm
191                 = &parse.FullToken.FullImmediate;
192  
193              if (ctx->transform_immediate)
194                 ctx->transform_immediate(ctx, fullimm);
195              else
196                 ctx->emit_immediate(ctx, fullimm);
197           }
198           break;
199        case TGSI_TOKEN_TYPE_PROPERTY:
200           {
201              struct tgsi_full_property *fullprop
202                 = &parse.FullToken.FullProperty;
203  
204              if (ctx->transform_property)
205                 ctx->transform_property(ctx, fullprop);
206              else
207                 ctx->emit_property(ctx, fullprop);
208           }
209           break;
210  
211        default:
212           assert( 0 );
213        }
214     }
215  
216     if (ctx->epilog) {
217        ctx->epilog(ctx);
218     }
219  
220     tgsi_parse_free (&parse);
221  
222     return ctx->ti;
223  }
224  
225  
226  #include "tgsi_text.h"
227  
228  extern int tgsi_transform_foo( struct tgsi_token *tokens_out,
229                                 uint max_tokens_out );
230  
231  /* This function exists only so that tgsi_text_translate() doesn't get
232   * magic-ed out of the libtgsi.a archive by the build system.  Don't
233   * remove unless you know this has been fixed - check on mingw/scons
234   * builds as well.
235   */
236  int
tgsi_transform_foo(struct tgsi_token * tokens_out,uint max_tokens_out)237  tgsi_transform_foo( struct tgsi_token *tokens_out,
238                      uint max_tokens_out )
239  {
240     const char *text =
241        "FRAG\n"
242        "DCL IN[0], COLOR, CONSTANT\n"
243        "DCL OUT[0], COLOR\n"
244        "  0: MOV OUT[0], IN[0]\n"
245        "  1: END";
246  
247     return tgsi_text_translate( text,
248                                 tokens_out,
249                                 max_tokens_out );
250  }
251