utils.c File Reference

#include <stdio.h>
#include "d3dcompiler_private.h"

Include dependency graph for utils.c:

Go to the source code of this file.

Macros
#define	WINE_D3DCOMPILER_TO_STR(x)   case x: return #x

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (d3dcompiler)
const char *	debug_d3dcompiler_shader_variable_class (D3D_SHADER_VARIABLE_CLASS c)
const char *	debug_d3dcompiler_shader_variable_type (D3D_SHADER_VARIABLE_TYPE t)
const char *	debug_d3dcompiler_d3d_blob_part (D3D_BLOB_PART part)
const char *	debug_print_srcmod (DWORD mod)
const char *	debug_print_dstmod (DWORD mod)
const char *	debug_print_shift (DWORD shift)
static const char *	get_regname (const struct shader_reg *reg)
static const char *	debug_print_writemask (DWORD mask)
static const char *	debug_print_swizzle (DWORD arg)
static const char *	debug_print_relarg (const struct shader_reg *reg)
const char *	debug_print_dstreg (const struct shader_reg *reg)
const char *	debug_print_srcreg (const struct shader_reg *reg)
const char *	debug_print_comp (DWORD comp)
const char *	debug_print_opcode (DWORD opcode)
void	skip_dword_unknown (const char **ptr, unsigned int count)
static void	write_dword_unknown (char **ptr, DWORD d)
HRESULT	dxbc_add_section (struct dxbc *dxbc, DWORD tag, const char *data, DWORD data_size)
HRESULT	dxbc_init (struct dxbc *dxbc, unsigned int size)
HRESULT	dxbc_parse (const char *data, SIZE_T data_size, struct dxbc *dxbc)
void	dxbc_destroy (struct dxbc *dxbc)
HRESULT	dxbc_write_blob (struct dxbc *dxbc, ID3DBlob **blob)
void	compilation_message (struct compilation_messages *msg, const char *fmt, __ms_va_list args)
BOOL	add_declaration (struct hlsl_scope *scope, struct hlsl_ir_var *decl, BOOL local_var)
struct hlsl_ir_var *	get_variable (struct hlsl_scope *scope, const char *name)
void	free_declaration (struct hlsl_ir_var *decl)
struct hlsl_type *	new_hlsl_type (const char *name, enum hlsl_type_class type_class, enum hlsl_base_type base_type, unsigned dimx, unsigned dimy)
struct hlsl_type *	new_array_type (struct hlsl_type *basic_type, unsigned int array_size)
struct hlsl_type *	get_type (struct hlsl_scope *scope, const char *name, BOOL recursive)
BOOL	find_function (const char *name)
unsigned int	components_count_type (struct hlsl_type *type)
BOOL	compare_hlsl_types (const struct hlsl_type *t1, const struct hlsl_type *t2)
struct hlsl_type *	clone_hlsl_type (struct hlsl_type *old)
static BOOL	convertible_data_type (struct hlsl_type *type)
BOOL	compatible_data_types (struct hlsl_type *t1, struct hlsl_type *t2)
static BOOL	implicit_compatible_data_types (struct hlsl_type *t1, struct hlsl_type *t2)
static BOOL	expr_compatible_data_types (struct hlsl_type *t1, struct hlsl_type *t2)
static enum hlsl_base_type	expr_common_base_type (enum hlsl_base_type t1, enum hlsl_base_type t2)
static struct hlsl_type *	expr_common_type (struct hlsl_type *t1, struct hlsl_type *t2, struct source_location *loc)
static struct hlsl_ir_node *	implicit_conversion (struct hlsl_ir_node *node, struct hlsl_type *type, struct source_location *loc)
struct hlsl_ir_expr *	new_expr (enum hlsl_ir_expr_op op, struct hlsl_ir_node **operands, struct source_location *loc)
struct hlsl_ir_expr *	new_cast (struct hlsl_ir_node *node, struct hlsl_type *type, struct source_location *loc)
struct hlsl_ir_deref *	new_var_deref (struct hlsl_ir_var *var)
struct hlsl_ir_deref *	new_record_deref (struct hlsl_ir_node *record, struct hlsl_struct_field *field)
static enum hlsl_ir_expr_op	op_from_assignment (enum parse_assign_op op)
struct hlsl_ir_node *	make_assignment (struct hlsl_ir_node *left, enum parse_assign_op assign_op, DWORD writemask, struct hlsl_ir_node *right)
static int	compare_hlsl_types_rb (const void *key, const struct wine_rb_entry *entry)
void	push_scope (struct hlsl_parse_ctx *ctx)
BOOL	pop_scope (struct hlsl_parse_ctx *ctx)
struct hlsl_ir_function_decl *	new_func_decl (struct hlsl_type *return_type, struct list *parameters)
static int	compare_param_hlsl_types (const struct hlsl_type *t1, const struct hlsl_type *t2)
static int	compare_function_decl_rb (const void *key, const struct wine_rb_entry *entry)
static int	compare_function_rb (const void *key, const struct wine_rb_entry *entry)
void	init_functions_tree (struct wine_rb_tree *funcs)
static const char *	debug_base_type (const struct hlsl_type *type)
const char *	debug_hlsl_type (const struct hlsl_type *type)
const char *	debug_modifiers (DWORD modifiers)
static const char *	debug_node_type (enum hlsl_ir_node_type type)
static void	debug_dump_instr (const struct hlsl_ir_node *instr)
static void	debug_dump_instr_list (const struct list *list)
static void	debug_dump_ir_var (const struct hlsl_ir_var *var)
static void	debug_dump_ir_deref (const struct hlsl_ir_deref *deref)
static void	debug_dump_ir_constant (const struct hlsl_ir_constant *constant)
static const char *	debug_expr_op (const struct hlsl_ir_expr *expr)
static void	debug_dump_ir_expr (const struct hlsl_ir_expr *expr)
static void	debug_dump_ir_constructor (const struct hlsl_ir_constructor *constructor)
static const char *	debug_writemask (DWORD writemask)
static void	debug_dump_ir_assignment (const struct hlsl_ir_assignment *assign)
static void	debug_dump_ir_swizzle (const struct hlsl_ir_swizzle *swizzle)
static void	debug_dump_ir_jump (const struct hlsl_ir_jump *jump)
static void	debug_dump_ir_if (const struct hlsl_ir_if *if_node)
void	debug_dump_ir_function_decl (const struct hlsl_ir_function_decl *func)
void	free_hlsl_type (struct hlsl_type *type)
void	free_instr_list (struct list *list)
static void	free_ir_constant (struct hlsl_ir_constant *constant)
static void	free_ir_deref (struct hlsl_ir_deref *deref)
static void	free_ir_swizzle (struct hlsl_ir_swizzle *swizzle)
static void	free_ir_constructor (struct hlsl_ir_constructor *constructor)
static void	free_ir_expr (struct hlsl_ir_expr *expr)
static void	free_ir_assignment (struct hlsl_ir_assignment *assignment)
static void	free_ir_if (struct hlsl_ir_if *if_node)
static void	free_ir_jump (struct hlsl_ir_jump *jump)
void	free_instr (struct hlsl_ir_node *node)
static void	free_function_decl (struct hlsl_ir_function_decl *decl)
static void	free_function_decl_rb (struct wine_rb_entry *entry, void *context)
static void	free_function (struct hlsl_ir_function *func)
void	free_function_rb (struct wine_rb_entry *entry, void *context)
void	add_function_decl (struct wine_rb_tree *funcs, char *name, struct hlsl_ir_function_decl *decl, BOOL intrinsic)

Macro Definition Documentation

WINE_D3DCOMPILER_TO_STR

#define WINE_D3DCOMPILER_TO_STR

(

x

)

case x: return #x

Definition at line 30 of file utils.c.

Function Documentation

add_declaration()

BOOL add_declaration	(	struct hlsl_scope *	scope,
		struct hlsl_ir_var *	decl,
		BOOL	local_var
	)

Definition at line 761 of file utils.c.

{
    struct hlsl_ir_var *var;
 
    LIST_FOR_EACH_ENTRY(var, &scope->vars, struct hlsl_ir_var, scope_entry)
    {
        if (!strcmp(decl->name, var->name))
            return FALSE;
    }
    if (local_var && scope->upper->upper == hlsl_ctx.globals)
    {
        /* Check whether the variable redefines a function parameter. */
        LIST_FOR_EACH_ENTRY(var, &scope->upper->vars, struct hlsl_ir_var, scope_entry)
        {
            if (!strcmp(decl->name, var->name))
                return FALSE;
        }
    }
 
    list_add_tail(&scope->vars, &decl->scope_entry);
    return TRUE;
}

add_function_decl()

void add_function_decl	(	struct wine_rb_tree *	funcs,
		char *	name,
		struct hlsl_ir_function_decl *	decl,
		BOOL	intrinsic
	)

Definition at line 2282 of file utils.c.

{
    struct hlsl_ir_function *func;
    struct wine_rb_entry *func_entry, *old_entry;
 
    func_entry = wine_rb_get(funcs, name);
    if (func_entry)
    {
        func = WINE_RB_ENTRY_VALUE(func_entry, struct hlsl_ir_function, entry);
        if (intrinsic != func->intrinsic)
        {
            if (intrinsic)
            {
                ERR("Redeclaring a user defined function as an intrinsic.\n");
                return;
            }
            TRACE("Function %s redeclared as a user defined function.\n", debugstr_a(name));
            func->intrinsic = intrinsic;
            wine_rb_destroy(&func->overloads, free_function_decl_rb, NULL);
            wine_rb_init(&func->overloads, compare_function_decl_rb);
        }
        decl->func = func;
        if ((old_entry = wine_rb_get(&func->overloads, decl->parameters)))
        {
            struct hlsl_ir_function_decl *old_decl =
                    WINE_RB_ENTRY_VALUE(old_entry, struct hlsl_ir_function_decl, entry);
 
            if (!decl->body)
            {
                free_function_decl(decl);
                d3dcompiler_free(name);
                return;
            }
            wine_rb_remove(&func->overloads, old_entry);
            free_function_decl(old_decl);
        }
        wine_rb_put(&func->overloads, decl->parameters, &decl->entry);
        d3dcompiler_free(name);
        return;
    }
    func = d3dcompiler_alloc(sizeof(*func));
    func->name = name;
    wine_rb_init(&func->overloads, compare_function_decl_rb);
    decl->func = func;
    wine_rb_put(&func->overloads, decl->parameters, &decl->entry);
    func->intrinsic = intrinsic;
    wine_rb_put(funcs, func->name, &func->entry);
}

clone_hlsl_type()

struct hlsl_type * clone_hlsl_type

(

struct hlsl_type *

old

)

Definition at line 929 of file utils.c.

{
    struct hlsl_type *type;
    struct hlsl_struct_field *old_field, *field;
 
    type = d3dcompiler_alloc(sizeof(*type));
    if (!type)
    {
        ERR("Out of memory\n");
        return NULL;
    }
    if (old->name)
    {
        type->name = d3dcompiler_strdup(old->name);
        if (!type->name)
        {
            d3dcompiler_free(type);
            return NULL;
        }
    }
    type->type = old->type;
    type->base_type = old->base_type;
    type->dimx = old->dimx;
    type->dimy = old->dimy;
    type->modifiers = old->modifiers;
    type->sampler_dim = old->sampler_dim;
    switch (old->type)
    {
        case HLSL_CLASS_ARRAY:
            type->e.array.type = old->e.array.type;
            type->e.array.elements_count = old->e.array.elements_count;
            break;
        case HLSL_CLASS_STRUCT:
            type->e.elements = d3dcompiler_alloc(sizeof(*type->e.elements));
            if (!type->e.elements)
            {
                d3dcompiler_free((void *)type->name);
                d3dcompiler_free(type);
                return NULL;
            }
            list_init(type->e.elements);
            LIST_FOR_EACH_ENTRY(old_field, old->e.elements, struct hlsl_struct_field, entry)
            {
                field = d3dcompiler_alloc(sizeof(*field));
                if (!field)
                {
                    LIST_FOR_EACH_ENTRY_SAFE(field, old_field, type->e.elements, struct hlsl_struct_field, entry)
                    {
                        d3dcompiler_free((void *)field->semantic);
                        d3dcompiler_free((void *)field->name);
                        d3dcompiler_free(field);
                    }
                    d3dcompiler_free(type->e.elements);
                    d3dcompiler_free((void *)type->name);
                    d3dcompiler_free(type);
                    return NULL;
                }
                field->type = clone_hlsl_type(old_field->type);
                field->name = d3dcompiler_strdup(old_field->name);
                if (old_field->semantic)
                    field->semantic = d3dcompiler_strdup(old_field->semantic);
                field->modifiers = old_field->modifiers;
                list_add_tail(type->e.elements, &field->entry);
            }
            break;
        default:
            break;
    }
 
    list_add_tail(&hlsl_ctx.types, &type->entry);
    return type;
}

Referenced by clone_hlsl_type().

compare_function_decl_rb()

static int compare_function_decl_rb ( const void *  key, const struct wine_rb_entry *  entry  )

static

Definition at line 1627 of file utils.c.

{
    const struct list *params = key;
    const struct hlsl_ir_function_decl *decl = WINE_RB_ENTRY_VALUE(entry, const struct hlsl_ir_function_decl, entry);
    int params_count = params ? list_count(params) : 0;
    int decl_params_count = decl->parameters ? list_count(decl->parameters) : 0;
    int r;
    struct list *p1cur, *p2cur;
 
    if (params_count != decl_params_count)
        return params_count - decl_params_count;
 
    p1cur = params ? list_head(params) : NULL;
    p2cur = decl->parameters ? list_head(decl->parameters) : NULL;
    while (p1cur && p2cur)
    {
        struct hlsl_ir_var *p1, *p2;
        p1 = LIST_ENTRY(p1cur, struct hlsl_ir_var, param_entry);
        p2 = LIST_ENTRY(p2cur, struct hlsl_ir_var, param_entry);
        if ((r = compare_param_hlsl_types(p1->data_type, p2->data_type)))
            return r;
        p1cur = list_next(params, p1cur);
        p2cur = list_next(decl->parameters, p2cur);
    }
    return 0;
}

Referenced by add_function_decl().

compare_function_rb()

static int compare_function_rb ( const void *  key, const struct wine_rb_entry *  entry  )

static

Definition at line 1654 of file utils.c.

{
    const char *name = key;
    const struct hlsl_ir_function *func = WINE_RB_ENTRY_VALUE(entry, const struct hlsl_ir_function,entry);
 
    return strcmp(name, func->name);
}

Referenced by init_functions_tree().

compare_hlsl_types()

BOOL compare_hlsl_types	(	const struct hlsl_type *	t1,
		const struct hlsl_type *	t2
	)

Definition at line 883 of file utils.c.

{
    if (t1 == t2)
        return TRUE;
 
    if (t1->type != t2->type)
        return FALSE;
    if (t1->base_type != t2->base_type)
        return FALSE;
    if (t1->base_type == HLSL_TYPE_SAMPLER && t1->sampler_dim != t2->sampler_dim)
        return FALSE;
    if ((t1->modifiers & HLSL_MODIFIERS_COMPARISON_MASK)
            != (t2->modifiers & HLSL_MODIFIERS_COMPARISON_MASK))
        return FALSE;
    if (t1->dimx != t2->dimx)
        return FALSE;
    if (t1->dimy != t2->dimy)
        return FALSE;
    if (t1->type == HLSL_CLASS_STRUCT)
    {
        struct list *t1cur, *t2cur;
        struct hlsl_struct_field *t1field, *t2field;
 
        t1cur = list_head(t1->e.elements);
        t2cur = list_head(t2->e.elements);
        while (t1cur && t2cur)
        {
            t1field = LIST_ENTRY(t1cur, struct hlsl_struct_field, entry);
            t2field = LIST_ENTRY(t2cur, struct hlsl_struct_field, entry);
            if (!compare_hlsl_types(t1field->type, t2field->type))
                return FALSE;
            if (strcmp(t1field->name, t2field->name))
                return FALSE;
            t1cur = list_next(t1->e.elements, t1cur);
            t2cur = list_next(t2->e.elements, t2cur);
        }
        if (t1cur != t2cur)
            return FALSE;
    }
    if (t1->type == HLSL_CLASS_ARRAY)
        return t1->e.array.elements_count == t2->e.array.elements_count
                && compare_hlsl_types(t1->e.array.type, t2->e.array.type);
 
    return TRUE;
}

Referenced by compare_hlsl_types(), compatible_data_types(), expr_common_type(), implicit_compatible_data_types(), implicit_conversion(), make_assignment(), and new_expr().

compare_hlsl_types_rb()

static int compare_hlsl_types_rb ( const void *  key, const struct wine_rb_entry *  entry  )

static

Definition at line 1518 of file utils.c.

{
    const char *name = key;
    const struct hlsl_type *type = WINE_RB_ENTRY_VALUE(entry, const struct hlsl_type, scope_entry);
 
    if (name == type->name)
        return 0;
 
    if (!name || !type->name)
    {
        ERR("hlsl_type without a name in a scope?\n");
        return -1;
    }
    return strcmp(name, type->name);
}

Referenced by push_scope().

compare_param_hlsl_types()

static int compare_param_hlsl_types ( const struct hlsl_type *  t1, const struct hlsl_type *  t2  )

static

Definition at line 1578 of file utils.c.

{
    if (t1->type != t2->type)
    {
        if (!((t1->type == HLSL_CLASS_SCALAR && t2->type == HLSL_CLASS_VECTOR)
                || (t1->type == HLSL_CLASS_VECTOR && t2->type == HLSL_CLASS_SCALAR)))
            return t1->type - t2->type;
    }
    if (t1->base_type != t2->base_type)
        return t1->base_type - t2->base_type;
    if (t1->base_type == HLSL_TYPE_SAMPLER && t1->sampler_dim != t2->sampler_dim)
        return t1->sampler_dim - t2->sampler_dim;
    if (t1->dimx != t2->dimx)
        return t1->dimx - t2->dimx;
    if (t1->dimy != t2->dimy)
        return t1->dimx - t2->dimx;
    if (t1->type == HLSL_CLASS_STRUCT)
    {
        struct list *t1cur, *t2cur;
        struct hlsl_struct_field *t1field, *t2field;
        int r;
 
        t1cur = list_head(t1->e.elements);
        t2cur = list_head(t2->e.elements);
        while (t1cur && t2cur)
        {
            t1field = LIST_ENTRY(t1cur, struct hlsl_struct_field, entry);
            t2field = LIST_ENTRY(t2cur, struct hlsl_struct_field, entry);
            if ((r = compare_param_hlsl_types(t1field->type, t2field->type)))
                return r;
            if ((r = strcmp(t1field->name, t2field->name)))
                return r;
            t1cur = list_next(t1->e.elements, t1cur);
            t2cur = list_next(t2->e.elements, t2cur);
        }
        if (t1cur != t2cur)
            return t1cur ? 1 : -1;
        return 0;
    }
    if (t1->type == HLSL_CLASS_ARRAY)
    {
        if (t1->e.array.elements_count != t2->e.array.elements_count)
            return t1->e.array.elements_count - t2->e.array.elements_count;
        return compare_param_hlsl_types(t1->e.array.type, t2->e.array.type);
    }
 
    return 0;
}

Referenced by compare_function_decl_rb(), and compare_param_hlsl_types().

compatible_data_types()

BOOL compatible_data_types	(	struct hlsl_type *	t1,
		struct hlsl_type *	t2
	)

Definition at line 1007 of file utils.c.

{
   if (!convertible_data_type(t1) || !convertible_data_type(t2))
        return FALSE;
 
    if (t1->type <= HLSL_CLASS_LAST_NUMERIC)
    {
        /* Scalar vars can be cast to pretty much everything */
        if (t1->dimx == 1 && t1->dimy == 1)
            return TRUE;
 
        if (t1->type == HLSL_CLASS_VECTOR && t2->type == HLSL_CLASS_VECTOR)
            return t1->dimx >= t2->dimx;
    }
 
    /* The other way around is true too i.e. whatever to scalar */
    if (t2->type <= HLSL_CLASS_LAST_NUMERIC && t2->dimx == 1 && t2->dimy == 1)
        return TRUE;
 
    if (t1->type == HLSL_CLASS_ARRAY)
    {
        if (compare_hlsl_types(t1->e.array.type, t2))
            /* e.g. float4[3] to float4 is allowed */
            return TRUE;
 
        if (t2->type == HLSL_CLASS_ARRAY || t2->type == HLSL_CLASS_STRUCT)
            return components_count_type(t1) >= components_count_type(t2);
        else
            return components_count_type(t1) == components_count_type(t2);
    }
 
    if (t1->type == HLSL_CLASS_STRUCT)
        return components_count_type(t1) >= components_count_type(t2);
 
    if (t2->type == HLSL_CLASS_ARRAY || t2->type == HLSL_CLASS_STRUCT)
        return components_count_type(t1) == components_count_type(t2);
 
    if (t1->type == HLSL_CLASS_MATRIX || t2->type == HLSL_CLASS_MATRIX)
    {
        if (t1->type == HLSL_CLASS_MATRIX && t2->type == HLSL_CLASS_MATRIX && t1->dimx >= t2->dimx && t1->dimy >= t2->dimy)
            return TRUE;
 
        /* Matrix-vector conversion is apparently allowed if they have the same components count */
        if ((t1->type == HLSL_CLASS_VECTOR || t2->type == HLSL_CLASS_VECTOR)
                && components_count_type(t1) == components_count_type(t2))
            return TRUE;
        return FALSE;
    }
 
    if (components_count_type(t1) >= components_count_type(t2))
        return TRUE;
    return FALSE;
}

compilation_message()

void compilation_message	(	struct compilation_messages *	msg,
		const char *	fmt,
		__ms_va_list	args
	)

Definition at line 719 of file utils.c.

{
    char* buffer;
    int rc, size;
 
    if (msg->capacity == 0)
    {
        msg->string = d3dcompiler_alloc(MESSAGEBUFFER_INITIAL_SIZE);
        if (msg->string == NULL)
        {
            ERR("Error allocating memory for parser messages\n");
            return;
        }
        msg->capacity = MESSAGEBUFFER_INITIAL_SIZE;
    }
 
    while (1)
    {
        rc = vsnprintf(msg->string + msg->size,
                msg->capacity - msg->size, fmt, args);
 
        if (rc < 0 || rc >= msg->capacity - msg->size)
        {
            size = msg->capacity * 2;
            buffer = d3dcompiler_realloc(msg->string, size);
            if (buffer == NULL)
            {
                ERR("Error reallocating memory for parser messages\n");
                return;
            }
            msg->string = buffer;
            msg->capacity = size;
        }
        else
        {
            TRACE("%s", msg->string + msg->size);
            msg->size += rc;
            return;
        }
    }
}

components_count_type()

unsigned int components_count_type

(

struct hlsl_type *

type

)

Definition at line 857 of file utils.c.

{
    unsigned int count = 0;
    struct hlsl_struct_field *field;
 
    if (type->type <= HLSL_CLASS_LAST_NUMERIC)
    {
        return type->dimx * type->dimy;
    }
    if (type->type == HLSL_CLASS_ARRAY)
    {
        return components_count_type(type->e.array.type) * type->e.array.elements_count;
    }
    if (type->type != HLSL_CLASS_STRUCT)
    {
        ERR("Unexpected data type %s.\n", debug_hlsl_type(type));
        return 0;
    }
 
    LIST_FOR_EACH_ENTRY(field, type->e.elements, struct hlsl_struct_field, entry)
    {
        count += components_count_type(field->type);
    }
    return count;
}

Referenced by compatible_data_types(), components_count_type(), expr_compatible_data_types(), and implicit_compatible_data_types().

convertible_data_type()

static BOOL convertible_data_type ( struct hlsl_type *  type )

static

Definition at line 1002 of file utils.c.

{
    return type->type != HLSL_CLASS_OBJECT;
}

Referenced by compatible_data_types(), and implicit_compatible_data_types().

debug_base_type()

static const char * debug_base_type ( const struct hlsl_type *  type )

static

Definition at line 1667 of file utils.c.

{
    const char *name = "(unknown)";
 
    switch (type->base_type)
    {
        case HLSL_TYPE_FLOAT:        name = "float";         break;
        case HLSL_TYPE_HALF:         name = "half";          break;
        case HLSL_TYPE_DOUBLE:       name = "double";        break;
        case HLSL_TYPE_INT:          name = "int";           break;
        case HLSL_TYPE_UINT:         name = "uint";          break;
        case HLSL_TYPE_BOOL:         name = "bool";          break;
        case HLSL_TYPE_SAMPLER:
            switch (type->sampler_dim)
            {
                case HLSL_SAMPLER_DIM_GENERIC: name = "sampler";       break;
                case HLSL_SAMPLER_DIM_1D:      name = "sampler1D";     break;
                case HLSL_SAMPLER_DIM_2D:      name = "sampler2D";     break;
                case HLSL_SAMPLER_DIM_3D:      name = "sampler3D";     break;
                case HLSL_SAMPLER_DIM_CUBE:    name = "samplerCUBE";   break;
            }
            break;
        default:
            FIXME("Unhandled case %u\n", type->base_type);
    }
    return name;
}

Referenced by debug_dump_ir_constant(), and debug_hlsl_type().

debug_d3dcompiler_d3d_blob_part()

const char * debug_d3dcompiler_d3d_blob_part

(

D3D_BLOB_PART

part

)

Definition at line 106 of file utils.c.

{
    switch(part)
    {
        WINE_D3DCOMPILER_TO_STR(D3D_BLOB_INPUT_SIGNATURE_BLOB);
        WINE_D3DCOMPILER_TO_STR(D3D_BLOB_OUTPUT_SIGNATURE_BLOB);
        WINE_D3DCOMPILER_TO_STR(D3D_BLOB_INPUT_AND_OUTPUT_SIGNATURE_BLOB);
        WINE_D3DCOMPILER_TO_STR(D3D_BLOB_PATCH_CONSTANT_SIGNATURE_BLOB);
        WINE_D3DCOMPILER_TO_STR(D3D_BLOB_ALL_SIGNATURE_BLOB);
        WINE_D3DCOMPILER_TO_STR(D3D_BLOB_DEBUG_INFO);
        WINE_D3DCOMPILER_TO_STR(D3D_BLOB_LEGACY_SHADER);
        WINE_D3DCOMPILER_TO_STR(D3D_BLOB_XNA_PREPASS_SHADER);
        WINE_D3DCOMPILER_TO_STR(D3D_BLOB_XNA_SHADER);
        WINE_D3DCOMPILER_TO_STR(D3D_BLOB_TEST_ALTERNATE_SHADER);
        WINE_D3DCOMPILER_TO_STR(D3D_BLOB_TEST_COMPILE_DETAILS);
        WINE_D3DCOMPILER_TO_STR(D3D_BLOB_TEST_COMPILE_PERF);
        default:
            FIXME("Unrecognized D3D_BLOB_PART %#x\n", part);
            return "unrecognized";
    }
}

Referenced by check_blob_part(), d3dcompiler_get_blob_part(), and D3DGetBlobPart().

debug_d3dcompiler_shader_variable_class()

const char * debug_d3dcompiler_shader_variable_class

(

D3D_SHADER_VARIABLE_CLASS

c

)

Definition at line 32 of file utils.c.

{
    switch (c)
    {
        WINE_D3DCOMPILER_TO_STR(D3D_SVC_SCALAR);
        WINE_D3DCOMPILER_TO_STR(D3D_SVC_VECTOR);
        WINE_D3DCOMPILER_TO_STR(D3D_SVC_MATRIX_ROWS);
        WINE_D3DCOMPILER_TO_STR(D3D_SVC_MATRIX_COLUMNS);
        WINE_D3DCOMPILER_TO_STR(D3D_SVC_OBJECT);
        WINE_D3DCOMPILER_TO_STR(D3D_SVC_STRUCT);
        WINE_D3DCOMPILER_TO_STR(D3D_SVC_INTERFACE_CLASS);
        WINE_D3DCOMPILER_TO_STR(D3D_SVC_INTERFACE_POINTER);
        default:
            FIXME("Unrecognized D3D_SHADER_VARIABLE_CLASS %#x.\n", c);
            return "unrecognized";
    }
}

Referenced by d3dcompiler_parse_type().

debug_d3dcompiler_shader_variable_type()

const char * debug_d3dcompiler_shader_variable_type

(

D3D_SHADER_VARIABLE_TYPE

t

)

Definition at line 50 of file utils.c.

{
    switch (t)
    {
        WINE_D3DCOMPILER_TO_STR(D3D_SVT_VOID);
        WINE_D3DCOMPILER_TO_STR(D3D_SVT_BOOL);
        WINE_D3DCOMPILER_TO_STR(D3D_SVT_INT);
        WINE_D3DCOMPILER_TO_STR(D3D_SVT_FLOAT);
        WINE_D3DCOMPILER_TO_STR(D3D_SVT_STRING);
        WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURE);
        WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURE1D);
        WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURE2D);
        WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURE3D);
        WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURECUBE);
        WINE_D3DCOMPILER_TO_STR(D3D_SVT_SAMPLER);
        WINE_D3DCOMPILER_TO_STR(D3D_SVT_PIXELSHADER);
        WINE_D3DCOMPILER_TO_STR(D3D_SVT_VERTEXSHADER);
        WINE_D3DCOMPILER_TO_STR(D3D_SVT_UINT);
        WINE_D3DCOMPILER_TO_STR(D3D_SVT_UINT8);
        WINE_D3DCOMPILER_TO_STR(D3D_SVT_GEOMETRYSHADER);
        WINE_D3DCOMPILER_TO_STR(D3D_SVT_RASTERIZER);
        WINE_D3DCOMPILER_TO_STR(D3D_SVT_DEPTHSTENCIL);
        WINE_D3DCOMPILER_TO_STR(D3D_SVT_BLEND);
        WINE_D3DCOMPILER_TO_STR(D3D_SVT_BUFFER);
        WINE_D3DCOMPILER_TO_STR(D3D_SVT_CBUFFER);
        WINE_D3DCOMPILER_TO_STR(D3D_SVT_TBUFFER);
        WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURE1DARRAY);
        WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURE2DARRAY);
        WINE_D3DCOMPILER_TO_STR(D3D_SVT_RENDERTARGETVIEW);
        WINE_D3DCOMPILER_TO_STR(D3D_SVT_DEPTHSTENCILVIEW);
        WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURE2DMS);
        WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURE2DMSARRAY);
        WINE_D3DCOMPILER_TO_STR(D3D_SVT_TEXTURECUBEARRAY);
        WINE_D3DCOMPILER_TO_STR(D3D_SVT_HULLSHADER);
        WINE_D3DCOMPILER_TO_STR(D3D_SVT_DOMAINSHADER);
        WINE_D3DCOMPILER_TO_STR(D3D_SVT_INTERFACE_POINTER);
        WINE_D3DCOMPILER_TO_STR(D3D_SVT_COMPUTESHADER);
        WINE_D3DCOMPILER_TO_STR(D3D_SVT_DOUBLE);
        WINE_D3DCOMPILER_TO_STR(D3D_SVT_RWTEXTURE1D);
        WINE_D3DCOMPILER_TO_STR(D3D_SVT_RWTEXTURE1DARRAY);
        WINE_D3DCOMPILER_TO_STR(D3D_SVT_RWTEXTURE2D);
        WINE_D3DCOMPILER_TO_STR(D3D_SVT_RWTEXTURE2DARRAY);
        WINE_D3DCOMPILER_TO_STR(D3D_SVT_RWTEXTURE3D);
        WINE_D3DCOMPILER_TO_STR(D3D_SVT_RWBUFFER);
        WINE_D3DCOMPILER_TO_STR(D3D_SVT_BYTEADDRESS_BUFFER);
        WINE_D3DCOMPILER_TO_STR(D3D_SVT_RWBYTEADDRESS_BUFFER);
        WINE_D3DCOMPILER_TO_STR(D3D_SVT_STRUCTURED_BUFFER);
        WINE_D3DCOMPILER_TO_STR(D3D_SVT_RWSTRUCTURED_BUFFER);
        WINE_D3DCOMPILER_TO_STR(D3D_SVT_APPEND_STRUCTURED_BUFFER);
        WINE_D3DCOMPILER_TO_STR(D3D_SVT_CONSUME_STRUCTURED_BUFFER);
        default:
            FIXME("Unrecognized D3D_SHADER_VARIABLE_TYPE %#x.\n", t);
            return "unrecognized";
    }
}

Referenced by d3dcompiler_parse_type().

debug_dump_instr()

static void debug_dump_instr ( const struct hlsl_ir_node *  instr )

static

Definition at line 2053 of file utils.c.

{
    switch (instr->type)
    {
        case HLSL_IR_EXPR:
            debug_dump_ir_expr(expr_from_node(instr));
            break;
        case HLSL_IR_DEREF:
            debug_dump_ir_deref(deref_from_node(instr));
            break;
        case HLSL_IR_CONSTANT:
            debug_dump_ir_constant(constant_from_node(instr));
            break;
        case HLSL_IR_ASSIGNMENT:
            debug_dump_ir_assignment(assignment_from_node(instr));
            break;
        case HLSL_IR_SWIZZLE:
            debug_dump_ir_swizzle(swizzle_from_node(instr));
            break;
        case HLSL_IR_CONSTRUCTOR:
            debug_dump_ir_constructor(constructor_from_node(instr));
            break;
        case HLSL_IR_JUMP:
            debug_dump_ir_jump(jump_from_node(instr));
            break;
        case HLSL_IR_IF:
            debug_dump_ir_if(if_from_node(instr));
            break;
        default:
            TRACE("<No dump function for %s>", debug_node_type(instr->type));
    }
}

Referenced by debug_dump_instr_list(), debug_dump_ir_assignment(), debug_dump_ir_constructor(), debug_dump_ir_deref(), debug_dump_ir_expr(), debug_dump_ir_if(), debug_dump_ir_jump(), and debug_dump_ir_swizzle().

debug_dump_instr_list()

static void debug_dump_instr_list ( const struct list *  list )

static

Definition at line 1780 of file utils.c.

{
    struct hlsl_ir_node *instr;
 
    LIST_FOR_EACH_ENTRY(instr, list, struct hlsl_ir_node, entry)
    {
        debug_dump_instr(instr);
        TRACE("\n");
    }
}

Referenced by debug_dump_ir_function_decl(), and debug_dump_ir_if().

debug_dump_ir_assignment()

static void debug_dump_ir_assignment ( const struct hlsl_ir_assignment *  assign )

static

Definition at line 1985 of file utils.c.

{
    TRACE("= (");
    debug_dump_instr(assign->lhs);
    if (assign->writemask != BWRITERSP_WRITEMASK_ALL)
        TRACE("%s", debug_writemask(assign->writemask));
    TRACE(" ");
    debug_dump_instr(assign->rhs);
    TRACE(")");
}

Referenced by debug_dump_instr().

debug_dump_ir_constant()

static void debug_dump_ir_constant ( const struct hlsl_ir_constant *  constant )

static

Definition at line 1822 of file utils.c.

{
    struct hlsl_type *type = constant->node.data_type;
    unsigned int x, y;
 
    if (type->dimy != 1)
        TRACE("{");
    for (y = 0; y < type->dimy; ++y)
    {
        if (type->dimx != 1)
            TRACE("{");
        for (x = 0; x < type->dimx; ++x)
        {
            switch (type->base_type)
            {
                case HLSL_TYPE_FLOAT:
                    TRACE("%g ", (double)constant->v.value.f[y * type->dimx + x]);
                    break;
                case HLSL_TYPE_DOUBLE:
                    TRACE("%g ", constant->v.value.d[y * type->dimx + x]);
                    break;
                case HLSL_TYPE_INT:
                    TRACE("%d ", constant->v.value.i[y * type->dimx + x]);
                    break;
                case HLSL_TYPE_UINT:
                    TRACE("%u ", constant->v.value.u[y * type->dimx + x]);
                    break;
                case HLSL_TYPE_BOOL:
                    TRACE("%s ", constant->v.value.b[y * type->dimx + x] == FALSE ? "false" : "true");
                    break;
                default:
                    TRACE("Constants of type %s not supported\n", debug_base_type(type));
            }
        }
        if (type->dimx != 1)
            TRACE("}");
    }
    if (type->dimy != 1)
        TRACE("}");
}

Referenced by debug_dump_instr().

debug_dump_ir_constructor()

static void debug_dump_ir_constructor ( const struct hlsl_ir_constructor *  constructor )

static

Definition at line 1953 of file utils.c.

{
    unsigned int i;
 
    TRACE("%s (", debug_hlsl_type(constructor->node.data_type));
    for (i = 0; i < constructor->args_count; ++i)
    {
        debug_dump_instr(constructor->args[i]);
        TRACE(" ");
    }
    TRACE(")");
}

Referenced by debug_dump_instr().

debug_dump_ir_deref()

static void debug_dump_ir_deref ( const struct hlsl_ir_deref *  deref )

static

Definition at line 1800 of file utils.c.

{
    switch (deref->type)
    {
        case HLSL_IR_DEREF_VAR:
            TRACE("deref(");
            debug_dump_ir_var(deref->v.var);
            TRACE(")");
            break;
        case HLSL_IR_DEREF_ARRAY:
            debug_dump_instr(deref->v.array.array);
            TRACE("[");
            debug_dump_instr(deref->v.array.index);
            TRACE("]");
            break;
        case HLSL_IR_DEREF_RECORD:
            debug_dump_instr(deref->v.record.record);
            TRACE(".%s", debugstr_a(deref->v.record.field->name));
            break;
    }
}

Referenced by debug_dump_instr().

debug_dump_ir_expr()

static void debug_dump_ir_expr ( const struct hlsl_ir_expr *  expr )

static

Definition at line 1940 of file utils.c.

{
    unsigned int i;
 
    TRACE("%s (", debug_expr_op(expr));
    for (i = 0; i < 3 && expr->operands[i]; ++i)
    {
        debug_dump_instr(expr->operands[i]);
        TRACE(" ");
    }
    TRACE(")");
}

Referenced by debug_dump_instr().

debug_dump_ir_function_decl()

void debug_dump_ir_function_decl

(

const struct hlsl_ir_function_decl *

func

)

Definition at line 2086 of file utils.c.

{
    struct hlsl_ir_var *param;
 
    TRACE("Dumping function %s.\n", debugstr_a(func->func->name));
    TRACE("Function parameters:\n");
    LIST_FOR_EACH_ENTRY(param, func->parameters, struct hlsl_ir_var, param_entry)
    {
        debug_dump_ir_var(param);
        TRACE("\n");
    }
    if (func->semantic)
        TRACE("Function semantic: %s\n", debugstr_a(func->semantic));
    if (func->body)
    {
        debug_dump_instr_list(func->body);
    }
}

debug_dump_ir_if()

static void debug_dump_ir_if ( const struct hlsl_ir_if *  if_node )

static

Definition at line 2038 of file utils.c.

{
    TRACE("if (");
    debug_dump_instr(if_node->condition);
    TRACE(")\n{\n");
    debug_dump_instr_list(if_node->then_instrs);
    TRACE("}\n");
    if (if_node->else_instrs)
    {
        TRACE("else\n{\n");
        debug_dump_instr_list(if_node->else_instrs);
        TRACE("}\n");
    }
}

Referenced by debug_dump_instr().

debug_dump_ir_jump()

static void debug_dump_ir_jump ( const struct hlsl_ir_jump *  jump )

static

Definition at line 2016 of file utils.c.

{
    switch (jump->type)
    {
        case HLSL_IR_JUMP_BREAK:
            TRACE("break");
            break;
        case HLSL_IR_JUMP_CONTINUE:
            TRACE("continue");
            break;
        case HLSL_IR_JUMP_DISCARD:
            TRACE("discard");
            break;
        case HLSL_IR_JUMP_RETURN:
            TRACE("return ");
            if (jump->return_value)
                debug_dump_instr(jump->return_value);
            TRACE(";");
            break;
    }
}

Referenced by debug_dump_instr().

debug_dump_ir_swizzle()

static void debug_dump_ir_swizzle ( const struct hlsl_ir_swizzle *  swizzle )

static

Definition at line 1996 of file utils.c.

{
    unsigned int i;
 
    debug_dump_instr(swizzle->val);
    TRACE(".");
    if (swizzle->val->data_type->dimy > 1)
    {
        for (i = 0; i < swizzle->node.data_type->dimx; ++i)
            TRACE("_m%u%u", (swizzle->swizzle >> i * 8) & 0xf, (swizzle->swizzle >> (i * 8 + 4)) & 0xf);
    }
    else
    {
        static const char c[] = {'x', 'y', 'z', 'w'};
 
        for (i = 0; i < swizzle->node.data_type->dimx; ++i)
            TRACE("%c", c[(swizzle->swizzle >> i * 2) & 0x3]);
    }
}

Referenced by debug_dump_instr().

debug_dump_ir_var()

static void debug_dump_ir_var ( const struct hlsl_ir_var *  var )

static

Definition at line 1791 of file utils.c.

{
    if (var->modifiers)
        TRACE("%s ", debug_modifiers(var->modifiers));
    TRACE("%s %s", debug_hlsl_type(var->data_type), var->name);
    if (var->semantic)
        TRACE(" : %s", debugstr_a(var->semantic));
}

Referenced by debug_dump_ir_deref(), and debug_dump_ir_function_decl().

debug_expr_op()

static const char * debug_expr_op ( const struct hlsl_ir_expr *  expr )

static

Definition at line 1863 of file utils.c.

{
    static const char * const op_names[] =
    {
        "~",
        "!",
        "-",
        "abs",
        "sign",
        "rcp",
        "rsq",
        "sqrt",
        "nrm",
        "exp2",
        "log2",
 
        "cast",
 
        "fract",
 
        "sin",
        "cos",
        "sin_reduced",
        "cos_reduced",
 
        "dsx",
        "dsy",
 
        "sat",
 
        "pre++",
        "pre--",
        "post++",
        "post--",
 
        "+",
        "-",
        "*",
        "/",
 
        "%",
 
        "<",
        ">",
        "<=",
        ">=",
        "==",
        "!=",
 
        "&&",
        "||",
 
        "<<",
        ">>",
        "&",
        "|",
        "^",
 
        "dot",
        "crs",
        "min",
        "max",
 
        "pow",
 
        "lerp",
 
        ",",
    };
 
    if (expr->op == HLSL_IR_UNOP_CAST)
        return debug_hlsl_type(expr->node.data_type);
 
    return op_names[expr->op];
}

Referenced by debug_dump_ir_expr().

debug_hlsl_type()

const char * debug_hlsl_type

(

const struct hlsl_type *

type

)

Definition at line 1695 of file utils.c.

{
    const char *name;
 
    if (type->name)
        return debugstr_a(type->name);
 
    if (type->type == HLSL_CLASS_STRUCT)
        return "<anonymous struct>";
 
    if (type->type == HLSL_CLASS_ARRAY)
    {
        name = debug_base_type(type->e.array.type);
        return wine_dbg_sprintf("%s[%u]", name, type->e.array.elements_count);
    }
 
    name = debug_base_type(type);
 
    if (type->type == HLSL_CLASS_SCALAR)
        return wine_dbg_sprintf("%s", name);
    if (type->type == HLSL_CLASS_VECTOR)
        return wine_dbg_sprintf("%s%u", name, type->dimx);
    if (type->type == HLSL_CLASS_MATRIX)
        return wine_dbg_sprintf("%s%ux%u", name, type->dimx, type->dimy);
    return "unexpected_type";
}

Referenced by components_count_type(), debug_dump_ir_constructor(), debug_dump_ir_var(), debug_expr_op(), implicit_conversion(), make_assignment(), and new_expr().

debug_modifiers()

const char * debug_modifiers

(

DWORD

modifiers

)

Definition at line 1722 of file utils.c.

{
    char string[110];
 
    string[0] = 0;
    if (modifiers & HLSL_STORAGE_EXTERN)
        strcat(string, " extern");                       /* 7 */
    if (modifiers & HLSL_STORAGE_NOINTERPOLATION)
        strcat(string, " nointerpolation");              /* 16 */
    if (modifiers & HLSL_MODIFIER_PRECISE)
        strcat(string, " precise");                      /* 8 */
    if (modifiers & HLSL_STORAGE_SHARED)
        strcat(string, " shared");                       /* 7 */
    if (modifiers & HLSL_STORAGE_GROUPSHARED)
        strcat(string, " groupshared");                  /* 12 */
    if (modifiers & HLSL_STORAGE_STATIC)
        strcat(string, " static");                       /* 7 */
    if (modifiers & HLSL_STORAGE_UNIFORM)
        strcat(string, " uniform");                      /* 8 */
    if (modifiers & HLSL_STORAGE_VOLATILE)
        strcat(string, " volatile");                     /* 9 */
    if (modifiers & HLSL_MODIFIER_CONST)
        strcat(string, " const");                        /* 6 */
    if (modifiers & HLSL_MODIFIER_ROW_MAJOR)
        strcat(string, " row_major");                    /* 10 */
    if (modifiers & HLSL_MODIFIER_COLUMN_MAJOR)
        strcat(string, " column_major");                 /* 13 */
    if ((modifiers & (HLSL_MODIFIER_IN | HLSL_MODIFIER_OUT)) == (HLSL_MODIFIER_IN | HLSL_MODIFIER_OUT))
        strcat(string, " inout");                        /* 6 */
    else if (modifiers & HLSL_MODIFIER_IN)
        strcat(string, " in");                           /* 3 */
    else if (modifiers & HLSL_MODIFIER_OUT)
        strcat(string, " out");                          /* 4 */
 
    return wine_dbg_sprintf("%s", string[0] ? string + 1 : "");
}

Referenced by debug_dump_ir_var().

debug_node_type()

static const char * debug_node_type ( enum hlsl_ir_node_type  type )

static

Definition at line 1759 of file utils.c.

{
    static const char * const names[] =
    {
        "HLSL_IR_ASSIGNMENT",
        "HLSL_IR_CONSTANT",
        "HLSL_IR_CONSTRUCTOR",
        "HLSL_IR_DEREF",
        "HLSL_IR_EXPR",
        "HLSL_IR_IF",
        "HLSL_IR_JUMP",
        "HLSL_IR_SWIZZLE",
    };
 
    if (type >= ARRAY_SIZE(names))
        return "Unexpected node type";
    return names[type];
}

Referenced by debug_dump_instr(), and free_instr().

debug_print_comp()

const char * debug_print_comp

(

DWORD

comp

)

Definition at line 401 of file utils.c.

{
    switch (comp)
    {
        case BWRITER_COMPARISON_NONE: return "";
        case BWRITER_COMPARISON_GT:   return "_gt";
        case BWRITER_COMPARISON_EQ:   return "_eq";
        case BWRITER_COMPARISON_GE:   return "_ge";
        case BWRITER_COMPARISON_LT:   return "_lt";
        case BWRITER_COMPARISON_NE:   return "_ne";
        case BWRITER_COMPARISON_LE:   return "_le";
        default: return "_unknown";
    }
}

Referenced by asmparser_instr().

debug_print_dstmod()

const char * debug_print_dstmod

(

DWORD

mod

)

Definition at line 153 of file utils.c.

{
    switch (mod)
    {
        case 0:
            return "";
        case BWRITERSPDM_SATURATE:
            return "_sat";
        case BWRITERSPDM_PARTIALPRECISION:
            return "_pp";
        case BWRITERSPDM_MSAMPCENTROID:
            return "_centroid";
        case BWRITERSPDM_SATURATE | BWRITERSPDM_PARTIALPRECISION:
            return "_sat_pp";
        case BWRITERSPDM_SATURATE | BWRITERSPDM_MSAMPCENTROID:
            return "_sat_centroid";
        case BWRITERSPDM_PARTIALPRECISION | BWRITERSPDM_MSAMPCENTROID:
            return "_pp_centroid";
        case BWRITERSPDM_SATURATE | BWRITERSPDM_PARTIALPRECISION | BWRITERSPDM_MSAMPCENTROID:
            return "_sat_pp_centroid";
        default:
            return "Unexpected modifier\n";
    }
}

Referenced by asmparser_instr(), and check_ps_dstmod().

debug_print_dstreg()

const char * debug_print_dstreg

(

const struct shader_reg *

reg

)

Definition at line 330 of file utils.c.

{
    return wine_dbg_sprintf("%s%s%s", get_regname(reg),
            debug_print_relarg(reg),
            debug_print_writemask(reg->u.writemask));
}

Referenced by asmparser_dstreg_ps_1_0123(), asmparser_dstreg_ps_1_4(), asmparser_dstreg_ps_2(), asmparser_dstreg_ps_2_x(), asmparser_dstreg_ps_3(), asmparser_dstreg_vs_1(), asmparser_dstreg_vs_2(), asmparser_dstreg_vs_3(), and asmparser_instr().

debug_print_opcode()

const char * debug_print_opcode

(

DWORD

opcode

)

Definition at line 416 of file utils.c.

{
    switch (opcode)
    {
        case BWRITERSIO_NOP:          return "nop";
        case BWRITERSIO_MOV:          return "mov";
        case BWRITERSIO_ADD:          return "add";
        case BWRITERSIO_SUB:          return "sub";
        case BWRITERSIO_MAD:          return "mad";
        case BWRITERSIO_MUL:          return "mul";
        case BWRITERSIO_RCP:          return "rcp";
        case BWRITERSIO_RSQ:          return "rsq";
        case BWRITERSIO_DP3:          return "dp3";
        case BWRITERSIO_DP4:          return "dp4";
        case BWRITERSIO_MIN:          return "min";
        case BWRITERSIO_MAX:          return "max";
        case BWRITERSIO_SLT:          return "slt";
        case BWRITERSIO_SGE:          return "sge";
        case BWRITERSIO_EXP:          return "exp";
        case BWRITERSIO_LOG:          return "log";
        case BWRITERSIO_LIT:          return "lit";
        case BWRITERSIO_DST:          return "dst";
        case BWRITERSIO_LRP:          return "lrp";
        case BWRITERSIO_FRC:          return "frc";
        case BWRITERSIO_M4x4:         return "m4x4";
        case BWRITERSIO_M4x3:         return "m4x3";
        case BWRITERSIO_M3x4:         return "m3x4";
        case BWRITERSIO_M3x3:         return "m3x3";
        case BWRITERSIO_M3x2:         return "m3x2";
        case BWRITERSIO_CALL:         return "call";
        case BWRITERSIO_CALLNZ:       return "callnz";
        case BWRITERSIO_LOOP:         return "loop";
        case BWRITERSIO_RET:          return "ret";
        case BWRITERSIO_ENDLOOP:      return "endloop";
        case BWRITERSIO_LABEL:        return "label";
        case BWRITERSIO_DCL:          return "dcl";
        case BWRITERSIO_POW:          return "pow";
        case BWRITERSIO_CRS:          return "crs";
        case BWRITERSIO_SGN:          return "sgn";
        case BWRITERSIO_ABS:          return "abs";
        case BWRITERSIO_NRM:          return "nrm";
        case BWRITERSIO_SINCOS:       return "sincos";
        case BWRITERSIO_REP:          return "rep";
        case BWRITERSIO_ENDREP:       return "endrep";
        case BWRITERSIO_IF:           return "if";
        case BWRITERSIO_IFC:          return "ifc";
        case BWRITERSIO_ELSE:         return "else";
        case BWRITERSIO_ENDIF:        return "endif";
        case BWRITERSIO_BREAK:        return "break";
        case BWRITERSIO_BREAKC:       return "breakc";
        case BWRITERSIO_MOVA:         return "mova";
        case BWRITERSIO_DEFB:         return "defb";
        case BWRITERSIO_DEFI:         return "defi";
        case BWRITERSIO_TEXCOORD:     return "texcoord";
        case BWRITERSIO_TEXKILL:      return "texkill";
        case BWRITERSIO_TEX:          return "tex";
        case BWRITERSIO_TEXBEM:       return "texbem";
        case BWRITERSIO_TEXBEML:      return "texbeml";
        case BWRITERSIO_TEXREG2AR:    return "texreg2ar";
        case BWRITERSIO_TEXREG2GB:    return "texreg2gb";
        case BWRITERSIO_TEXM3x2PAD:   return "texm3x2pad";
        case BWRITERSIO_TEXM3x2TEX:   return "texm3x2tex";
        case BWRITERSIO_TEXM3x3PAD:   return "texm3x3pad";
        case BWRITERSIO_TEXM3x3TEX:   return "texm3x3tex";
        case BWRITERSIO_TEXM3x3SPEC:  return "texm3x3vspec";
        case BWRITERSIO_TEXM3x3VSPEC: return "texm3x3vspec";
        case BWRITERSIO_EXPP:         return "expp";
        case BWRITERSIO_LOGP:         return "logp";
        case BWRITERSIO_CND:          return "cnd";
        case BWRITERSIO_DEF:          return "def";
        case BWRITERSIO_TEXREG2RGB:   return "texreg2rgb";
        case BWRITERSIO_TEXDP3TEX:    return "texdp3tex";
        case BWRITERSIO_TEXM3x2DEPTH: return "texm3x2depth";
        case BWRITERSIO_TEXDP3:       return "texdp3";
        case BWRITERSIO_TEXM3x3:      return "texm3x3";
        case BWRITERSIO_TEXDEPTH:     return "texdepth";
        case BWRITERSIO_CMP:          return "cmp";
        case BWRITERSIO_BEM:          return "bem";
        case BWRITERSIO_DP2ADD:       return "dp2add";
        case BWRITERSIO_DSX:          return "dsx";
        case BWRITERSIO_DSY:          return "dsy";
        case BWRITERSIO_TEXLDD:       return "texldd";
        case BWRITERSIO_SETP:         return "setp";
        case BWRITERSIO_TEXLDL:       return "texldl";
        case BWRITERSIO_BREAKP:       return "breakp";
        case BWRITERSIO_PHASE:        return "phase";
 
        case BWRITERSIO_TEXLDP:       return "texldp";
        case BWRITERSIO_TEXLDB:       return "texldb";
 
        default:                      return "unknown";
    }
}

Referenced by asmparser_instr(), and call_instr_handler().

debug_print_relarg()

static const char * debug_print_relarg ( const struct shader_reg *  reg )

static

Definition at line 315 of file utils.c.

{
    const char *short_swizzle;
    if (!reg->rel_reg) return "";
 
    short_swizzle = debug_print_swizzle(reg->rel_reg->u.swizzle);
 
    if (reg->rel_reg->type == BWRITERSPR_ADDR)
        return wine_dbg_sprintf("[a%u%s]", reg->rel_reg->regnum, short_swizzle);
    else if(reg->rel_reg->type == BWRITERSPR_LOOP && reg->rel_reg->regnum == 0)
        return wine_dbg_sprintf("[aL%s]", short_swizzle);
    else
        return "Unexpected relative addressing argument";
}

Referenced by debug_print_dstreg(), and debug_print_srcreg().

debug_print_shift()

const char * debug_print_shift

(

DWORD

shift

)

Definition at line 178 of file utils.c.

{
    static const char * const shiftstrings[] =
    {
        "",
        "_x2",
        "_x4",
        "_x8",
        "_x16",
        "_x32",
        "",
        "",
        "",
        "",
        "",
        "",
        "_d16",
        "_d8",
        "_d4",
        "_d2",
    };
    return shiftstrings[shift];
}

Referenced by asmparser_instr().

debug_print_srcmod()

const char * debug_print_srcmod

(

DWORD

mod

)

Definition at line 128 of file utils.c.

{
    switch (mod)
    {
        WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_NEG);
        WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_BIAS);
        WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_BIASNEG);
        WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_SIGN);
        WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_SIGNNEG);
        WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_COMP);
        WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_X2);
        WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_X2NEG);
        WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_DZ);
        WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_DW);
        WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_ABS);
        WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_ABSNEG);
        WINE_D3DCOMPILER_TO_STR(BWRITERSPSM_NOT);
        default:
            FIXME("Unrecognized source modifier %#x.\n", mod);
            return "unrecognized_src_mod";
    }
}

Referenced by check_abs_srcmod(), and check_legacy_srcmod().

debug_print_srcreg()

const char * debug_print_srcreg

(

const struct shader_reg *

reg

)

Definition at line 337 of file utils.c.

{
    switch (reg->srcmod)
    {
        case BWRITERSPSM_NONE:
            return wine_dbg_sprintf("%s%s%s", get_regname(reg),
                    debug_print_relarg(reg),
                    debug_print_swizzle(reg->u.swizzle));
        case BWRITERSPSM_NEG:
            return wine_dbg_sprintf("-%s%s%s", get_regname(reg),
                    debug_print_relarg(reg),
                    debug_print_swizzle(reg->u.swizzle));
        case BWRITERSPSM_BIAS:
            return wine_dbg_sprintf("%s%s_bias%s", get_regname(reg),
                    debug_print_relarg(reg),
                    debug_print_swizzle(reg->u.swizzle));
        case BWRITERSPSM_BIASNEG:
            return wine_dbg_sprintf("-%s%s_bias%s", get_regname(reg),
                    debug_print_relarg(reg),
                    debug_print_swizzle(reg->u.swizzle));
        case BWRITERSPSM_SIGN:
            return wine_dbg_sprintf("%s%s_bx2%s", get_regname(reg),
                    debug_print_relarg(reg),
                    debug_print_swizzle(reg->u.swizzle));
        case BWRITERSPSM_SIGNNEG:
            return wine_dbg_sprintf("-%s%s_bx2%s", get_regname(reg),
                    debug_print_relarg(reg),
                    debug_print_swizzle(reg->u.swizzle));
        case BWRITERSPSM_COMP:
            return wine_dbg_sprintf("1 - %s%s%s", get_regname(reg),
                    debug_print_relarg(reg),
                    debug_print_swizzle(reg->u.swizzle));
        case BWRITERSPSM_X2:
            return wine_dbg_sprintf("%s%s_x2%s", get_regname(reg),
                    debug_print_relarg(reg),
                    debug_print_swizzle(reg->u.swizzle));
        case BWRITERSPSM_X2NEG:
            return wine_dbg_sprintf("-%s%s_x2%s", get_regname(reg),
                    debug_print_relarg(reg),
                    debug_print_swizzle(reg->u.swizzle));
        case BWRITERSPSM_DZ:
            return wine_dbg_sprintf("%s%s_dz%s", get_regname(reg),
                    debug_print_relarg(reg),
                    debug_print_swizzle(reg->u.swizzle));
        case BWRITERSPSM_DW:
            return wine_dbg_sprintf("%s%s_dw%s", get_regname(reg),
                    debug_print_relarg(reg),
                    debug_print_swizzle(reg->u.swizzle));
        case BWRITERSPSM_ABS:
            return wine_dbg_sprintf("%s%s_abs%s", get_regname(reg),
                    debug_print_relarg(reg),
                    debug_print_swizzle(reg->u.swizzle));
        case BWRITERSPSM_ABSNEG:
            return wine_dbg_sprintf("-%s%s_abs%s", get_regname(reg),
                    debug_print_relarg(reg),
                    debug_print_swizzle(reg->u.swizzle));
        case BWRITERSPSM_NOT:
            return wine_dbg_sprintf("!%s%s%s", get_regname(reg),
                    debug_print_relarg(reg),
                    debug_print_swizzle(reg->u.swizzle));
    }
    return "Unknown modifier";
}

Referenced by asmparser_instr(), asmparser_srcreg_ps_1_0123(), asmparser_srcreg_ps_1_4(), asmparser_srcreg_ps_2(), asmparser_srcreg_ps_2_x(), asmparser_srcreg_ps_3(), asmparser_srcreg_vs_1(), asmparser_srcreg_vs_2(), and asmparser_srcreg_vs_3().

debug_print_swizzle()

static const char * debug_print_swizzle ( DWORD  arg )

static

Definition at line 274 of file utils.c.

{
    char ret[6];
    unsigned int i;
    DWORD swizzle[4];
 
    switch (arg)
    {
        case BWRITERVS_NOSWIZZLE:
            return "";
        case BWRITERVS_SWIZZLE_X:
            return ".x";
        case BWRITERVS_SWIZZLE_Y:
            return ".y";
        case BWRITERVS_SWIZZLE_Z:
            return ".z";
        case BWRITERVS_SWIZZLE_W:
            return ".w";
    }
 
    swizzle[0] = (arg >> (BWRITERVS_SWIZZLE_SHIFT + 0)) & 0x03;
    swizzle[1] = (arg >> (BWRITERVS_SWIZZLE_SHIFT + 2)) & 0x03;
    swizzle[2] = (arg >> (BWRITERVS_SWIZZLE_SHIFT + 4)) & 0x03;
    swizzle[3] = (arg >> (BWRITERVS_SWIZZLE_SHIFT + 6)) & 0x03;
 
    ret[0] = '.';
    for (i = 0; i < 4; ++i)
    {
        switch (swizzle[i])
        {
            case 0: ret[1 + i] = 'x'; break;
            case 1: ret[1 + i] = 'y'; break;
            case 2: ret[1 + i] = 'z'; break;
            case 3: ret[1 + i] = 'w'; break;
        }
    }
    ret[5] = '\0';
 
    return wine_dbg_sprintf("%s", ret);
}

Referenced by debug_print_relarg(), and debug_print_srcreg().

debug_print_writemask()

static const char * debug_print_writemask ( DWORD  mask )

static

Definition at line 258 of file utils.c.

{
    char ret[6];
    unsigned char pos = 1;
 
    if(mask == BWRITERSP_WRITEMASK_ALL) return "";
    ret[0] = '.';
    if(mask & BWRITERSP_WRITEMASK_0) ret[pos++] = 'x';
    if(mask & BWRITERSP_WRITEMASK_1) ret[pos++] = 'y';
    if(mask & BWRITERSP_WRITEMASK_2) ret[pos++] = 'z';
    if(mask & BWRITERSP_WRITEMASK_3) ret[pos++] = 'w';
    ret[pos] = 0;
 
    return wine_dbg_sprintf("%s", ret);
}

Referenced by debug_print_dstreg().

debug_writemask()

static const char * debug_writemask ( DWORD  writemask )

static

Definition at line 1966 of file utils.c.

{
    static const char components[] = {'x', 'y', 'z', 'w'};
    char string[5];
    unsigned int i = 0, pos = 0;
 
    assert(!(writemask & ~BWRITERSP_WRITEMASK_ALL));
 
    while (writemask)
    {
        if (writemask & 1)
            string[pos++] = components[i];
        writemask >>= 1;
        i++;
    }
    string[pos] = '\0';
    return wine_dbg_sprintf(".%s", string);
}

Referenced by debug_dump_ir_assignment().

dxbc_add_section()

HRESULT dxbc_add_section	(	struct dxbc *	dxbc,
		DWORD	tag,
		const char *	data,
		DWORD	data_size
	)

Definition at line 529 of file utils.c.

{
    TRACE("dxbc %p, tag %s, size %#x.\n", dxbc, debugstr_an((const char *)&tag, 4), data_size);
 
    if (dxbc->count >= dxbc->size)
    {
        struct dxbc_section *new_sections;
        DWORD new_size = dxbc->size << 1;
 
        new_sections = HeapReAlloc(GetProcessHeap(), 0, dxbc->sections, new_size * sizeof(*dxbc->sections));
        if (!new_sections)
        {
            ERR("Failed to allocate dxbc section memory\n");
            return E_OUTOFMEMORY;
        }
 
        dxbc->sections = new_sections;
        dxbc->size = new_size;
    }
 
    dxbc->sections[dxbc->count].tag = tag;
    dxbc->sections[dxbc->count].data_size = data_size;
    dxbc->sections[dxbc->count].data = data;
    ++dxbc->count;
 
    return S_OK;
}

Referenced by d3dcompiler_get_blob_part(), d3dcompiler_strip_shader(), and dxbc_parse().

dxbc_destroy()

void dxbc_destroy

(

struct dxbc *

dxbc

)

Definition at line 648 of file utils.c.

{
    TRACE("dxbc %p.\n", dxbc);
 
    HeapFree(GetProcessHeap(), 0, dxbc->sections);
}

Referenced by d3dcompiler_get_blob_part(), d3dcompiler_shader_reflection_init(), and d3dcompiler_strip_shader().

dxbc_init()

HRESULT dxbc_init	(	struct dxbc *	dxbc,
		unsigned int	size
	)

Definition at line 557 of file utils.c.

{
    TRACE("dxbc %p, size %u.\n", dxbc, size);
 
    /* use a good starting value for the size if none specified */
    if (!size) size = 2;
 
    dxbc->sections = HeapAlloc(GetProcessHeap(), 0, size * sizeof(*dxbc->sections));
    if (!dxbc->sections)
    {
        ERR("Failed to allocate dxbc section memory\n");
        return E_OUTOFMEMORY;
    }
 
    dxbc->size = size;
    dxbc->count = 0;
 
    return S_OK;
}

Referenced by d3dcompiler_get_blob_part(), d3dcompiler_strip_shader(), and dxbc_parse().

dxbc_parse()

HRESULT dxbc_parse	(	const char *	data,
		SIZE_T	data_size,
		struct dxbc *	dxbc
	)

Definition at line 577 of file utils.c.

{
    const char *ptr = data;
    HRESULT hr;
    unsigned int i;
    DWORD tag, total_size, chunk_count;
 
    if (!data)
    {
        WARN("No data supplied.\n");
        return E_FAIL;
    }
 
    read_dword(&ptr, &tag);
    TRACE("tag: %s.\n", debugstr_an((const char *)&tag, 4));
 
    if (tag != TAG_DXBC)
    {
        WARN("Wrong tag.\n");
        return E_FAIL;
    }
 
    /* checksum? */
    skip_dword_unknown(&ptr, 4);
 
    skip_dword_unknown(&ptr, 1);
 
    read_dword(&ptr, &total_size);
    TRACE("total size: %#x\n", total_size);
 
    if (data_size != total_size)
    {
        WARN("Wrong size supplied.\n");
        return D3DERR_INVALIDCALL;
    }
 
    read_dword(&ptr, &chunk_count);
    TRACE("chunk count: %#x\n", chunk_count);
 
    hr = dxbc_init(dxbc, chunk_count);
    if (FAILED(hr))
    {
        WARN("Failed to init dxbc\n");
        return hr;
    }
 
    for (i = 0; i < chunk_count; ++i)
    {
        DWORD chunk_tag, chunk_size;
        const char *chunk_ptr;
        DWORD chunk_offset;
 
        read_dword(&ptr, &chunk_offset);
        TRACE("chunk %u at offset %#x\n", i, chunk_offset);
 
        chunk_ptr = data + chunk_offset;
 
        read_dword(&chunk_ptr, &chunk_tag);
        read_dword(&chunk_ptr, &chunk_size);
 
        hr = dxbc_add_section(dxbc, chunk_tag, chunk_ptr, chunk_size);
        if (FAILED(hr))
        {
            WARN("Failed to add section to dxbc\n");
            return hr;
        }
    }
 
    return hr;
}

Referenced by d3dcompiler_get_blob_part(), d3dcompiler_shader_reflection_init(), and d3dcompiler_strip_shader().

dxbc_write_blob()

HRESULT dxbc_write_blob	(	struct dxbc *	dxbc,
		ID3DBlob **	blob
	)

Definition at line 655 of file utils.c.

{
    DWORD size = 32, offset = size + 4 * dxbc->count;
    ID3DBlob *object;
    HRESULT hr;
    char *ptr;
    unsigned int i;
 
    TRACE("dxbc %p, blob %p.\n", dxbc, blob);
 
    for (i = 0; i < dxbc->count; ++i)
    {
        size += 12 + dxbc->sections[i].data_size;
    }
 
    hr = D3DCreateBlob(size, &object);
    if (FAILED(hr))
    {
        WARN("Failed to create blob\n");
        return hr;
    }
 
    ptr = ID3D10Blob_GetBufferPointer(object);
 
    write_dword(&ptr, TAG_DXBC);
 
    /* signature(?) */
    write_dword_unknown(&ptr, 0);
    write_dword_unknown(&ptr, 0);
    write_dword_unknown(&ptr, 0);
    write_dword_unknown(&ptr, 0);
 
    /* seems to be always 1 */
    write_dword_unknown(&ptr, 1);
 
    /* DXBC size */
    write_dword(&ptr, size);
 
    /* chunk count */
    write_dword(&ptr, dxbc->count);
 
    /* write the chunk offsets */
    for (i = 0; i < dxbc->count; ++i)
    {
        write_dword(&ptr, offset);
        offset += 8 + dxbc->sections[i].data_size;
    }
 
    /* write the chunks */
    for (i = 0; i < dxbc->count; ++i)
    {
        write_dword(&ptr, dxbc->sections[i].tag);
        write_dword(&ptr, dxbc->sections[i].data_size);
        memcpy(ptr, dxbc->sections[i].data, dxbc->sections[i].data_size);
        ptr += dxbc->sections[i].data_size;
    }
 
    TRACE("Created ID3DBlob %p\n", object);
 
    *blob = object;
 
    return S_OK;
}

Referenced by d3dcompiler_get_blob_part(), and d3dcompiler_strip_shader().

expr_common_base_type()

static enum hlsl_base_type expr_common_base_type ( enum hlsl_base_type  t1, enum hlsl_base_type  t2  )

static

Definition at line 1152 of file utils.c.

{
    static const enum hlsl_base_type types[] =
    {
        HLSL_TYPE_BOOL,
        HLSL_TYPE_INT,
        HLSL_TYPE_UINT,
        HLSL_TYPE_HALF,
        HLSL_TYPE_FLOAT,
        HLSL_TYPE_DOUBLE,
    };
    int t1_idx = -1, t2_idx = -1, i;
 
    for (i = 0; i < ARRAY_SIZE(types); ++i)
    {
        /* Always convert away from HLSL_TYPE_HALF */
        if (t1 == types[i])
            t1_idx = t1 == HLSL_TYPE_HALF ? i + 1 : i;
        if (t2 == types[i])
            t2_idx = t2 == HLSL_TYPE_HALF ? i + 1 : i;
 
        if (t1_idx != -1 && t2_idx != -1)
            break;
    }
    if (t1_idx == -1 || t2_idx == -1)
    {
        FIXME("Unexpected base type.\n");
        return HLSL_TYPE_FLOAT;
    }
    return t1_idx >= t2_idx ? t1 : t2;
}

Referenced by expr_common_type().

expr_common_type()

static struct hlsl_type * expr_common_type ( struct hlsl_type *  t1, struct hlsl_type *  t2, struct source_location *  loc  )

static

Definition at line 1184 of file utils.c.

{
    enum hlsl_type_class type;
    enum hlsl_base_type base;
    unsigned int dimx, dimy;
 
    if (t1->type > HLSL_CLASS_LAST_NUMERIC || t2->type > HLSL_CLASS_LAST_NUMERIC)
    {
        hlsl_report_message(loc->file, loc->line, loc->col, HLSL_LEVEL_ERROR,
                "non scalar/vector/matrix data type in expression");
        return NULL;
    }
 
    if (compare_hlsl_types(t1, t2))
        return t1;
 
    if (!expr_compatible_data_types(t1, t2))
    {
        hlsl_report_message(loc->file, loc->line, loc->col, HLSL_LEVEL_ERROR,
                "expression data types are incompatible");
        return NULL;
    }
 
    if (t1->base_type == t2->base_type)
        base = t1->base_type;
    else
        base = expr_common_base_type(t1->base_type, t2->base_type);
 
    if (t1->dimx == 1 && t1->dimy == 1)
    {
        type = t2->type;
        dimx = t2->dimx;
        dimy = t2->dimy;
    }
    else if (t2->dimx == 1 && t2->dimy == 1)
    {
        type = t1->type;
        dimx = t1->dimx;
        dimy = t1->dimy;
    }
    else if (t1->type == HLSL_CLASS_MATRIX && t2->type == HLSL_CLASS_MATRIX)
    {
        type = HLSL_CLASS_MATRIX;
        dimx = min(t1->dimx, t2->dimx);
        dimy = min(t1->dimy, t2->dimy);
    }
    else
    {
        /* Two vectors or a vector and a matrix (matrix must be 1xn or nx1) */
        unsigned int max_dim_1, max_dim_2;
 
        max_dim_1 = max(t1->dimx, t1->dimy);
        max_dim_2 = max(t2->dimx, t2->dimy);
        if (t1->dimx * t1->dimy == t2->dimx * t2->dimy)
        {
            type = HLSL_CLASS_VECTOR;
            dimx = max(t1->dimx, t2->dimx);
            dimy = 1;
        }
        else if (max_dim_1 <= max_dim_2)
        {
            type = t1->type;
            if (type == HLSL_CLASS_VECTOR)
            {
                dimx = max_dim_1;
                dimy = 1;
            }
            else
            {
                dimx = t1->dimx;
                dimy = t1->dimy;
            }
        }
        else
        {
            type = t2->type;
            if (type == HLSL_CLASS_VECTOR)
            {
                dimx = max_dim_2;
                dimy = 1;
            }
            else
            {
                dimx = t2->dimx;
                dimy = t2->dimy;
            }
        }
    }
 
    return new_hlsl_type(NULL, type, base, dimx, dimy);
}

Referenced by new_expr().

expr_compatible_data_types()

static BOOL expr_compatible_data_types ( struct hlsl_type *  t1, struct hlsl_type *  t2  )

static

Definition at line 1118 of file utils.c.

{
    if (t1->base_type > HLSL_TYPE_LAST_SCALAR || t2->base_type > HLSL_TYPE_LAST_SCALAR)
        return FALSE;
 
    /* Scalar vars can be converted to pretty much everything */
    if ((t1->dimx == 1 && t1->dimy == 1) || (t2->dimx == 1 && t2->dimy == 1))
        return TRUE;
 
    if (t1->type == HLSL_CLASS_VECTOR && t2->type == HLSL_CLASS_VECTOR)
        return TRUE;
 
    if (t1->type == HLSL_CLASS_MATRIX || t2->type == HLSL_CLASS_MATRIX)
    {
        /* Matrix-vector conversion is apparently allowed if either they have the same components
           count or the matrix is nx1 or 1xn */
        if (t1->type == HLSL_CLASS_VECTOR || t2->type == HLSL_CLASS_VECTOR)
        {
            if (components_count_type(t1) == components_count_type(t2))
                return TRUE;
 
            return (t1->type == HLSL_CLASS_MATRIX && (t1->dimx == 1 || t1->dimy == 1))
                    || (t2->type == HLSL_CLASS_MATRIX && (t2->dimx == 1 || t2->dimy == 1));
        }
 
        /* Both matrices */
        if ((t1->dimx >= t2->dimx && t1->dimy >= t2->dimy)
                || (t1->dimx <= t2->dimx && t1->dimy <= t2->dimy))
            return TRUE;
    }
 
    return FALSE;
}

Referenced by expr_common_type().

find_function()

BOOL find_function

(

const char *

name

)

Definition at line 852 of file utils.c.

{
    return wine_rb_get(&hlsl_ctx.functions, name) != NULL;
}

free_declaration()

void free_declaration

(

struct hlsl_ir_var *

decl

)

Definition at line 798 of file utils.c.

{
    d3dcompiler_free((void *)decl->name);
    d3dcompiler_free((void *)decl->semantic);
    d3dcompiler_free((void *)decl->reg_reservation);
    d3dcompiler_free(decl);
}

free_function()

static void free_function ( struct hlsl_ir_function *  func )

static

Definition at line 2270 of file utils.c.

{
    wine_rb_destroy(&func->overloads, free_function_decl_rb, NULL);
    d3dcompiler_free((void *)func->name);
    d3dcompiler_free(func);
}

Referenced by free_function_rb().

free_function_decl()

static void free_function_decl ( struct hlsl_ir_function_decl *  decl )

static

Definition at line 2257 of file utils.c.

{
    d3dcompiler_free((void *)decl->semantic);
    d3dcompiler_free(decl->parameters);
    free_instr_list(decl->body);
    d3dcompiler_free(decl);
}

Referenced by add_function_decl(), and free_function_decl_rb().

free_function_decl_rb()

static void free_function_decl_rb ( struct wine_rb_entry *  entry, void *  context  )

static

Definition at line 2265 of file utils.c.

{
    free_function_decl(WINE_RB_ENTRY_VALUE(entry, struct hlsl_ir_function_decl, entry));
}

Referenced by add_function_decl(), and free_function().

free_function_rb()

void free_function_rb	(	struct wine_rb_entry *	entry,
		void *	context
	)

Definition at line 2277 of file utils.c.

{
    free_function(WINE_RB_ENTRY_VALUE(entry, struct hlsl_ir_function, entry));
}

free_hlsl_type()

void free_hlsl_type

(

struct hlsl_type *

type

)

Definition at line 2105 of file utils.c.

{
    struct hlsl_struct_field *field, *next_field;
 
    d3dcompiler_free((void *)type->name);
    if (type->type == HLSL_CLASS_STRUCT)
    {
        LIST_FOR_EACH_ENTRY_SAFE(field, next_field, type->e.elements, struct hlsl_struct_field, entry)
        {
            d3dcompiler_free((void *)field->name);
            d3dcompiler_free((void *)field->semantic);
            d3dcompiler_free(field);
        }
    }
    d3dcompiler_free(type);
}

free_instr()

void free_instr

(

struct hlsl_ir_node *

node

)

Definition at line 2224 of file utils.c.

{
    switch (node->type)
    {
        case HLSL_IR_CONSTANT:
            free_ir_constant(constant_from_node(node));
            break;
        case HLSL_IR_DEREF:
            free_ir_deref(deref_from_node(node));
            break;
        case HLSL_IR_SWIZZLE:
            free_ir_swizzle(swizzle_from_node(node));
            break;
        case HLSL_IR_CONSTRUCTOR:
            free_ir_constructor(constructor_from_node(node));
            break;
        case HLSL_IR_EXPR:
            free_ir_expr(expr_from_node(node));
            break;
        case HLSL_IR_ASSIGNMENT:
            free_ir_assignment(assignment_from_node(node));
            break;
        case HLSL_IR_IF:
            free_ir_if(if_from_node(node));
            break;
        case HLSL_IR_JUMP:
            free_ir_jump(jump_from_node(node));
            break;
        default:
            FIXME("Unsupported node type %s\n", debug_node_type(node->type));
    }
}

Referenced by free_instr_list(), free_ir_assignment(), free_ir_constructor(), free_ir_deref(), free_ir_expr(), free_ir_if(), free_ir_jump(), free_ir_swizzle(), and make_assignment().

free_instr_list()

void free_instr_list

(

struct list *

list

)

Definition at line 2122 of file utils.c.

{
    struct hlsl_ir_node *node, *next_node;
 
    if (!list)
        return;
    LIST_FOR_EACH_ENTRY_SAFE(node, next_node, list, struct hlsl_ir_node, entry)
        free_instr(node);
    d3dcompiler_free(list);
}

Referenced by free_function_decl(), free_ir_expr(), and free_ir_if().

free_ir_assignment()

static void free_ir_assignment ( struct hlsl_ir_assignment *  assignment )

static

Definition at line 2202 of file utils.c.

{
    free_instr(assignment->lhs);
    free_instr(assignment->rhs);
    d3dcompiler_free(assignment);
}

Referenced by free_instr().

free_ir_constant()

static void free_ir_constant ( struct hlsl_ir_constant *  constant )

static

Definition at line 2133 of file utils.c.

{
    struct hlsl_type *type = constant->node.data_type;
    unsigned int i;
    struct hlsl_ir_constant *field, *next_field;
 
    switch (type->type)
    {
        case HLSL_CLASS_ARRAY:
            for (i = 0; i < type->e.array.elements_count; ++i)
                free_ir_constant(&constant->v.array_elements[i]);
            d3dcompiler_free(constant->v.array_elements);
            break;
        case HLSL_CLASS_STRUCT:
            LIST_FOR_EACH_ENTRY_SAFE(field, next_field, constant->v.struct_elements, struct hlsl_ir_constant, node.entry)
                free_ir_constant(field);
            break;
        default:
            break;
    }
    d3dcompiler_free(constant);
}

Referenced by free_instr(), and free_ir_constant().

free_ir_constructor()

static void free_ir_constructor ( struct hlsl_ir_constructor *  constructor )

static

Definition at line 2180 of file utils.c.

{
    unsigned int i;
    for (i = 0; i < constructor->args_count; ++i)
        free_instr(constructor->args[i]);
    d3dcompiler_free(constructor);
}

Referenced by free_instr().

free_ir_deref()

static void free_ir_deref ( struct hlsl_ir_deref *  deref )

static

Definition at line 2156 of file utils.c.

{
    switch (deref->type)
    {
        case HLSL_IR_DEREF_VAR:
            /* Variables are shared among nodes in the tree. */
            break;
        case HLSL_IR_DEREF_ARRAY:
            free_instr(deref->v.array.array);
            free_instr(deref->v.array.index);
            break;
        case HLSL_IR_DEREF_RECORD:
            free_instr(deref->v.record.record);
            break;
    }
    d3dcompiler_free(deref);
}

Referenced by free_instr().

free_ir_expr()

static void free_ir_expr ( struct hlsl_ir_expr *  expr )

static

Definition at line 2188 of file utils.c.

{
    unsigned int i;
 
    for (i = 0; i < 3; ++i)
    {
        if (!expr->operands[i])
            break;
        free_instr(expr->operands[i]);
    }
    free_instr_list(expr->subexpressions);
    d3dcompiler_free(expr);
}

Referenced by free_instr().

free_ir_if()

static void free_ir_if ( struct hlsl_ir_if *  if_node )

static

Definition at line 2209 of file utils.c.

{
    free_instr(if_node->condition);
    free_instr_list(if_node->then_instrs);
    free_instr_list(if_node->else_instrs);
    d3dcompiler_free(if_node);
}

Referenced by free_instr().

free_ir_jump()

static void free_ir_jump ( struct hlsl_ir_jump *  jump )

static

Definition at line 2217 of file utils.c.

{
    if (jump->type == HLSL_IR_JUMP_RETURN)
        free_instr(jump->return_value);
    d3dcompiler_free(jump);
}

Referenced by free_instr().

free_ir_swizzle()

static void free_ir_swizzle ( struct hlsl_ir_swizzle *  swizzle )

static

Definition at line 2174 of file utils.c.

{
    free_instr(swizzle->val);
    d3dcompiler_free(swizzle);
}

Referenced by free_instr().

get_regname()

static const char * get_regname ( const struct shader_reg *  reg )

static

Definition at line 202 of file utils.c.

{
    switch (reg->type)
    {
        case BWRITERSPR_TEMP:
            return wine_dbg_sprintf("r%u", reg->regnum);
        case BWRITERSPR_INPUT:
            return wine_dbg_sprintf("v%u", reg->regnum);
        case BWRITERSPR_CONST:
            return wine_dbg_sprintf("c%u", reg->regnum);
        case BWRITERSPR_ADDR:
            return wine_dbg_sprintf("a%u", reg->regnum);
        case BWRITERSPR_TEXTURE:
            return wine_dbg_sprintf("t%u", reg->regnum);
        case BWRITERSPR_RASTOUT:
            switch (reg->regnum)
            {
                case BWRITERSRO_POSITION:   return "oPos";
                case BWRITERSRO_FOG:        return "oFog";
                case BWRITERSRO_POINT_SIZE: return "oPts";
                default: return "Unexpected RASTOUT";
            }
        case BWRITERSPR_ATTROUT:
            return wine_dbg_sprintf("oD%u", reg->regnum);
        case BWRITERSPR_TEXCRDOUT:
            return wine_dbg_sprintf("oT%u", reg->regnum);
        case BWRITERSPR_OUTPUT:
            return wine_dbg_sprintf("o%u", reg->regnum);
        case BWRITERSPR_CONSTINT:
            return wine_dbg_sprintf("i%u", reg->regnum);
        case BWRITERSPR_COLOROUT:
            return wine_dbg_sprintf("oC%u", reg->regnum);
        case BWRITERSPR_DEPTHOUT:
            return "oDepth";
        case BWRITERSPR_SAMPLER:
            return wine_dbg_sprintf("s%u", reg->regnum);
        case BWRITERSPR_CONSTBOOL:
            return wine_dbg_sprintf("b%u", reg->regnum);
        case BWRITERSPR_LOOP:
            return "aL";
        case BWRITERSPR_MISCTYPE:
            switch (reg->regnum)
            {
                case 0: return "vPos";
                case 1: return "vFace";
                default: return "unexpected misctype";
            }
        case BWRITERSPR_LABEL:
            return wine_dbg_sprintf("l%u", reg->regnum);
        case BWRITERSPR_PREDICATE:
            return wine_dbg_sprintf("p%u", reg->regnum);
        default:
            return wine_dbg_sprintf("unknown regname %#x", reg->type);
    }
}

Referenced by debug_print_dstreg(), and debug_print_srcreg().

get_type()

struct hlsl_type * get_type	(	struct hlsl_scope *	scope,
		const char *	name,
		BOOL	recursive
	)

Definition at line 841 of file utils.c.

{
    struct wine_rb_entry *entry = wine_rb_get(&scope->types, name);
    if (entry)
        return WINE_RB_ENTRY_VALUE(entry, struct hlsl_type, scope_entry);
 
    if (recursive && scope->upper)
        return get_type(scope->upper, name, recursive);
    return NULL;
}

Referenced by get_type(), type_new_coclass(), type_new_encapsulated_union(), and type_new_module().

get_variable()

struct hlsl_ir_var * get_variable	(	struct hlsl_scope *	scope,
		const char *	name
	)

Definition at line 784 of file utils.c.

{
    struct hlsl_ir_var *var;
 
    LIST_FOR_EACH_ENTRY(var, &scope->vars, struct hlsl_ir_var, scope_entry)
    {
        if (!strcmp(name, var->name))
            return var;
    }
    if (!scope->upper)
        return NULL;
    return get_variable(scope->upper, name);
}

Referenced by get_variable().

implicit_compatible_data_types()

static BOOL implicit_compatible_data_types ( struct hlsl_type *  t1, struct hlsl_type *  t2  )

static

Definition at line 1061 of file utils.c.

{
    if (!convertible_data_type(t1) || !convertible_data_type(t2))
        return FALSE;
 
    if (t1->type <= HLSL_CLASS_LAST_NUMERIC)
    {
        /* Scalar vars can be converted to any other numeric data type */
        if (t1->dimx == 1 && t1->dimy == 1 && t2->type <= HLSL_CLASS_LAST_NUMERIC)
            return TRUE;
        /* The other way around is true too */
        if (t2->dimx == 1 && t2->dimy == 1 && t2->type <= HLSL_CLASS_LAST_NUMERIC)
            return TRUE;
    }
 
    if (t1->type == HLSL_CLASS_ARRAY && t2->type == HLSL_CLASS_ARRAY)
    {
        return components_count_type(t1) == components_count_type(t2);
    }
 
    if ((t1->type == HLSL_CLASS_ARRAY && t2->type <= HLSL_CLASS_LAST_NUMERIC)
            || (t1->type <= HLSL_CLASS_LAST_NUMERIC && t2->type == HLSL_CLASS_ARRAY))
    {
        /* e.g. float4[3] to float4 is allowed */
        if (t1->type == HLSL_CLASS_ARRAY && compare_hlsl_types(t1->e.array.type, t2))
            return TRUE;
        if (components_count_type(t1) == components_count_type(t2))
            return TRUE;
        return FALSE;
    }
 
    if (t1->type <= HLSL_CLASS_VECTOR && t2->type <= HLSL_CLASS_VECTOR)
    {
        if (t1->dimx >= t2->dimx)
            return TRUE;
        return FALSE;
    }
 
    if (t1->type == HLSL_CLASS_MATRIX || t2->type == HLSL_CLASS_MATRIX)
    {
        if (t1->type == HLSL_CLASS_MATRIX && t2->type == HLSL_CLASS_MATRIX
                && t1->dimx >= t2->dimx && t1->dimy >= t2->dimy)
            return TRUE;
 
        /* Matrix-vector conversion is apparently allowed if they have the same components count */
        if ((t1->type == HLSL_CLASS_VECTOR || t2->type == HLSL_CLASS_VECTOR)
                && components_count_type(t1) == components_count_type(t2))
            return TRUE;
        return FALSE;
    }
 
    if (t1->type == HLSL_CLASS_STRUCT && t2->type == HLSL_CLASS_STRUCT)
        return compare_hlsl_types(t1, t2);
 
    return FALSE;
}

Referenced by make_assignment().

implicit_conversion()

static struct hlsl_ir_node * implicit_conversion ( struct hlsl_ir_node *  node, struct hlsl_type *  type, struct source_location *  loc  )

static

Definition at line 1277 of file utils.c.

{
    if (compare_hlsl_types(node->data_type, type))
        return node;
    TRACE("Implicit conversion of expression to %s\n", debug_hlsl_type(type));
    return &new_cast(node, type, loc)->node;
}

Referenced by make_assignment(), and new_expr().

init_functions_tree()

void init_functions_tree

(

struct wine_rb_tree *

funcs

)

Definition at line 1662 of file utils.c.

{
    wine_rb_init(&hlsl_ctx.functions, compare_function_rb);
}

make_assignment()

struct hlsl_ir_node * make_assignment	(	struct hlsl_ir_node *	left,
		enum parse_assign_op	assign_op,
		DWORD	writemask,
		struct hlsl_ir_node *	right
	)

Definition at line 1407 of file utils.c.

{
    struct hlsl_ir_assignment *assign = d3dcompiler_alloc(sizeof(*assign));
    struct hlsl_type *type;
    struct hlsl_ir_node *lhs, *rhs;
 
    if (!assign)
    {
        ERR("Out of memory\n");
        return NULL;
    }
 
    TRACE("Creating proper assignment expression.\n");
    rhs = right;
    if (writemask == BWRITERSP_WRITEMASK_ALL)
        type = left->data_type;
    else
    {
        unsigned int dimx = 0;
        DWORD bitmask;
        enum hlsl_type_class type_class;
 
        if (left->data_type->type > HLSL_CLASS_LAST_NUMERIC)
        {
            hlsl_report_message(left->loc.file, left->loc.line, left->loc.col, HLSL_LEVEL_ERROR,
                    "writemask on a non scalar/vector/matrix type");
            d3dcompiler_free(assign);
            return NULL;
        }
        bitmask = writemask & ((1 << left->data_type->dimx) - 1);
        while (bitmask)
        {
            if (bitmask & 1)
                dimx++;
            bitmask >>= 1;
        }
        if (left->data_type->type == HLSL_CLASS_MATRIX)
            FIXME("Assignments with writemasks and matrices on lhs are not supported yet.\n");
        if (dimx == 1)
            type_class = HLSL_CLASS_SCALAR;
        else
            type_class = left->data_type->type;
        type = new_hlsl_type(NULL, type_class, left->data_type->base_type, dimx, 1);
    }
    assign->node.type = HLSL_IR_ASSIGNMENT;
    assign->node.loc = left->loc;
    assign->node.data_type = type;
    assign->writemask = writemask;
    FIXME("Check for casts in the lhs.\n");
 
    lhs = left;
    /* FIXME: check for invalid writemasks on the lhs. */
 
    if (!compare_hlsl_types(type, rhs->data_type))
    {
        struct hlsl_ir_node *converted_rhs;
 
        if (!implicit_compatible_data_types(rhs->data_type, type))
        {
            hlsl_report_message(rhs->loc.file, rhs->loc.line, rhs->loc.col, HLSL_LEVEL_ERROR,
                    "can't implicitly convert %s to %s",
                    debug_hlsl_type(rhs->data_type), debug_hlsl_type(type));
            free_instr(lhs);
            free_instr(rhs);
            d3dcompiler_free(assign);
            return NULL;
        }
        if (lhs->data_type->dimx * lhs->data_type->dimy < rhs->data_type->dimx * rhs->data_type->dimy)
            hlsl_report_message(rhs->loc.file, rhs->loc.line, rhs->loc.col, HLSL_LEVEL_WARNING,
                    "implicit truncation of vector type");
 
        converted_rhs = implicit_conversion(rhs, type, &rhs->loc);
        if (!converted_rhs)
        {
            ERR("Couldn't implicitly convert expression to %s.\n", debug_hlsl_type(type));
            free_instr(lhs);
            free_instr(rhs);
            d3dcompiler_free(assign);
            return NULL;
        }
        rhs = converted_rhs;
    }
 
    assign->lhs = lhs;
    if (assign_op != ASSIGN_OP_ASSIGN)
    {
        enum hlsl_ir_expr_op op = op_from_assignment(assign_op);
        struct hlsl_ir_node *expr;
 
        if (lhs->type != HLSL_IR_DEREF || deref_from_node(lhs)->type != HLSL_IR_DEREF_VAR)
        {
            FIXME("LHS expression not supported in compound assignments yet.\n");
            assign->rhs = rhs;
        }
        else
        {
            struct hlsl_ir_deref *lhs_deref = deref_from_node(lhs), *new_deref;
 
            TRACE("Adding an expression for the compound assignment.\n");
            new_deref = new_var_deref(lhs_deref->v.var);
            expr = new_binary_expr(op, &new_deref->node, rhs, left->loc);
            assign->rhs = expr;
        }
    }
    else
        assign->rhs = rhs;
 
    return &assign->node;
}

new_array_type()

struct hlsl_type * new_array_type	(	struct hlsl_type *	basic_type,
		unsigned int	array_size
	)

Definition at line 828 of file utils.c.

{
    struct hlsl_type *type = new_hlsl_type(NULL, HLSL_CLASS_ARRAY, HLSL_TYPE_FLOAT, 1, 1);
 
    if (!type)
        return NULL;
 
    type->modifiers = basic_type->modifiers;
    type->e.array.elements_count = array_size;
    type->e.array.type = basic_type;
    return type;
}

new_cast()

struct hlsl_ir_expr * new_cast	(	struct hlsl_ir_node *	node,
		struct hlsl_type *	type,
		struct source_location *	loc
	)

Definition at line 1343 of file utils.c.

{
    struct hlsl_ir_node *cast;
 
    cast = new_unary_expr(HLSL_IR_UNOP_CAST, node, *loc);
    if (cast)
        cast->data_type = type;
    return expr_from_node(cast);
}

Referenced by implicit_conversion().

new_expr()

struct hlsl_ir_expr * new_expr	(	enum hlsl_ir_expr_op	op,
		struct hlsl_ir_node **	operands,
		struct source_location *	loc
	)

Definition at line 1286 of file utils.c.

{
    struct hlsl_ir_expr *expr = d3dcompiler_alloc(sizeof(*expr));
    struct hlsl_type *type;
    unsigned int i;
 
    if (!expr)
    {
        ERR("Out of memory\n");
        return NULL;
    }
    expr->node.type = HLSL_IR_EXPR;
    expr->node.loc = *loc;
    type = operands[0]->data_type;
    for (i = 1; i <= 2; ++i)
    {
        if (!operands[i])
            break;
        type = expr_common_type(type, operands[i]->data_type, loc);
        if (!type)
        {
            d3dcompiler_free(expr);
            return NULL;
        }
    }
    for (i = 0; i <= 2; ++i)
    {
        if (!operands[i])
            break;
        if (compare_hlsl_types(operands[i]->data_type, type))
            continue;
        TRACE("Implicitly converting %s into %s in an expression\n", debug_hlsl_type(operands[i]->data_type), debug_hlsl_type(type));
        if (operands[i]->data_type->dimx * operands[i]->data_type->dimy != 1
                && operands[i]->data_type->dimx * operands[i]->data_type->dimy != type->dimx * type->dimy)
        {
            hlsl_report_message(operands[i]->loc.file,
                    operands[i]->loc.line, operands[i]->loc.col, HLSL_LEVEL_WARNING,
                    "implicit truncation of vector/matrix type");
        }
        operands[i] = implicit_conversion(operands[i], type, &operands[i]->loc);
        if (!operands[i])
        {
            ERR("Impossible to convert expression operand %u to %s\n", i + 1, debug_hlsl_type(type));
            d3dcompiler_free(expr);
            return NULL;
        }
    }
    expr->node.data_type = type;
    expr->op = op;
    expr->operands[0] = operands[0];
    expr->operands[1] = operands[1];
    expr->operands[2] = operands[2];
 
    return expr;
}

Referenced by new_binary_expr(), and new_unary_expr().

new_func_decl()

struct hlsl_ir_function_decl * new_func_decl	(	struct hlsl_type *	return_type,
		struct list *	parameters
	)

Definition at line 1562 of file utils.c.

{
    struct hlsl_ir_function_decl *decl;
 
    decl = d3dcompiler_alloc(sizeof(*decl));
    if (!decl)
    {
        ERR("Out of memory.\n");
        return NULL;
    }
    decl->return_type = return_type;
    decl->parameters = parameters;
 
    return decl;
}

new_hlsl_type()

struct hlsl_type * new_hlsl_type	(	const char *	name,
		enum hlsl_type_class	type_class,
		enum hlsl_base_type	base_type,
		unsigned	dimx,
		unsigned	dimy
	)

Definition at line 806 of file utils.c.

{
    struct hlsl_type *type;
 
    type = d3dcompiler_alloc(sizeof(*type));
    if (!type)
    {
        ERR("Out of memory\n");
        return NULL;
    }
    type->name = name;
    type->type = type_class;
    type->base_type = base_type;
    type->dimx = dimx;
    type->dimy = dimy;
 
    list_add_tail(&hlsl_ctx.types, &type->entry);
 
    return type;
}

Referenced by expr_common_type(), make_assignment(), and new_array_type().

new_record_deref()

struct hlsl_ir_deref * new_record_deref	(	struct hlsl_ir_node *	record,
		struct hlsl_struct_field *	field
	)

Definition at line 1370 of file utils.c.

{
    struct hlsl_ir_deref *deref = d3dcompiler_alloc(sizeof(*deref));
 
    if (!deref)
    {
        ERR("Out of memory.\n");
        return NULL;
    }
    deref->node.type = HLSL_IR_DEREF;
    deref->node.data_type = field->type;
    deref->type = HLSL_IR_DEREF_RECORD;
    deref->v.record.record = record;
    deref->v.record.field = field;
    return deref;
}

new_var_deref()

struct hlsl_ir_deref * new_var_deref

(

struct hlsl_ir_var *

var

)

Definition at line 1354 of file utils.c.

{
    struct hlsl_ir_deref *deref = d3dcompiler_alloc(sizeof(*deref));
 
    if (!deref)
    {
        ERR("Out of memory.\n");
        return NULL;
    }
    deref->node.type = HLSL_IR_DEREF;
    deref->node.data_type = var->data_type;
    deref->type = HLSL_IR_DEREF_VAR;
    deref->v.var = var;
    return deref;
}

Referenced by make_assignment().

op_from_assignment()

static enum hlsl_ir_expr_op op_from_assignment ( enum parse_assign_op  op )

static

Definition at line 1387 of file utils.c.

{
    static const enum hlsl_ir_expr_op ops[] =
    {
        0,
        HLSL_IR_BINOP_ADD,
        HLSL_IR_BINOP_SUB,
        HLSL_IR_BINOP_MUL,
        HLSL_IR_BINOP_DIV,
        HLSL_IR_BINOP_MOD,
        HLSL_IR_BINOP_LSHIFT,
        HLSL_IR_BINOP_RSHIFT,
        HLSL_IR_BINOP_BIT_AND,
        HLSL_IR_BINOP_BIT_OR,
        HLSL_IR_BINOP_BIT_XOR,
    };
 
    return ops[op];
}

Referenced by make_assignment().

pop_scope()

BOOL pop_scope

(

struct hlsl_parse_ctx *

ctx

)

Definition at line 1551 of file utils.c.

{
    struct hlsl_scope *prev_scope = ctx->cur_scope->upper;
    if (!prev_scope)
        return FALSE;
 
    TRACE("Popping current scope\n");
    ctx->cur_scope = prev_scope;
    return TRUE;
}

push_scope()

void push_scope

(

struct hlsl_parse_ctx *

ctx

)

Definition at line 1534 of file utils.c.

{
    struct hlsl_scope *new_scope = d3dcompiler_alloc(sizeof(*new_scope));
 
    if (!new_scope)
    {
        ERR("Out of memory!\n");
        return;
    }
    TRACE("Pushing a new scope\n");
    list_init(&new_scope->vars);
    wine_rb_init(&new_scope->types, compare_hlsl_types_rb);
    new_scope->upper = ctx->cur_scope;
    ctx->cur_scope = new_scope;
    list_add_tail(&ctx->scopes, &new_scope->entry);
}

skip_dword_unknown()

void skip_dword_unknown	(	const char **	ptr,
		unsigned int	count
	)

Definition at line 510 of file utils.c.

{
    unsigned int i;
    DWORD d;
 
    FIXME("Skipping %u unknown DWORDs:\n", count);
    for (i = 0; i < count; ++i)
    {
        read_dword(ptr, &d);
        FIXME("\t0x%08x\n", d);
    }
}

Referenced by d3dcompiler_parse_rdef(), d3dcompiler_parse_signature(), d3dcompiler_parse_stat(), d3dcompiler_parse_type(), d3dcompiler_parse_variables(), and dxbc_parse().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

d3dcompiler

)

write_dword_unknown()

static void write_dword_unknown ( char **  ptr, DWORD  d  )

static

Definition at line 523 of file utils.c.

{
    FIXME("Writing unknown DWORD 0x%08x\n", d);
    write_dword(ptr, d);
}

Referenced by dxbc_write_blob().