tgsi_parse.c revision a5f44cc8c2ce0916809ce5da5a2490ad000ef099
1/************************************************************************** 2 * 3 * Copyright 2007 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#include "util/u_debug.h" 29#include "pipe/p_shader_tokens.h" 30#include "tgsi_parse.h" 31#include "util/u_memory.h" 32 33unsigned 34tgsi_parse_init( 35 struct tgsi_parse_context *ctx, 36 const struct tgsi_token *tokens ) 37{ 38 ctx->FullHeader.Header = *(struct tgsi_header *) &tokens[0]; 39 if( ctx->FullHeader.Header.HeaderSize >= 2 ) { 40 ctx->FullHeader.Processor = *(struct tgsi_processor *) &tokens[1]; 41 } 42 else { 43 return TGSI_PARSE_ERROR; 44 } 45 46 ctx->Tokens = tokens; 47 ctx->Position = ctx->FullHeader.Header.HeaderSize; 48 49 return TGSI_PARSE_OK; 50} 51 52void 53tgsi_parse_free( 54 struct tgsi_parse_context *ctx ) 55{ 56} 57 58boolean 59tgsi_parse_end_of_tokens( 60 struct tgsi_parse_context *ctx ) 61{ 62 return ctx->Position >= 63 ctx->FullHeader.Header.HeaderSize + ctx->FullHeader.Header.BodySize; 64} 65 66 67/** 68 * This function is used to avoid and work-around type punning/aliasing 69 * warnings. The warnings seem harmless on x86 but on PPC they cause 70 * real failures. 71 */ 72static INLINE void 73copy_token(void *dst, const void *src) 74{ 75 memcpy(dst, src, 4); 76} 77 78 79/** 80 * Get next 4-byte token, return it at address specified by 'token' 81 */ 82static void 83next_token( 84 struct tgsi_parse_context *ctx, 85 void *token ) 86{ 87 assert( !tgsi_parse_end_of_tokens( ctx ) ); 88 copy_token(token, &ctx->Tokens[ctx->Position]); 89 ctx->Position++; 90} 91 92 93void 94tgsi_parse_token( 95 struct tgsi_parse_context *ctx ) 96{ 97 struct tgsi_token token; 98 unsigned i; 99 100 next_token( ctx, &token ); 101 102 switch( token.Type ) { 103 case TGSI_TOKEN_TYPE_DECLARATION: 104 { 105 struct tgsi_full_declaration *decl = &ctx->FullToken.FullDeclaration; 106 107 memset(decl, 0, sizeof *decl); 108 copy_token(&decl->Declaration, &token); 109 110 next_token( ctx, &decl->Range ); 111 112 if (decl->Declaration.Dimension) { 113 next_token(ctx, &decl->Dim); 114 } 115 116 if( decl->Declaration.Semantic ) { 117 next_token( ctx, &decl->Semantic ); 118 } 119 120 if (decl->Declaration.File == TGSI_FILE_IMMEDIATE_ARRAY) { 121 unsigned i, j; 122 decl->ImmediateData.u = (union tgsi_immediate_data*) 123 &ctx->Tokens[ctx->Position]; 124 for (i = 0; i <= decl->Range.Last; ++i) { 125 for (j = 0; j < 4; ++j) { 126 ctx->Position++; 127 } 128 } 129 } 130 131 if (decl->Declaration.File == TGSI_FILE_RESOURCE) { 132 next_token(ctx, &decl->Resource); 133 } 134 135 if (decl->Declaration.File == TGSI_FILE_SAMPLER_VIEW) { 136 next_token(ctx, &decl->SamplerView); 137 } 138 139 break; 140 } 141 142 case TGSI_TOKEN_TYPE_IMMEDIATE: 143 { 144 struct tgsi_full_immediate *imm = &ctx->FullToken.FullImmediate; 145 uint imm_count; 146 147 memset(imm, 0, sizeof *imm); 148 copy_token(&imm->Immediate, &token); 149 150 imm_count = imm->Immediate.NrTokens - 1; 151 152 switch (imm->Immediate.DataType) { 153 case TGSI_IMM_FLOAT32: 154 for (i = 0; i < imm_count; i++) { 155 next_token(ctx, &imm->u[i].Float); 156 } 157 break; 158 159 case TGSI_IMM_UINT32: 160 for (i = 0; i < imm_count; i++) { 161 next_token(ctx, &imm->u[i].Uint); 162 } 163 break; 164 165 case TGSI_IMM_INT32: 166 for (i = 0; i < imm_count; i++) { 167 next_token(ctx, &imm->u[i].Int); 168 } 169 break; 170 171 default: 172 assert( 0 ); 173 } 174 175 break; 176 } 177 178 case TGSI_TOKEN_TYPE_INSTRUCTION: 179 { 180 struct tgsi_full_instruction *inst = &ctx->FullToken.FullInstruction; 181 182 memset(inst, 0, sizeof *inst); 183 copy_token(&inst->Instruction, &token); 184 185 if (inst->Instruction.Predicate) { 186 next_token(ctx, &inst->Predicate); 187 } 188 189 if (inst->Instruction.Label) { 190 next_token( ctx, &inst->Label); 191 } 192 193 if (inst->Instruction.Texture) { 194 next_token( ctx, &inst->Texture); 195 for( i = 0; i < inst->Texture.NumOffsets; i++ ) { 196 next_token( ctx, &inst->TexOffsets[i] ); 197 } 198 } 199 200 assert( inst->Instruction.NumDstRegs <= TGSI_FULL_MAX_DST_REGISTERS ); 201 202 for( i = 0; i < inst->Instruction.NumDstRegs; i++ ) { 203 204 next_token( ctx, &inst->Dst[i].Register ); 205 206 if( inst->Dst[i].Register.Indirect ) { 207 next_token( ctx, &inst->Dst[i].Indirect ); 208 209 /* 210 * No support for indirect or multi-dimensional addressing. 211 */ 212 assert( !inst->Dst[i].Indirect.Dimension ); 213 assert( !inst->Dst[i].Indirect.Indirect ); 214 } 215 if( inst->Dst[i].Register.Dimension ) { 216 next_token( ctx, &inst->Dst[i].Dimension ); 217 218 /* 219 * No support for multi-dimensional addressing. 220 */ 221 assert( !inst->Dst[i].Dimension.Dimension ); 222 223 if( inst->Dst[i].Dimension.Indirect ) { 224 next_token( ctx, &inst->Dst[i].DimIndirect ); 225 226 /* 227 * No support for indirect or multi-dimensional addressing. 228 */ 229 assert( !inst->Dst[i].Indirect.Indirect ); 230 assert( !inst->Dst[i].Indirect.Dimension ); 231 } 232 } 233 } 234 235 assert( inst->Instruction.NumSrcRegs <= TGSI_FULL_MAX_SRC_REGISTERS ); 236 237 for( i = 0; i < inst->Instruction.NumSrcRegs; i++ ) { 238 239 next_token( ctx, &inst->Src[i].Register ); 240 241 if( inst->Src[i].Register.Indirect ) { 242 next_token( ctx, &inst->Src[i].Indirect ); 243 244 /* 245 * No support for indirect or multi-dimensional addressing. 246 */ 247 assert( !inst->Src[i].Indirect.Indirect ); 248 assert( !inst->Src[i].Indirect.Dimension ); 249 } 250 251 if( inst->Src[i].Register.Dimension ) { 252 next_token( ctx, &inst->Src[i].Dimension ); 253 254 /* 255 * No support for multi-dimensional addressing. 256 */ 257 assert( !inst->Src[i].Dimension.Dimension ); 258 259 if( inst->Src[i].Dimension.Indirect ) { 260 next_token( ctx, &inst->Src[i].DimIndirect ); 261 262 /* 263 * No support for indirect or multi-dimensional addressing. 264 */ 265 assert( !inst->Src[i].Indirect.Indirect ); 266 assert( !inst->Src[i].Indirect.Dimension ); 267 } 268 } 269 } 270 271 break; 272 } 273 274 case TGSI_TOKEN_TYPE_PROPERTY: 275 { 276 struct tgsi_full_property *prop = &ctx->FullToken.FullProperty; 277 uint prop_count; 278 279 memset(prop, 0, sizeof *prop); 280 copy_token(&prop->Property, &token); 281 282 prop_count = prop->Property.NrTokens - 1; 283 for (i = 0; i < prop_count; i++) { 284 next_token(ctx, &prop->u[i]); 285 } 286 287 break; 288 } 289 290 default: 291 assert( 0 ); 292 } 293} 294 295 296 297 298/** 299 * Make a new copy of a token array. 300 */ 301struct tgsi_token * 302tgsi_dup_tokens(const struct tgsi_token *tokens) 303{ 304 unsigned n = tgsi_num_tokens(tokens); 305 unsigned bytes = n * sizeof(struct tgsi_token); 306 struct tgsi_token *new_tokens = (struct tgsi_token *) MALLOC(bytes); 307 if (new_tokens) 308 memcpy(new_tokens, tokens, bytes); 309 return new_tokens; 310} 311 312 313/** 314 * Allocate memory for num_tokens tokens. 315 */ 316struct tgsi_token * 317tgsi_alloc_tokens(unsigned num_tokens) 318{ 319 unsigned bytes = num_tokens * sizeof(struct tgsi_token); 320 return (struct tgsi_token *) MALLOC(bytes); 321} 322 323 324void 325tgsi_dump_tokens(const struct tgsi_token *tokens) 326{ 327 const unsigned *dwords = (const unsigned *)tokens; 328 int nr = tgsi_num_tokens(tokens); 329 int i; 330 331 assert(sizeof(*tokens) == sizeof(unsigned)); 332 333 debug_printf("const unsigned tokens[%d] = {\n", nr); 334 for (i = 0; i < nr; i++) 335 debug_printf("0x%08x,\n", dwords[i]); 336 debug_printf("};\n"); 337} 338