1 /**************************************************************************
3 * Copyright 2007 VMware, Inc.
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:
14 * The above copyright notice and this permission notice (including the
15 * next paragraph) shall be included in all copies or substantial portions
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 VMWARE 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.
26 **************************************************************************/
28 #include "util/u_debug.h"
29 #include "pipe/p_shader_tokens.h"
30 #include "tgsi_parse.h"
31 #include "util/u_memory.h"
35 struct tgsi_parse_context
*ctx
,
36 const struct tgsi_token
*tokens
)
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];
43 return TGSI_PARSE_ERROR
;
47 ctx
->Position
= ctx
->FullHeader
.Header
.HeaderSize
;
54 struct tgsi_parse_context
*ctx
)
59 tgsi_parse_end_of_tokens(
60 struct tgsi_parse_context
*ctx
)
62 return ctx
->Position
>=
63 ctx
->FullHeader
.Header
.HeaderSize
+ ctx
->FullHeader
.Header
.BodySize
;
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
73 copy_token(void *dst
, const void *src
)
80 * Get next 4-byte token, return it at address specified by 'token'
84 struct tgsi_parse_context
*ctx
,
87 assert( !tgsi_parse_end_of_tokens( ctx
) );
88 copy_token(token
, &ctx
->Tokens
[ctx
->Position
]);
95 struct tgsi_parse_context
*ctx
)
97 struct tgsi_token token
;
100 next_token( ctx
, &token
);
102 switch( token
.Type
) {
103 case TGSI_TOKEN_TYPE_DECLARATION
:
105 struct tgsi_full_declaration
*decl
= &ctx
->FullToken
.FullDeclaration
;
107 memset(decl
, 0, sizeof *decl
);
108 copy_token(&decl
->Declaration
, &token
);
110 next_token( ctx
, &decl
->Range
);
112 if (decl
->Declaration
.Dimension
) {
113 next_token(ctx
, &decl
->Dim
);
116 if (decl
->Declaration
.Interpolate
) {
117 next_token( ctx
, &decl
->Interp
);
120 if (decl
->Declaration
.Semantic
) {
121 next_token( ctx
, &decl
->Semantic
);
124 if (decl
->Declaration
.File
== TGSI_FILE_IMAGE
) {
125 next_token(ctx
, &decl
->Image
);
128 if (decl
->Declaration
.File
== TGSI_FILE_SAMPLER_VIEW
) {
129 next_token(ctx
, &decl
->SamplerView
);
132 if (decl
->Declaration
.Array
) {
133 next_token(ctx
, &decl
->Array
);
139 case TGSI_TOKEN_TYPE_IMMEDIATE
:
141 struct tgsi_full_immediate
*imm
= &ctx
->FullToken
.FullImmediate
;
144 memset(imm
, 0, sizeof *imm
);
145 copy_token(&imm
->Immediate
, &token
);
147 imm_count
= imm
->Immediate
.NrTokens
- 1;
149 switch (imm
->Immediate
.DataType
) {
150 case TGSI_IMM_FLOAT32
:
151 case TGSI_IMM_FLOAT64
:
152 for (i
= 0; i
< imm_count
; i
++) {
153 next_token(ctx
, &imm
->u
[i
].Float
);
157 case TGSI_IMM_UINT32
:
158 case TGSI_IMM_UINT64
:
159 for (i
= 0; i
< imm_count
; i
++) {
160 next_token(ctx
, &imm
->u
[i
].Uint
);
166 for (i
= 0; i
< imm_count
; i
++) {
167 next_token(ctx
, &imm
->u
[i
].Int
);
178 case TGSI_TOKEN_TYPE_INSTRUCTION
:
180 struct tgsi_full_instruction
*inst
= &ctx
->FullToken
.FullInstruction
;
182 memset(inst
, 0, sizeof *inst
);
183 copy_token(&inst
->Instruction
, &token
);
185 if (inst
->Instruction
.Predicate
) {
186 next_token(ctx
, &inst
->Predicate
);
189 if (inst
->Instruction
.Label
) {
190 next_token( ctx
, &inst
->Label
);
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
] );
200 if (inst
->Instruction
.Memory
) {
201 next_token(ctx
, &inst
->Memory
);
204 assert( inst
->Instruction
.NumDstRegs
<= TGSI_FULL_MAX_DST_REGISTERS
);
206 for (i
= 0; i
< inst
->Instruction
.NumDstRegs
; i
++) {
208 next_token( ctx
, &inst
->Dst
[i
].Register
);
210 if (inst
->Dst
[i
].Register
.Indirect
)
211 next_token( ctx
, &inst
->Dst
[i
].Indirect
);
213 if (inst
->Dst
[i
].Register
.Dimension
) {
214 next_token( ctx
, &inst
->Dst
[i
].Dimension
);
217 * No support for multi-dimensional addressing.
219 assert( !inst
->Dst
[i
].Dimension
.Dimension
);
221 if (inst
->Dst
[i
].Dimension
.Indirect
)
222 next_token( ctx
, &inst
->Dst
[i
].DimIndirect
);
226 assert( inst
->Instruction
.NumSrcRegs
<= TGSI_FULL_MAX_SRC_REGISTERS
);
228 for (i
= 0; i
< inst
->Instruction
.NumSrcRegs
; i
++) {
230 next_token( ctx
, &inst
->Src
[i
].Register
);
232 if (inst
->Src
[i
].Register
.Indirect
)
233 next_token( ctx
, &inst
->Src
[i
].Indirect
);
235 if (inst
->Src
[i
].Register
.Dimension
) {
236 next_token( ctx
, &inst
->Src
[i
].Dimension
);
239 * No support for multi-dimensional addressing.
241 assert( !inst
->Src
[i
].Dimension
.Dimension
);
243 if (inst
->Src
[i
].Dimension
.Indirect
)
244 next_token( ctx
, &inst
->Src
[i
].DimIndirect
);
251 case TGSI_TOKEN_TYPE_PROPERTY
:
253 struct tgsi_full_property
*prop
= &ctx
->FullToken
.FullProperty
;
256 memset(prop
, 0, sizeof *prop
);
257 copy_token(&prop
->Property
, &token
);
259 prop_count
= prop
->Property
.NrTokens
- 1;
260 for (i
= 0; i
< prop_count
; i
++) {
261 next_token(ctx
, &prop
->u
[i
]);
276 * Make a new copy of a token array.
279 tgsi_dup_tokens(const struct tgsi_token
*tokens
)
281 unsigned n
= tgsi_num_tokens(tokens
);
282 unsigned bytes
= n
* sizeof(struct tgsi_token
);
283 struct tgsi_token
*new_tokens
= (struct tgsi_token
*) MALLOC(bytes
);
285 memcpy(new_tokens
, tokens
, bytes
);
291 * Allocate memory for num_tokens tokens.
294 tgsi_alloc_tokens(unsigned num_tokens
)
296 unsigned bytes
= num_tokens
* sizeof(struct tgsi_token
);
297 return (struct tgsi_token
*) MALLOC(bytes
);
302 * Free tokens allocated by tgsi_alloc_tokens() or tgsi_dup_tokens()
305 tgsi_free_tokens(const struct tgsi_token
*tokens
)
307 FREE((void *) tokens
);
312 tgsi_dump_tokens(const struct tgsi_token
*tokens
)
314 const unsigned *dwords
= (const unsigned *)tokens
;
315 int nr
= tgsi_num_tokens(tokens
);
318 STATIC_ASSERT(sizeof(*tokens
) == sizeof(unsigned));
320 debug_printf("const unsigned tokens[%d] = {\n", nr
);
321 for (i
= 0; i
< nr
; i
++)
322 debug_printf("0x%08x,\n", dwords
[i
]);
323 debug_printf("};\n");
327 tgsi_get_processor_type(const struct tgsi_token
*tokens
)
329 struct tgsi_parse_context parse
;
331 if (tgsi_parse_init( &parse
, tokens
) != TGSI_PARSE_OK
) {
332 debug_printf("tgsi_parse_init() failed in %s:%i!\n", __func__
, __LINE__
);
335 return parse
.FullHeader
.Processor
.Processor
;