~mmach/netext73/mesa_2004

static const char * const tex_opcode_strs[] = { "tex", "txb", "txl", "txd", "txf", "txf_ms", "txs", "lod", "tg4", "query_levels", "texture_samples", "samples_identical" };

1776

1777

const char *ir_texture::opcode_string()

1778

{

1779

assert((unsigned int) op < ARRAY_SIZE(tex_opcode_strs));

1780

return tex_opcode_strs[op];

1781

}

1782

1783

ir_texture_opcode

1784

ir_texture::get_opcode(const char *str)

1785

{

1786

const int count = sizeof(tex_opcode_strs) / sizeof(tex_opcode_strs[0]);

1787

for (int op = 0; op < count; op++) {

1788

if (strcmp(str, tex_opcode_strs[op]) == 0)

1789

return (ir_texture_opcode) op;

1790

}

1791

return (ir_texture_opcode) -1;

1792

}

1793

1794

1795

void

1796

ir_texture::set_sampler(ir_dereference *sampler, const glsl_type *type)

1797

{

1798

assert(sampler != NULL);

1799

assert(type != NULL);

1800

this->sampler = sampler;

1801

1802

if (this->is_sparse) {

1803

/* code holds residency info */

1804

glsl_struct_field fields[2] = {

1805

glsl_struct_field(glsl_type::int_type, "code"),

1806

glsl_struct_field(type, "texel"),

1807

};

1808

this->type = glsl_type::get_struct_instance(fields, 2, "struct");

1809

} else

1810

this->type = type;

1811

1812

if (this->op == ir_txs || this->op == ir_query_levels ||

1813

this->op == ir_texture_samples) {

1814

assert(type->base_type == GLSL_TYPE_INT);

1815

} else if (this->op == ir_lod) {

1816

assert(type->vector_elements == 2);

1817

assert(type->is_float());

1818

} else if (this->op == ir_samples_identical) {

1819

assert(type == glsl_type::bool_type);

1820

assert(sampler->type->is_sampler());

1821

assert(sampler->type->sampler_dimensionality == GLSL_SAMPLER_DIM_MS);

1822

} else {

1823

assert(sampler->type->sampled_type == (int) type->base_type);

1824

if (sampler->type->sampler_shadow)

1825

assert(type->vector_elements == 4 || type->vector_elements == 1);

1826

else

1827

assert(type->vector_elements == 4);

1828

}

1829

}

1830

1831

1832

void

1833

ir_swizzle::init_mask(const unsigned *comp, unsigned count)

1834

{

1835

assert((count >= 1) && (count <= 4));

1836

1837

memset(&this->mask, 0, sizeof(this->mask));

1838

this->mask.num_components = count;

1839

1840

unsigned dup_mask = 0;

1841

switch (count) {

1842

case 4:

1843

assert(comp[3] <= 3);

1844

dup_mask |= (1U << comp[3])

1845

& ((1U << comp[0]) | (1U << comp[1]) | (1U << comp[2]));

1846

this->mask.w = comp[3];

1847

1848

case 3:

1849

assert(comp[2] <= 3);

1850

dup_mask |= (1U << comp[2])

1851

& ((1U << comp[0]) | (1U << comp[1]));

1852

this->mask.z = comp[2];

1853

1854

case 2:

1855

assert(comp[1] <= 3);

1856

dup_mask |= (1U << comp[1])

1857

& ((1U << comp[0]));

1858

this->mask.y = comp[1];

1859

1860

case 1:

1861

assert(comp[0] <= 3);

1862

this->mask.x = comp[0];

1863

}

1864

1865

this->mask.has_duplicates = dup_mask != 0;

1866

1867

/* Based on the number of elements in the swizzle and the base type

1868

* (i.e., float, int, unsigned, or bool) of the vector being swizzled,

1869

* generate the type of the resulting value.

1870

1871

type = glsl_type::get_instance(val->type->base_type, mask.num_components, 1);

1872

}

1873

1874

ir_swizzle::ir_swizzle(ir_rvalue *val, unsigned x, unsigned y, unsigned z,

1875

unsigned w, unsigned count)

1876

: ir_rvalue(ir_type_swizzle), val(val)

1877

{

1878

const unsigned components[4] = { x, y, z, w };

1879

this->init_mask(components, count);

1880

}

1881

1882

ir_swizzle::ir_swizzle(ir_rvalue *val, const unsigned *comp,

1883

unsigned count)

1884

: ir_rvalue(ir_type_swizzle), val(val)

1885

{

1886

this->init_mask(comp, count);

1887

}

1888

1889

ir_swizzle::ir_swizzle(ir_rvalue *val, ir_swizzle_mask mask)

1890

: ir_rvalue(ir_type_swizzle), val(val), mask(mask)

1891

{

1892

this->type = glsl_type::get_instance(val->type->base_type,

1893

mask.num_components, 1);

1894

}

1895

1896

#define X 1

1897

#define R 5

1898

#define S 9

1899

#define I 13

1900

1901

ir_swizzle *

1902

ir_swizzle::create(ir_rvalue *val, const char *str, unsigned vector_length)

1903

{

1904

void *ctx = ralloc_parent(val);

1905

1906

/* For each possible swizzle character, this table encodes the value in

1907

* \c idx_map that represents the 0th element of the vector. For invalid

1908

* swizzle characters (e.g., 'k'), a special value is used that will allow

1909

* detection of errors.

1910

1911

static const unsigned char base_idx[26] = {

1912

/* a b c d e f g h i j k l m */

1913

R, R, I, I, I, I, R, I, I, I, I, I, I,

1914

/* n o p q r s t u v w x y z */

1915

I, I, S, S, R, S, S, I, I, X, X, X, X

1916

};

1917

1918

/* Each valid swizzle character has an entry in the previous table. This

1919

* table encodes the base index encoded in the previous table plus the actual

1920

* index of the swizzle character. When processing swizzles, the first

1921

* character in the string is indexed in the previous table. Each character

1922

* in the string is indexed in this table, and the value found there has the

1923

* value form the first table subtracted. The result must be on the range

1924

* [0,3].

1925

1926

* For example, the string "wzyx" will get X from the first table. Each of

1927

* the charcaters will get X+3, X+2, X+1, and X+0 from this table. After

1928

* subtraction, the swizzle values are { 3, 2, 1, 0 }.

1929

1930

* The string "wzrg" will get X from the first table. Each of the characters

1931

* will get X+3, X+2, R+0, and R+1 from this table. After subtraction, the

1932

* swizzle values are { 3, 2, 4, 5 }. Since 4 and 5 are outside the range

1933

* [0,3], the error is detected.

1934

1935

static const unsigned char idx_map[26] = {

1936

/* a b c d e f g h i j k l m */

1937

R+3, R+2, 0, 0, 0, 0, R+1, 0, 0, 0, 0, 0, 0,

1938

/* n o p q r s t u v w x y z */

1939

0, 0, S+2, S+3, R+0, S+0, S+1, 0, 0, X+3, X+0, X+1, X+2

1940

};

1941

1942

int swiz_idx[4] = { 0, 0, 0, 0 };

1943

unsigned i;

1944

1945

1946

/* Validate the first character in the swizzle string and look up the base

1947

* index value as described above.

1948

1949

if ((str[0] < 'a') || (str[0] > 'z'))

1950

return NULL;

1951

1952

const unsigned base = base_idx[str[0] - 'a'];

1953

1954

1955

for (i = 0; (i < 4) && (str[i] != '\0'); i++) {

1956

/* Validate the next character, and, as described above, convert it to a

1957

* swizzle index.

1958

1959

if ((str[i] < 'a') || (str[i] > 'z'))

1960

return NULL;

1961

1962

swiz_idx[i] = idx_map[str[i] - 'a'] - base;

1963

if ((swiz_idx[i] < 0) || (swiz_idx[i] >= (int) vector_length))

1964

return NULL;

1965

}

1966

1967

if (str[i] != '\0')

1968

return NULL;

1969

1970

return new(ctx) ir_swizzle(val, swiz_idx[0], swiz_idx[1], swiz_idx[2],

1971

swiz_idx[3], i);

1972

}

1973

1974

#undef X

1975

#undef R

1976

#undef S

1977

#undef I

1978

1979

ir_variable *

1980

ir_swizzle::variable_referenced() const

1981

{

1982

return this->val->variable_referenced();

1983

}

1984

1985

1986

bool ir_variable::temporaries_allocate_names = false;

1987

1988

const char ir_variable::tmp_name[] = "compiler_temp";

1989

1990

ir_variable::ir_variable(const struct glsl_type *type, const char *name,

1991

ir_variable_mode mode)

1992

: ir_instruction(ir_type_variable)

1993

{

1994

this->type = type;

1995

1996

if (mode == ir_var_temporary && !ir_variable::temporaries_allocate_names)

1997

name = NULL;

1998

1999

/* The ir_variable clone method may call this constructor with name set to

2000

* tmp_name.

2001

2002

assert(name != NULL

2003

|| mode == ir_var_temporary

2004

|| mode == ir_var_function_in

2005

|| mode == ir_var_function_out

2006

|| mode == ir_var_function_inout);

2007

assert(name != ir_variable::tmp_name

2008

|| mode == ir_var_temporary);

2009

if (mode == ir_var_temporary

2010

&& (name == NULL || name == ir_variable::tmp_name)) {

2011

this->name = ir_variable::tmp_name;

2012

} else if (name == NULL ||

2013

strlen(name) < ARRAY_SIZE(this->name_storage)) {

2014

strcpy(this->name_storage, name ? name : "");

2015

this->name = this->name_storage;

2016

} else {

2017

this->name = ralloc_strdup(this, name);

2018

}

2019

2020

this->u.max_ifc_array_access = NULL;

2021

2022

this->data.explicit_location = false;

2023

this->data.explicit_index = false;

2024

this->data.explicit_binding = false;

2025

this->data.explicit_component = false;

2026

this->data.has_initializer = false;

2027

this->data.is_implicit_initializer = false;

2028

this->data.is_xfb = false;

2029

this->data.is_xfb_only = false;

2030

this->data.explicit_xfb_buffer = false;

2031

this->data.explicit_xfb_offset = false;

2032

this->data.explicit_xfb_stride = false;

2033

this->data.location = -1;

2034

this->data.location_frac = 0;

2035

this->data.matrix_layout = GLSL_MATRIX_LAYOUT_INHERITED;

2036

this->data.from_named_ifc_block = false;

2037

this->data.must_be_shader_input = false;

2038

this->data.index = 0;

2039

this->data.binding = 0;

2040

this->data.warn_extension_index = 0;

2041

this->constant_value = NULL;

2042

this->constant_initializer = NULL;

2043

this->data.depth_layout = ir_depth_layout_none;

2044

this->data.used = false;

2045

this->data.assigned = false;

2046

this->data.always_active_io = false;

2047

this->data.read_only = false;

2048

this->data.centroid = false;

2049

this->data.sample = false;

2050

this->data.patch = false;

2051

this->data.explicit_invariant = false;

2052

this->data.invariant = false;

2053

this->data.precise = false;

2054

this->data.how_declared = ir_var_declared_normally;

2055

this->data.mode = mode;

2056

this->data.interpolation = INTERP_MODE_NONE;

2057

this->data.max_array_access = -1;

2058

this->data.offset = 0;

2059

this->data.precision = GLSL_PRECISION_NONE;

2060

this->data.memory_read_only = false;

2061

this->data.memory_write_only = false;

2062

this->data.memory_coherent = false;

2063

this->data.memory_volatile = false;

2064

this->data.memory_restrict = false;

2065

this->data.from_ssbo_unsized_array = false;

2066

this->data.implicit_sized_array = false;

2067

this->data.fb_fetch_output = false;

2068

this->data.bindless = false;

2069

this->data.bound = false;

2070

this->data.image_format = PIPE_FORMAT_NONE;

2071

this->data._num_state_slots = 0;

2072

this->data.param_index = 0;

2073

this->data.stream = 0;

2074

this->data.xfb_buffer = -1;

2075

this->data.xfb_stride = -1;

2076

this->data.implicit_conversion_prohibited = false;

2077

2078

this->interface_type = NULL;

2079

2080

if (type != NULL) {

2081

if (type->is_interface())

2082

this->init_interface_type(type);

2083

else if (type->without_array()->is_interface())

2084

this->init_interface_type(type->without_array());

2085

}

2086

}

2087

2088

2089

const char *

2090

interpolation_string(unsigned interpolation)

2091

{

2092

switch (interpolation) {

2093

case INTERP_MODE_NONE: return "no";

2094

case INTERP_MODE_SMOOTH: return "smooth";

2095

case INTERP_MODE_FLAT: return "flat";

2096

case INTERP_MODE_NOPERSPECTIVE: return "noperspective";

2097

}

2098

2099

assert(!"Should not get here.");

2100

return "";

2101

}

2102

2103

const char *const ir_variable::warn_extension_table[] = {

2104

"",

2105

"GL_ARB_shader_stencil_export",

2106

"GL_AMD_shader_stencil_export",

2107

};

2108

2109

void

2110

ir_variable::enable_extension_warning(const char *extension)

2111

{

2112

for (unsigned i = 0; i < ARRAY_SIZE(warn_extension_table); i++) {

2113

if (strcmp(warn_extension_table[i], extension) == 0) {

2114

this->data.warn_extension_index = i;

2115

return;

2116

}

2117

}

2118

2119

assert(!"Should not get here.");

2120

this->data.warn_extension_index = 0;

2121

}

2122

2123

const char *

2124

ir_variable::get_extension_warning() const

2125

{

2126

return this->data.warn_extension_index == 0

2127

? NULL : warn_extension_table[this->data.warn_extension_index];

2128

}

2129

2130

ir_function_signature::ir_function_signature(const glsl_type *return_type,

2131

builtin_available_predicate b)

2132

: ir_instruction(ir_type_function_signature),

2133

return_type(return_type), is_defined(false),

2134

return_precision(GLSL_PRECISION_NONE),

2135

intrinsic_id(ir_intrinsic_invalid), builtin_avail(b), _function(NULL)

2136

{

2137

this->origin = NULL;

2138

}

2139

2140

2141

bool

2142

ir_function_signature::is_builtin() const

2143

{

2144

return builtin_avail != NULL;

2145

}

2146

2147

2148

bool

2149

ir_function_signature::is_builtin_available(const _mesa_glsl_parse_state *state) const

2150

{

2151

/* We can't call the predicate without a state pointer, so just say that

2152

* the signature is available. At compile time, we need the filtering,

2153

* but also receive a valid state pointer. At link time, we're resolving

2154

* imported built-in prototypes to their definitions, which will always

2155

* be an exact match. So we can skip the filtering.

2156

2157

if (state == NULL)

2158

return true;

2159

2160

assert(builtin_avail != NULL);

2161

return builtin_avail(state);

2162

}

2163

2164

2165

static bool

2166

modes_match(unsigned a, unsigned b)

2167

{

2168

if (a == b)

2169

return true;

2170

2171

/* Accept "in" vs. "const in" */

2172

if ((a == ir_var_const_in && b == ir_var_function_in) ||

2173

(b == ir_var_const_in && a == ir_var_function_in))

2174

return true;

2175

2176

return false;

2177

}

2178

2179

2180

const char *

2181

ir_function_signature::qualifiers_match(exec_list *params)

2182

{

2183

/* check that the qualifiers match. */

2184

foreach_two_lists(a_node, &this->parameters, b_node, params) {

2185

ir_variable *a = (ir_variable *) a_node;

2186

ir_variable *b = (ir_variable *) b_node;

2187

2188

if (a->data.read_only != b->data.read_only ||

2189

!modes_match(a->data.mode, b->data.mode) ||

2190

a->data.interpolation != b->data.interpolation ||

2191

a->data.centroid != b->data.centroid ||

2192

a->data.sample != b->data.sample ||

2193

a->data.patch != b->data.patch ||

2194

a->data.memory_read_only != b->data.memory_read_only ||

2195

a->data.memory_write_only != b->data.memory_write_only ||

2196

a->data.memory_coherent != b->data.memory_coherent ||

2197

a->data.memory_volatile != b->data.memory_volatile ||

2198

a->data.memory_restrict != b->data.memory_restrict) {

2199

2200

/* parameter a's qualifiers don't match */

2201

return a->name;

2202

}

2203

}

2204

return NULL;

2205

}

2206

2207

2208

void

2209

ir_function_signature::replace_parameters(exec_list *new_params)

2210

{

2211

/* Destroy all of the previous parameter information. If the previous

2212

* parameter information comes from the function prototype, it may either

2213

* specify incorrect parameter names or not have names at all.

2214

2215

new_params->move_nodes_to(&parameters);

2216

}

2217

2218

2219

ir_function::ir_function(const char *name)

2220

: ir_instruction(ir_type_function)

2221

{

2222

this->subroutine_index = -1;

2223

this->name = ralloc_strdup(this, name);

2224

}

2225

2226

2227

bool

2228

ir_function::has_user_signature()

2229

{

2230

foreach_in_list(ir_function_signature, sig, &this->signatures) {

2231

if (!sig->is_builtin())

2232

return true;

2233

}

2234

return false;

2235

}

2236

2237

2238

ir_rvalue *

2239

ir_rvalue::error_value(void *mem_ctx)

2240

{

2241

ir_rvalue *v = new(mem_ctx) ir_rvalue(ir_type_unset);

2242

2243

v->type = glsl_type::error_type;

2244

return v;

2245

}

2246

2247

2248

void

2249

visit_exec_list(exec_list *list, ir_visitor *visitor)

2250

{

2251

foreach_in_list_safe(ir_instruction, node, list) {

2252

node->accept(visitor);

2253

}

2254

}

2255

2256

2257

static void

2258

steal_memory(ir_instruction *ir, void *new_ctx)

2259

{

2260

ir_variable *var = ir->as_variable();

2261

ir_function *fn = ir->as_function();

2262

ir_constant *constant = ir->as_constant();

2263

if (var != NULL && var->constant_value != NULL)

2264

steal_memory(var->constant_value, ir);

2265

2266

if (var != NULL && var->constant_initializer != NULL)

2267

steal_memory(var->constant_initializer, ir);

2268

2269

if (fn != NULL && fn->subroutine_types)

2270

ralloc_steal(new_ctx, fn->subroutine_types);

2271

2272

/* The components of aggregate constants are not visited by the normal

2273

* visitor, so steal their values by hand.

2274

2275

if (constant != NULL &&

2276

(constant->type->is_array() || constant->type->is_struct())) {

2277

for (unsigned int i = 0; i < constant->type->length; i++) {

2278

steal_memory(constant->const_elements[i], ir);

2279

}

2280

}

2281

2282

ralloc_steal(new_ctx, ir);

2283

}

2284

2285

2286

void

2287

reparent_ir(exec_list *list, void *mem_ctx)

2288

{

2289

foreach_in_list(ir_instruction, node, list) {

2290

visit_tree(node, steal_memory, mem_ctx);

2291

}

2292

}

2293

2294

2295

static ir_rvalue *

2296

try_min_one(ir_rvalue *ir)

2297

{

2298

ir_expression *expr = ir->as_expression();

2299

2300

if (!expr || expr->operation != ir_binop_min)

2301

return NULL;

2302

2303

if (expr->operands[0]->is_one())

2304

return expr->operands[1];

2305

2306

if (expr->operands[1]->is_one())

2307

return expr->operands[0];

2308

2309

return NULL;

2310

}

2311

2312

static ir_rvalue *

2313

try_max_zero(ir_rvalue *ir)

2314

{

2315

ir_expression *expr = ir->as_expression();

2316

2317

if (!expr || expr->operation != ir_binop_max)

2318

return NULL;

2319

2320

if (expr->operands[0]->is_zero())

2321

return expr->operands[1];

2322

2323

if (expr->operands[1]->is_zero())

2324

return expr->operands[0];

2325

2326

return NULL;

2327

}

2328

2329

ir_rvalue *

2330

ir_rvalue::as_rvalue_to_saturate()

2331

{

2332

ir_expression *expr = this->as_expression();

2333

2334

if (!expr)

2335

return NULL;

2336

2337

ir_rvalue *max_zero = try_max_zero(expr);

2338

if (max_zero) {

2339

return try_min_one(max_zero);

2340

} else {

2341

ir_rvalue *min_one = try_min_one(expr);

2342

if (min_one) {

2343

return try_max_zero(min_one);

2344

}

2345

}

2346

2347

return NULL;

2348

}

2349

2350

2351

unsigned

2352

vertices_per_prim(GLenum prim)

2353

{

2354

switch (prim) {

2355

case GL_POINTS:

2356

return 1;

2357

case GL_LINES:

2358

return 2;

2359

case GL_TRIANGLES:

2360

return 3;

2361

case GL_LINES_ADJACENCY:

2362

return 4;

2363

case GL_TRIANGLES_ADJACENCY:

2364

return 6;

2365

default:

2366

assert(!"Bad primitive");

2367

return 3;

2368

}

2369

}

2370

2371

/**

2372

* Generate a string describing the mode of a variable

2373

2374

const char *

2375

mode_string(const ir_variable *var)

2376

{

2377

switch (var->data.mode) {

2378

case ir_var_auto:

2379

return (var->data.read_only) ? "global constant" : "global variable";

2380

2381

case ir_var_uniform:

2382

return "uniform";

2383

2384

case ir_var_shader_storage:

2385

return "buffer";

2386

2387

case ir_var_shader_in:

2388

return "shader input";

2389

2390

case ir_var_shader_out:

2391

return "shader output";

2392

2393

case ir_var_function_in:

2394

case ir_var_const_in:

2395

return "function input";

2396

2397

case ir_var_function_out:

2398

return "function output";

2399

2400

case ir_var_function_inout:

2401

return "function inout";

2402

2403

case ir_var_system_value:

2404

return "shader input";

2405

2406

case ir_var_temporary:

2407

return "compiler temporary";

2408

2409

case ir_var_mode_count:

2410

break;

2411

}

2412

2413

assert(!"Should not get here.");

2414

return "invalid variable";

2415

}

Older »