src/mesa/shader/slang/slang_codegen.c

   1 /*
   2  * Mesa 3-D graphics library
   3  * Version:  7.1
   4  *
   5  * Copyright (C) 2005-2007  Brian Paul   All Rights Reserved.
   6  *
   7  * Permission is hereby granted, free of charge, to any person obtaining a
   8  * copy of this software and associated documentation files (the "Software"),
   9  * to deal in the Software without restriction, including without limitation
  10  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  11  * and/or sell copies of the Software, and to permit persons to whom the
  12  * Software is furnished to do so, subject to the following conditions:
  13  *
  14  * The above copyright notice and this permission notice shall be included
  15  * in all copies or substantial portions of the Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  18  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  20  * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  21  * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  22  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  23  */
  24
  25 /**
  26  * \file slang_codegen.c
  27  * Generate IR tree from AST.
  28  * \author Brian Paul
  29  */
  30
  31
  32 /***
  33  *** NOTES:
  34  *** The new_() functions return a new instance of a simple IR node.
  35  *** The gen_() functions generate larger IR trees from the simple nodes.
  36  ***/
  37
  38
  39
  40 #include "main/imports.h"
  41 #include "main/macros.h"
  42 #include "main/mtypes.h"
  43 #include "shader/program.h"
  44 #include "shader/prog_instruction.h"
  45 #include "shader/prog_parameter.h"
  46 #include "shader/prog_print.h"
  47 #include "shader/prog_statevars.h"
  48 #include "slang_typeinfo.h"
  49 #include "slang_codegen.h"
  50 #include "slang_compile.h"
  51 #include "slang_label.h"
  52 #include "slang_mem.h"
  53 #include "slang_simplify.h"
  54 #include "slang_emit.h"
  55 #include "slang_vartable.h"
  56 #include "slang_ir.h"
  57 #include "slang_print.h"
  58
  59
  60 static slang_ir_node *
  61 _slang_gen_operation(slang_assemble_ctx * A, slang_operation *oper);
  62
  63
  64 static GLboolean
  65 is_sampler_type(const slang_fully_specified_type *t)
  66 {
  67    switch (t->specifier.type) {
  68    case SLANG_SPEC_SAMPLER1D:
  69    case SLANG_SPEC_SAMPLER2D:
  70    case SLANG_SPEC_SAMPLER3D:
  71    case SLANG_SPEC_SAMPLERCUBE:
  72    case SLANG_SPEC_SAMPLER1DSHADOW:
  73    case SLANG_SPEC_SAMPLER2DSHADOW:
  74    case SLANG_SPEC_SAMPLER2DRECT:
  75    case SLANG_SPEC_SAMPLER2DRECTSHADOW:
  76       return GL_TRUE;
  77    default:
  78       return GL_FALSE;
  79    }
  80 }
  81
  82
  83 /**
  84  * Return the offset (in floats or ints) of the named field within
  85  * the given struct.  Return -1 if field not found.
  86  * If field is NULL, return the size of the struct instead.
  87  */
  88 static GLint
  89 _slang_field_offset(const slang_type_specifier *spec, slang_atom field)
  90 {
  91    GLint offset = 0;
  92    GLuint i;
  93    for (i = 0; i < spec->_struct->fields->num_variables; i++) {
  94       const slang_variable *v = spec->_struct->fields->variables[i];
  95       const GLuint sz = _slang_sizeof_type_specifier(&v->type.specifier);
  96       if (sz > 1) {
  97          /* types larger than 1 float are register (4-float) aligned */
  98          offset = (offset + 3) & ~3;
  99       }
 100       if (field && v->a_name == field) {
 101          return offset;
 102       }
 103       offset += sz;
 104    }
 105    if (field)
 106       return -1; /* field not found */
 107    else
 108       return offset;  /* struct size */
 109 }
 110
 111
 112 /**
 113  * Return the size (in floats) of the given type specifier.
 114  * If the size is greater than 4, the size should be a multiple of 4
 115  * so that the correct number of 4-float registers are allocated.
 116  * For example, a mat3x2 is size 12 because we want to store the
 117  * 3 columns in 3 float[4] registers.
 118  */
 119 GLuint
 120 _slang_sizeof_type_specifier(const slang_type_specifier *spec)
 121 {
 122    GLuint sz;
 123    switch (spec->type) {
 124    case SLANG_SPEC_VOID:
 125       sz = 0;
 126       break;
 127    case SLANG_SPEC_BOOL:
 128       sz = 1;
 129       break;
 130    case SLANG_SPEC_BVEC2:
 131       sz = 2;
 132       break;
 133    case SLANG_SPEC_BVEC3:
 134       sz = 3;
 135       break;
 136    case SLANG_SPEC_BVEC4:
 137       sz = 4;
 138       break;
 139    case SLANG_SPEC_INT:
 140       sz = 1;
 141       break;
 142    case SLANG_SPEC_IVEC2:
 143       sz = 2;
 144       break;
 145    case SLANG_SPEC_IVEC3:
 146       sz = 3;
 147       break;
 148    case SLANG_SPEC_IVEC4:
 149       sz = 4;
 150       break;
 151    case SLANG_SPEC_FLOAT:
 152       sz = 1;
 153       break;
 154    case SLANG_SPEC_VEC2:
 155       sz = 2;
 156       break;
 157    case SLANG_SPEC_VEC3:
 158       sz = 3;
 159       break;
 160    case SLANG_SPEC_VEC4:
 161       sz = 4;
 162       break;
 163    case SLANG_SPEC_MAT2:
 164       sz = 2 * 4; /* 2 columns (regs) */
 165       break;
 166    case SLANG_SPEC_MAT3:
 167       sz = 3 * 4;
 168       break;
 169    case SLANG_SPEC_MAT4:
 170       sz = 4 * 4;
 171       break;
 172    case SLANG_SPEC_MAT23:
 173       sz = 2 * 4; /* 2 columns (regs) */
 174       break;
 175    case SLANG_SPEC_MAT32:
 176       sz = 3 * 4; /* 3 columns (regs) */
 177       break;
 178    case SLANG_SPEC_MAT24:
 179       sz = 2 * 4;
 180       break;
 181    case SLANG_SPEC_MAT42:
 182       sz = 4 * 4; /* 4 columns (regs) */
 183       break;
 184    case SLANG_SPEC_MAT34:
 185       sz = 3 * 4;
 186       break;
 187    case SLANG_SPEC_MAT43:
 188       sz = 4 * 4; /* 4 columns (regs) */
 189       break;
 190    case SLANG_SPEC_SAMPLER1D:
 191    case SLANG_SPEC_SAMPLER2D:
 192    case SLANG_SPEC_SAMPLER3D:
 193    case SLANG_SPEC_SAMPLERCUBE:
 194    case SLANG_SPEC_SAMPLER1DSHADOW:
 195    case SLANG_SPEC_SAMPLER2DSHADOW:
 196    case SLANG_SPEC_SAMPLER2DRECT:
 197    case SLANG_SPEC_SAMPLER2DRECTSHADOW:
 198       sz = 1; /* a sampler is basically just an integer index */
 199       break;
 200    case SLANG_SPEC_STRUCT:
 201       sz = _slang_field_offset(spec, 0); /* special use */
 202       if (sz > 4) {
 203          sz = (sz + 3) & ~0x3; /* round up to multiple of four */
 204       }
 205       break;
 206    case SLANG_SPEC_ARRAY:
 207       sz = _slang_sizeof_type_specifier(spec->_array);
 208       break;
 209    default:
 210       _mesa_problem(NULL, "Unexpected type in _slang_sizeof_type_specifier()");
 211       sz = 0;
 212    }
 213
 214    if (sz > 4) {
 215       /* if size is > 4, it should be a multiple of four */
 216       assert((sz & 0x3) == 0);
 217    }
 218    return sz;
 219 }
 220
 221
 222 /**
 223  * Establish the binding between a slang_ir_node and a slang_variable.
 224  * Then, allocate/attach a slang_ir_storage object to the IR node if needed.
 225  * The IR node must be a IR_VAR or IR_VAR_DECL node.
 226  * \param n  the IR node
 227  * \param var  the variable to associate with the IR node
 228  */
 229 static void
 230 _slang_attach_storage(slang_ir_node *n, slang_variable *var)
 231 {
 232    assert(n);
 233    assert(var);
 234    assert(n->Opcode == IR_VAR || n->Opcode == IR_VAR_DECL);
 235    assert(!n->Var || n->Var == var);
 236
 237    n->Var = var;
 238
 239    if (!n->Store) {
 240       /* need to setup storage */
 241       if (n->Var && n->Var->store) {
 242          /* node storage info = var storage info */
 243          n->Store = n->Var->store;
 244       }
 245       else {
 246          /* alloc new storage info */
 247          n->Store = _slang_new_ir_storage(PROGRAM_UNDEFINED, -7, -5);
 248 #if 0
 249          printf("%s var=%s Store=%p Size=%d\n", __FUNCTION__,
 250                 (char*) var->a_name,
 251                 (void*) n->Store, n->Store->Size);
 252 #endif
 253          if (n->Var)
 254             n->Var->store = n->Store;
 255          assert(n->Var->store);
 256       }
 257    }
 258 }
 259
 260
 261 /**
 262  * Return the TEXTURE_*_INDEX value that corresponds to a sampler type,
 263  * or -1 if the type is not a sampler.
 264  */
 265 static GLint
 266 sampler_to_texture_index(const slang_type_specifier_type type)
 267 {
 268    switch (type) {
 269    case SLANG_SPEC_SAMPLER1D:
 270       return TEXTURE_1D_INDEX;
 271    case SLANG_SPEC_SAMPLER2D:
 272       return TEXTURE_2D_INDEX;
 273    case SLANG_SPEC_SAMPLER3D:
 274       return TEXTURE_3D_INDEX;
 275    case SLANG_SPEC_SAMPLERCUBE:
 276       return TEXTURE_CUBE_INDEX;
 277    case SLANG_SPEC_SAMPLER1DSHADOW:
 278       return TEXTURE_1D_INDEX; /* XXX fix */
 279    case SLANG_SPEC_SAMPLER2DSHADOW:
 280       return TEXTURE_2D_INDEX; /* XXX fix */
 281    case SLANG_SPEC_SAMPLER2DRECT:
 282       return TEXTURE_RECT_INDEX;
 283    case SLANG_SPEC_SAMPLER2DRECTSHADOW:
 284       return TEXTURE_RECT_INDEX; /* XXX fix */
 285    default:
 286       return -1;
 287    }
 288 }
 289
 290
 291 #define SWIZZLE_ZWWW MAKE_SWIZZLE4(SWIZZLE_Z, SWIZZLE_W, SWIZZLE_W, SWIZZLE_W)
 292
 293 /**
 294  * Return the VERT_ATTRIB_* or FRAG_ATTRIB_* value that corresponds to
 295  * a vertex or fragment program input variable.  Return -1 if the input
 296  * name is invalid.
 297  * XXX return size too
 298  */
 299 static GLint
 300 _slang_input_index(const char *name, GLenum target, GLuint *swizzleOut)
 301 {
 302    struct input_info {
 303       const char *Name;
 304       GLuint Attrib;
 305       GLuint Swizzle;
 306    };
 307    static const struct input_info vertInputs[] = {
 308       { "gl_Vertex", VERT_ATTRIB_POS, SWIZZLE_NOOP },
 309       { "gl_Normal", VERT_ATTRIB_NORMAL, SWIZZLE_NOOP },
 310       { "gl_Color", VERT_ATTRIB_COLOR0, SWIZZLE_NOOP },
 311       { "gl_SecondaryColor", VERT_ATTRIB_COLOR1, SWIZZLE_NOOP },
 312       { "gl_FogCoord", VERT_ATTRIB_FOG, SWIZZLE_XXXX },
 313       { "gl_MultiTexCoord0", VERT_ATTRIB_TEX0, SWIZZLE_NOOP },
 314       { "gl_MultiTexCoord1", VERT_ATTRIB_TEX1, SWIZZLE_NOOP },
 315       { "gl_MultiTexCoord2", VERT_ATTRIB_TEX2, SWIZZLE_NOOP },
 316       { "gl_MultiTexCoord3", VERT_ATTRIB_TEX3, SWIZZLE_NOOP },
 317       { "gl_MultiTexCoord4", VERT_ATTRIB_TEX4, SWIZZLE_NOOP },
 318       { "gl_MultiTexCoord5", VERT_ATTRIB_TEX5, SWIZZLE_NOOP },
 319       { "gl_MultiTexCoord6", VERT_ATTRIB_TEX6, SWIZZLE_NOOP },
 320       { "gl_MultiTexCoord7", VERT_ATTRIB_TEX7, SWIZZLE_NOOP },
 321       { NULL, 0, SWIZZLE_NOOP }
 322    };
 323    static const struct input_info fragInputs[] = {
 324       { "gl_FragCoord", FRAG_ATTRIB_WPOS, SWIZZLE_NOOP },
 325       { "gl_Color", FRAG_ATTRIB_COL0, SWIZZLE_NOOP },
 326       { "gl_SecondaryColor", FRAG_ATTRIB_COL1, SWIZZLE_NOOP },
 327       { "gl_TexCoord", FRAG_ATTRIB_TEX0, SWIZZLE_NOOP },
 328       /* note: we're packing several quantities into the fogcoord vector */
 329       { "gl_FogFragCoord", FRAG_ATTRIB_FOGC, SWIZZLE_XXXX },
 330       { "gl_FrontFacing", FRAG_ATTRIB_FOGC, SWIZZLE_YYYY }, /*XXX*/
 331       { "gl_PointCoord", FRAG_ATTRIB_FOGC, SWIZZLE_ZWWW },
 332       { NULL, 0, SWIZZLE_NOOP }
 333    };
 334    GLuint i;
 335    const struct input_info *inputs
 336       = (target == GL_VERTEX_PROGRAM_ARB) ? vertInputs : fragInputs;
 337
 338    ASSERT(MAX_TEXTURE_UNITS == 8); /* if this fails, fix vertInputs above */
 339
 340    for (i = 0; inputs[i].Name; i++) {
 341       if (strcmp(inputs[i].Name, name) == 0) {
 342          /* found */
 343          *swizzleOut = inputs[i].Swizzle;
 344          return inputs[i].Attrib;
 345       }
 346    }
 347    return -1;
 348 }
 349
 350
 351 /**
 352  * Return the VERT_RESULT_* or FRAG_RESULT_* value that corresponds to
 353  * a vertex or fragment program output variable.  Return -1 for an invalid
 354  * output name.
 355  */
 356 static GLint
 357 _slang_output_index(const char *name, GLenum target)
 358 {
 359    struct output_info {
 360       const char *Name;
 361       GLuint Attrib;
 362    };
 363    static const struct output_info vertOutputs[] = {
 364       { "gl_Position", VERT_RESULT_HPOS },
 365       { "gl_FrontColor", VERT_RESULT_COL0 },
 366       { "gl_BackColor", VERT_RESULT_BFC0 },
 367       { "gl_FrontSecondaryColor", VERT_RESULT_COL1 },
 368       { "gl_BackSecondaryColor", VERT_RESULT_BFC1 },
 369       { "gl_TexCoord", VERT_RESULT_TEX0 },
 370       { "gl_FogFragCoord", VERT_RESULT_FOGC },
 371       { "gl_PointSize", VERT_RESULT_PSIZ },
 372       { NULL, 0 }
 373    };
 374    static const struct output_info fragOutputs[] = {
 375       { "gl_FragColor", FRAG_RESULT_COLR },
 376       { "gl_FragDepth", FRAG_RESULT_DEPR },
 377       { "gl_FragData", FRAG_RESULT_DATA0 },
 378       { NULL, 0 }
 379    };
 380    GLuint i;
 381    const struct output_info *outputs
 382       = (target == GL_VERTEX_PROGRAM_ARB) ? vertOutputs : fragOutputs;
 383
 384    for (i = 0; outputs[i].Name; i++) {
 385       if (strcmp(outputs[i].Name, name) == 0) {
 386          /* found */
 387          return outputs[i].Attrib;
 388       }
 389    }
 390    return -1;
 391 }
 392
 393
 394
 395 /**********************************************************************/
 396
 397
 398 /**
 399  * Map "_asm foo" to IR_FOO, etc.
 400  */
 401 typedef struct
 402 {
 403    const char *Name;
 404    slang_ir_opcode Opcode;
 405    GLuint HaveRetValue, NumParams;
 406 } slang_asm_info;
 407
 408
 409 static slang_asm_info AsmInfo[] = {
 410    /* vec4 binary op */
 411    { "vec4_add", IR_ADD, 1, 2 },
 412    { "vec4_subtract", IR_SUB, 1, 2 },
 413    { "vec4_multiply", IR_MUL, 1, 2 },
 414    { "vec4_dot", IR_DOT4, 1, 2 },
 415    { "vec3_dot", IR_DOT3, 1, 2 },
 416    { "vec2_dot", IR_DOT2, 1, 2 },
 417    { "vec3_nrm", IR_NRM3, 1, 1 },
 418    { "vec4_nrm", IR_NRM4, 1, 1 },
 419    { "vec3_cross", IR_CROSS, 1, 2 },
 420    { "vec4_lrp", IR_LRP, 1, 3 },
 421    { "vec4_min", IR_MIN, 1, 2 },
 422    { "vec4_max", IR_MAX, 1, 2 },
 423    { "vec4_clamp", IR_CLAMP, 1, 3 },
 424    { "vec4_seq", IR_SEQUAL, 1, 2 },
 425    { "vec4_sne", IR_SNEQUAL, 1, 2 },
 426    { "vec4_sge", IR_SGE, 1, 2 },
 427    { "vec4_sgt", IR_SGT, 1, 2 },
 428    { "vec4_sle", IR_SLE, 1, 2 },
 429    { "vec4_slt", IR_SLT, 1, 2 },
 430    /* vec4 unary */
 431    { "vec4_move", IR_MOVE, 1, 1 },
 432    { "vec4_floor", IR_FLOOR, 1, 1 },
 433    { "vec4_frac", IR_FRAC, 1, 1 },
 434    { "vec4_abs", IR_ABS, 1, 1 },
 435    { "vec4_negate", IR_NEG, 1, 1 },
 436    { "vec4_ddx", IR_DDX, 1, 1 },
 437    { "vec4_ddy", IR_DDY, 1, 1 },
 438    /* float binary op */
 439    { "float_power", IR_POW, 1, 2 },
 440    /* texture / sampler */
 441    { "vec4_tex1d", IR_TEX, 1, 2 },
 442    { "vec4_texb1d", IR_TEXB, 1, 2 },  /* 1d w/ bias */
 443    { "vec4_texp1d", IR_TEXP, 1, 2 },  /* 1d w/ projection */
 444    { "vec4_tex2d", IR_TEX, 1, 2 },
 445    { "vec4_texb2d", IR_TEXB, 1, 2 },  /* 2d w/ bias */
 446    { "vec4_texp2d", IR_TEXP, 1, 2 },  /* 2d w/ projection */
 447    { "vec4_tex3d", IR_TEX, 1, 2 },
 448    { "vec4_texb3d", IR_TEXB, 1, 2 },  /* 3d w/ bias */
 449    { "vec4_texp3d", IR_TEXP, 1, 2 },  /* 3d w/ projection */
 450    { "vec4_texcube", IR_TEX, 1, 2 },  /* cubemap */
 451    { "vec4_tex_rect", IR_TEX, 1, 2 }, /* rectangle */
 452    { "vec4_texp_rect", IR_TEX, 1, 2 },/* rectangle w/ projection */
 453
 454    /* unary op */
 455    { "ivec4_to_vec4", IR_I_TO_F, 1, 1 }, /* int[4] to float[4] */
 456    { "vec4_to_ivec4", IR_F_TO_I, 1, 1 },  /* float[4] to int[4] */
 457    { "float_exp", IR_EXP, 1, 1 },
 458    { "float_exp2", IR_EXP2, 1, 1 },
 459    { "float_log2", IR_LOG2, 1, 1 },
 460    { "float_rsq", IR_RSQ, 1, 1 },
 461    { "float_rcp", IR_RCP, 1, 1 },
 462    { "float_sine", IR_SIN, 1, 1 },
 463    { "float_cosine", IR_COS, 1, 1 },
 464    { "float_noise1", IR_NOISE1, 1, 1},
 465    { "float_noise2", IR_NOISE2, 1, 1},
 466    { "float_noise3", IR_NOISE3, 1, 1},
 467    { "float_noise4", IR_NOISE4, 1, 1},
 468
 469    { NULL, IR_NOP, 0, 0 }
 470 };
 471
 472
 473 static slang_ir_node *
 474 new_node3(slang_ir_opcode op,
 475           slang_ir_node *c0, slang_ir_node *c1, slang_ir_node *c2)
 476 {
 477    slang_ir_node *n = (slang_ir_node *) _slang_alloc(sizeof(slang_ir_node));
 478    if (n) {
 479       n->Opcode = op;
 480       n->Children[0] = c0;
 481       n->Children[1] = c1;
 482       n->Children[2] = c2;
 483       n->InstLocation = -1;
 484    }
 485    return n;
 486 }
 487
 488 static slang_ir_node *
 489 new_node2(slang_ir_opcode op, slang_ir_node *c0, slang_ir_node *c1)
 490 {
 491    return new_node3(op, c0, c1, NULL);
 492 }
 493
 494 static slang_ir_node *
 495 new_node1(slang_ir_opcode op, slang_ir_node *c0)
 496 {
 497    return new_node3(op, c0, NULL, NULL);
 498 }
 499
 500 static slang_ir_node *
 501 new_node0(slang_ir_opcode op)
 502 {
 503    return new_node3(op, NULL, NULL, NULL);
 504 }
 505
 506
 507 /**
 508  * Create sequence of two nodes.
 509  */
 510 static slang_ir_node *
 511 new_seq(slang_ir_node *left, slang_ir_node *right)
 512 {
 513    if (!left)
 514       return right;
 515    if (!right)
 516       return left;
 517    return new_node2(IR_SEQ, left, right);
 518 }
 519
 520 static slang_ir_node *
 521 new_label(slang_label *label)
 522 {
 523    slang_ir_node *n = new_node0(IR_LABEL);
 524    assert(label);
 525    if (n)
 526       n->Label = label;
 527    return n;
 528 }
 529
 530 static slang_ir_node *
 531 new_float_literal(const float v[4], GLuint size)
 532 {
 533    slang_ir_node *n = new_node0(IR_FLOAT);
 534    assert(size <= 4);
 535    COPY_4V(n->Value, v);
 536    /* allocate a storage object, but compute actual location (Index) later */
 537    n->Store = _slang_new_ir_storage(PROGRAM_CONSTANT, -1, size);
 538    return n;
 539 }
 540
 541
 542 static slang_ir_node *
 543 new_not(slang_ir_node *n)
 544 {
 545    return new_node1(IR_NOT, n);
 546 }
 547
 548
 549 /**
 550  * Non-inlined function call.
 551  */
 552 static slang_ir_node *
 553 new_function_call(slang_ir_node *code, slang_label *name)
 554 {
 555    slang_ir_node *n = new_node1(IR_CALL, code);
 556    assert(name);
 557    if (n)
 558       n->Label = name;
 559    return n;
 560 }
 561
 562
 563 /**
 564  * Unconditional jump.
 565  */
 566 static slang_ir_node *
 567 new_return(slang_label *dest)
 568 {
 569    slang_ir_node *n = new_node0(IR_RETURN);
 570    assert(dest);
 571    if (n)
 572       n->Label = dest;
 573    return n;
 574 }
 575
 576
 577 static slang_ir_node *
 578 new_loop(slang_ir_node *body)
 579 {
 580    return new_node1(IR_LOOP, body);
 581 }
 582
 583
 584 static slang_ir_node *
 585 new_break(slang_ir_node *loopNode)
 586 {
 587    slang_ir_node *n = new_node0(IR_BREAK);
 588    assert(loopNode);
 589    assert(loopNode->Opcode == IR_LOOP);
 590    if (n) {
 591       /* insert this node at head of linked list */
 592       n->List = loopNode->List;
 593       loopNode->List = n;
 594    }
 595    return n;
 596 }
 597
 598
 599 /**
 600  * Make new IR_BREAK_IF_TRUE.
 601  */
 602 static slang_ir_node *
 603 new_break_if_true(slang_ir_node *loopNode, slang_ir_node *cond)
 604 {
 605    slang_ir_node *n;
 606    assert(loopNode);
 607    assert(loopNode->Opcode == IR_LOOP);
 608    n = new_node1(IR_BREAK_IF_TRUE, cond);
 609    if (n) {
 610       /* insert this node at head of linked list */
 611       n->List = loopNode->List;
 612       loopNode->List = n;
 613    }
 614    return n;
 615 }
 616
 617
 618 /**
 619  * Make new IR_CONT_IF_TRUE node.
 620  */
 621 static slang_ir_node *
 622 new_cont_if_true(slang_ir_node *loopNode, slang_ir_node *cond)
 623 {
 624    slang_ir_node *n;
 625    assert(loopNode);
 626    assert(loopNode->Opcode == IR_LOOP);
 627    n = new_node1(IR_CONT_IF_TRUE, cond);
 628    if (n) {
 629       /* insert this node at head of linked list */
 630       n->List = loopNode->List;
 631       loopNode->List = n;
 632    }
 633    return n;
 634 }
 635
 636
 637 static slang_ir_node *
 638 new_cond(slang_ir_node *n)
 639 {
 640    slang_ir_node *c = new_node1(IR_COND, n);
 641    return c;
 642 }
 643
 644
 645 static slang_ir_node *
 646 new_if(slang_ir_node *cond, slang_ir_node *ifPart, slang_ir_node *elsePart)
 647 {
 648    return new_node3(IR_IF, cond, ifPart, elsePart);
 649 }
 650
 651
 652 /**
 653  * New IR_VAR node - a reference to a previously declared variable.
 654  */
 655 static slang_ir_node *
 656 new_var(slang_assemble_ctx *A, slang_variable *var)
 657 {
 658    slang_ir_node *n;
 659    if (!var)
 660       return NULL;
 661
 662    assert(var->declared);
 663
 664    n = new_node0(IR_VAR);
 665    if (n) {
 666       _slang_attach_storage(n, var);
 667       /*
 668       printf("new_var %s store=%p\n", (char*)name, (void*) n->Store);
 669       */
 670    }
 671    return n;
 672 }
 673
 674
 675 /**
 676  * Check if the given function is really just a wrapper for a
 677  * basic assembly instruction.
 678  */
 679 static GLboolean
 680 slang_is_asm_function(const slang_function *fun)
 681 {
 682    if (fun->body->type == SLANG_OPER_BLOCK_NO_NEW_SCOPE &&
 683        fun->body->num_children == 1 &&
 684        fun->body->children[0].type == SLANG_OPER_ASM) {
 685       return GL_TRUE;
 686    }
 687    return GL_FALSE;
 688 }
 689
 690
 691 static GLboolean
 692 _slang_is_noop(const slang_operation *oper)
 693 {
 694    if (!oper ||
 695        oper->type == SLANG_OPER_VOID ||
 696        (oper->num_children == 1 && oper->children[0].type == SLANG_OPER_VOID))
 697       return GL_TRUE;
 698    else
 699       return GL_FALSE;
 700 }
 701
 702
 703 /**
 704  * Recursively search tree for a node of the given type.
 705  */
 706 static slang_operation *
 707 _slang_find_node_type(slang_operation *oper, slang_operation_type type)
 708 {
 709    GLuint i;
 710    if (oper->type == type)
 711       return oper;
 712    for (i = 0; i < oper->num_children; i++) {
 713       slang_operation *p = _slang_find_node_type(&oper->children[i], type);
 714       if (p)
 715          return p;
 716    }
 717    return NULL;
 718 }
 719
 720
 721 /**
 722  * Count the number of operations of the given time rooted at 'oper'.
 723  */
 724 static GLuint
 725 _slang_count_node_type(slang_operation *oper, slang_operation_type type)
 726 {
 727    GLuint i, count = 0;
 728    if (oper->type == type) {
 729       return 1;
 730    }
 731    for (i = 0; i < oper->num_children; i++) {
 732       count += _slang_count_node_type(&oper->children[i], type);
 733    }
 734    return count;
 735 }
 736
 737
 738 /**
 739  * Check if the 'return' statement found under 'oper' is a "tail return"
 740  * that can be no-op'd.  For example:
 741  *
 742  * void func(void)
 743  * {
 744  *    .. do something ..
 745  *    return;   // this is a no-op
 746  * }
 747  *
 748  * This is used when determining if a function can be inlined.  If the
 749  * 'return' is not the last statement, we can't inline the function since
 750  * we still need the semantic behaviour of the 'return' but we don't want
 751  * to accidentally return from the _calling_ function.  We'd need to use an
 752  * unconditional branch, but we don't have such a GPU instruction (not
 753  * always, at least).
 754  */
 755 static GLboolean
 756 _slang_is_tail_return(const slang_operation *oper)
 757 {
 758    GLuint k = oper->num_children;
 759
 760    while (k > 0) {
 761       const slang_operation *last = &oper->children[k - 1];
 762       if (last->type == SLANG_OPER_RETURN)
 763          return GL_TRUE;
 764       else if (last->type == SLANG_OPER_IDENTIFIER ||
 765                last->type == SLANG_OPER_LABEL)
 766          k--; /* try prev child */
 767       else if (last->type == SLANG_OPER_BLOCK_NO_NEW_SCOPE ||
 768                last->type == SLANG_OPER_BLOCK_NEW_SCOPE)
 769          /* try sub-children */
 770          return _slang_is_tail_return(last);
 771       else
 772          break;
 773    }
 774
 775    return GL_FALSE;
 776 }
 777
 778
 779 static void
 780 slang_resolve_variable(slang_operation *oper)
 781 {
 782    if (oper->type == SLANG_OPER_IDENTIFIER && !oper->var) {
 783       oper->var = _slang_locate_variable(oper->locals, oper->a_id, GL_TRUE);
 784    }
 785 }
 786
 787
 788 /**
 789  * Replace particular variables (SLANG_OPER_IDENTIFIER) with new expressions.
 790  */
 791 static void
 792 slang_substitute(slang_assemble_ctx *A, slang_operation *oper,
 793                  GLuint substCount, slang_variable **substOld,
 794                  slang_operation **substNew, GLboolean isLHS)
 795 {
 796    switch (oper->type) {
 797    case SLANG_OPER_VARIABLE_DECL:
 798       {
 799          slang_variable *v = _slang_locate_variable(oper->locals,
 800                                                     oper->a_id, GL_TRUE);
 801          assert(v);
 802          if (v->initializer && oper->num_children == 0) {
 803             /* set child of oper to copy of initializer */
 804             oper->num_children = 1;
 805             oper->children = slang_operation_new(1);
 806             slang_operation_copy(&oper->children[0], v->initializer);
 807          }
 808          if (oper->num_children == 1) {
 809             /* the initializer */
 810             slang_substitute(A, &oper->children[0], substCount,
 811                              substOld, substNew, GL_FALSE);
 812          }
 813       }
 814       break;
 815    case SLANG_OPER_IDENTIFIER:
 816       assert(oper->num_children == 0);
 817       if (1/**!isLHS XXX FIX */) {
 818          slang_atom id = oper->a_id;
 819          slang_variable *v;
 820          GLuint i;
 821          v = _slang_locate_variable(oper->locals, id, GL_TRUE);
 822          if (!v) {
 823             _mesa_problem(NULL, "var %s not found!\n", (char *) oper->a_id);
 824             return;
 825          }
 826
 827          /* look for a substitution */
 828          for (i = 0; i < substCount; i++) {
 829             if (v == substOld[i]) {
 830                /* OK, replace this SLANG_OPER_IDENTIFIER with a new expr */
 831 #if 0 /* DEBUG only */
 832                if (substNew[i]->type == SLANG_OPER_IDENTIFIER) {
 833                   assert(substNew[i]->var);
 834                   assert(substNew[i]->var->a_name);
 835                   printf("Substitute %s with %s in id node %p\n",
 836                          (char*)v->a_name, (char*) substNew[i]->var->a_name,
 837                          (void*) oper);
 838                }
 839                else {
 840                   printf("Substitute %s with %f in id node %p\n",
 841                          (char*)v->a_name, substNew[i]->literal[0],
 842                          (void*) oper);
 843                }
 844 #endif
 845                slang_operation_copy(oper, substNew[i]);
 846                break;
 847             }
 848          }
 849       }
 850       break;
 851
 852    case SLANG_OPER_RETURN:
 853       /* do return replacement here too */
 854       assert(oper->num_children == 0 || oper->num_children == 1);
 855       if (oper->num_children == 1 && !_slang_is_noop(&oper->children[0])) {
 856          /* replace:
 857           *   return expr;
 858           * with:
 859           *   __retVal = expr;
 860           *   return;
 861           * then do substitutions on the assignment.
 862           */
 863          slang_operation *blockOper, *assignOper, *returnOper;
 864
 865          /* check if function actually has a return type */
 866          assert(A->CurFunction);
 867          if (A->CurFunction->header.type.specifier.type == SLANG_SPEC_VOID) {
 868             slang_info_log_error(A->log, "illegal return expression");
 869             return;
 870          }
 871
 872          blockOper = slang_operation_new(1);
 873          blockOper->type = SLANG_OPER_BLOCK_NO_NEW_SCOPE;
 874          blockOper->num_children = 2;
 875          blockOper->locals->outer_scope = oper->locals->outer_scope;
 876          blockOper->children = slang_operation_new(2);
 877          assignOper = blockOper->children + 0;
 878          returnOper = blockOper->children + 1;
 879
 880          assignOper->type = SLANG_OPER_ASSIGN;
 881          assignOper->num_children = 2;
 882          assignOper->locals->outer_scope = blockOper->locals;
 883          assignOper->children = slang_operation_new(2);
 884          assignOper->children[0].type = SLANG_OPER_IDENTIFIER;
 885          assignOper->children[0].a_id = slang_atom_pool_atom(A->atoms, "__retVal");
 886          assignOper->children[0].locals->outer_scope = assignOper->locals;
 887
 888          slang_operation_copy(&assignOper->children[1],
 889                               &oper->children[0]);
 890
 891          returnOper->type = SLANG_OPER_RETURN; /* return w/ no value */
 892          assert(returnOper->num_children == 0);
 893
 894          /* do substitutions on the "__retVal = expr" sub-tree */
 895          slang_substitute(A, assignOper,
 896                           substCount, substOld, substNew, GL_FALSE);
 897
 898          /* install new code */
 899          slang_operation_copy(oper, blockOper);
 900          slang_operation_destruct(blockOper);
 901       }
 902       else {
 903          /* check if return value was expected */
 904          assert(A->CurFunction);
 905          if (A->CurFunction->header.type.specifier.type != SLANG_SPEC_VOID) {
 906             slang_info_log_error(A->log, "return statement requires an expression");
 907             return;
 908          }
 909       }
 910       break;
 911
 912    case SLANG_OPER_ASSIGN:
 913    case SLANG_OPER_SUBSCRIPT:
 914       /* special case:
 915        * child[0] can't have substitutions but child[1] can.
 916        */
 917       slang_substitute(A, &oper->children[0],
 918                        substCount, substOld, substNew, GL_TRUE);
 919       slang_substitute(A, &oper->children[1],
 920                        substCount, substOld, substNew, GL_FALSE);
 921       break;
 922    case SLANG_OPER_FIELD:
 923       /* XXX NEW - test */
 924       slang_substitute(A, &oper->children[0],
 925                        substCount, substOld, substNew, GL_TRUE);
 926       break;
 927    default:
 928       {
 929          GLuint i;
 930          for (i = 0; i < oper->num_children; i++)
 931             slang_substitute(A, &oper->children[i],
 932                              substCount, substOld, substNew, GL_FALSE);
 933       }
 934    }
 935 }
 936
 937
 938 /**
 939  * Produce inline code for a call to an assembly instruction.
 940  * This is typically used to compile a call to a built-in function like this:
 941  *
 942  * vec4 mix(const vec4 x, const vec4 y, const vec4 a)
 943  * {
 944  *    __asm vec4_lrp __retVal, a, y, x;
 945  * }
 946  *
 947  *
 948  * A call to
 949  *     r = mix(p1, p2, p3);
 950  *
 951  * Becomes:
 952  *
 953  *              mov
 954  *             /   \
 955  *            r   vec4_lrp
 956  *                 /  |  \
 957  *                p3  p2  p1
 958  *
 959  * We basically translate a SLANG_OPER_CALL into a SLANG_OPER_ASM.
 960  */
 961 static slang_operation *
 962 slang_inline_asm_function(slang_assemble_ctx *A,
 963                           slang_function *fun, slang_operation *oper)
 964 {
 965    const GLuint numArgs = oper->num_children;
 966    GLuint i;
 967    slang_operation *inlined;
 968    const GLboolean haveRetValue = _slang_function_has_return_value(fun);
 969    slang_variable **substOld;
 970    slang_operation **substNew;
 971
 972    ASSERT(slang_is_asm_function(fun));
 973    ASSERT(fun->param_count == numArgs + haveRetValue);
 974
 975    /*
 976    printf("Inline %s as %s\n",
 977           (char*) fun->header.a_name,
 978           (char*) fun->body->children[0].a_id);
 979    */
 980
 981    /*
 982     * We'll substitute formal params with actual args in the asm call.
 983     */
 984    substOld = (slang_variable **)
 985       _slang_alloc(numArgs * sizeof(slang_variable *));
 986    substNew = (slang_operation **)
 987       _slang_alloc(numArgs * sizeof(slang_operation *));
 988    for (i = 0; i < numArgs; i++) {
 989       substOld[i] = fun->parameters->variables[i];
 990       substNew[i] = oper->children + i;
 991    }
 992
 993    /* make a copy of the code to inline */
 994    inlined = slang_operation_new(1);
 995    slang_operation_copy(inlined, &fun->body->children[0]);
 996    if (haveRetValue) {
 997       /* get rid of the __retVal child */
 998       inlined->num_children--;
 999       for (i = 0; i < inlined->num_children; i++) {
1000          inlined->children[i] = inlined->children[i + 1];
1001       }
1002    }
1003
1004    /* now do formal->actual substitutions */
1005    slang_substitute(A, inlined, numArgs, substOld, substNew, GL_FALSE);
1006
1007    _slang_free(substOld);
1008    _slang_free(substNew);
1009
1010 #if 0
1011    printf("+++++++++++++ inlined asm function %s +++++++++++++\n",
1012           (char *) fun->header.a_name);
1013    slang_print_tree(inlined, 3);
1014    printf("+++++++++++++++++++++++++++++++++++++++++++++++++++\n");
1015 #endif
1016
1017    return inlined;
1018 }
1019
1020
1021 /**
1022  * Inline the given function call operation.
1023  * Return a new slang_operation that corresponds to the inlined code.
1024  */
1025 static slang_operation *
1026 slang_inline_function_call(slang_assemble_ctx * A, slang_function *fun,
1027                            slang_operation *oper, slang_operation *returnOper)
1028 {
1029    typedef enum {
1030       SUBST = 1,
1031       COPY_IN,
1032       COPY_OUT
1033    } ParamMode;
1034    ParamMode *paramMode;
1035    const GLboolean haveRetValue = _slang_function_has_return_value(fun);
1036    const GLuint numArgs = oper->num_children;
1037    const GLuint totalArgs = numArgs + haveRetValue;
1038    slang_operation *args = oper->children;
1039    slang_operation *inlined, *top;
1040    slang_variable **substOld;
1041    slang_operation **substNew;
1042    GLuint substCount, numCopyIn, i;
1043    slang_function *prevFunction;
1044    slang_variable_scope *newScope = NULL;
1045
1046    /* save / push */
1047    prevFunction = A->CurFunction;
1048    A->CurFunction = fun;
1049
1050    /*assert(oper->type == SLANG_OPER_CALL); (or (matrix) multiply, etc) */
1051    assert(fun->param_count == totalArgs);
1052
1053    /* allocate temporary arrays */
1054    paramMode = (ParamMode *)
1055       _slang_alloc(totalArgs * sizeof(ParamMode));
1056    substOld = (slang_variable **)
1057       _slang_alloc(totalArgs * sizeof(slang_variable *));
1058    substNew = (slang_operation **)
1059       _slang_alloc(totalArgs * sizeof(slang_operation *));
1060
1061 #if 0
1062    printf("\nInline call to %s  (total vars=%d  nparams=%d)\n",
1063           (char *) fun->header.a_name,
1064           fun->parameters->num_variables, numArgs);
1065 #endif
1066
1067    if (haveRetValue && !returnOper) {
1068       /* Create 3-child comma sequence for inlined code:
1069        * child[0]:  declare __resultTmp
1070        * child[1]:  inlined function body
1071        * child[2]:  __resultTmp
1072        */
1073       slang_operation *commaSeq;
1074       slang_operation *declOper = NULL;
1075       slang_variable *resultVar;
1076
1077       commaSeq = slang_operation_new(1);
1078       commaSeq->type = SLANG_OPER_SEQUENCE;
1079       assert(commaSeq->locals);
1080       commaSeq->locals->outer_scope = oper->locals->outer_scope;
1081       commaSeq->num_children = 3;
1082       commaSeq->children = slang_operation_new(3);
1083       /* allocate the return var */
1084       resultVar = slang_variable_scope_grow(commaSeq->locals);
1085       /*
1086       printf("Alloc __resultTmp in scope %p for retval of calling %s\n",
1087              (void*)commaSeq->locals, (char *) fun->header.a_name);
1088       */
1089
1090       resultVar->a_name = slang_atom_pool_atom(A->atoms, "__resultTmp");
1091       resultVar->type = fun->header.type; /* XXX copy? */
1092       resultVar->isTemp = GL_TRUE;
1093
1094       /* child[0] = __resultTmp declaration */
1095       declOper = &commaSeq->children[0];
1096       declOper->type = SLANG_OPER_VARIABLE_DECL;
1097       declOper->a_id = resultVar->a_name;
1098       declOper->locals->outer_scope = commaSeq->locals;
1099
1100       /* child[1] = function body */
1101       inlined = &commaSeq->children[1];
1102       inlined->locals->outer_scope = commaSeq->locals;
1103
1104       /* child[2] = __resultTmp reference */
1105       returnOper = &commaSeq->children[2];
1106       returnOper->type = SLANG_OPER_IDENTIFIER;
1107       returnOper->a_id = resultVar->a_name;
1108       returnOper->locals->outer_scope = commaSeq->locals;
1109
1110       top = commaSeq;
1111    }
1112    else {
1113       top = inlined = slang_operation_new(1);
1114       /* XXXX this may be inappropriate!!!! */
1115       inlined->locals->outer_scope = oper->locals->outer_scope;
1116    }
1117
1118
1119    assert(inlined->locals);
1120
1121    /* Examine the parameters, look for inout/out params, look for possible
1122     * substitutions, etc:
1123     *    param type      behaviour
1124     *     in             copy actual to local
1125     *     const in       substitute param with actual
1126     *     out            copy out
1127     */
1128    substCount = 0;
1129    for (i = 0; i < totalArgs; i++) {
1130       slang_variable *p = fun->parameters->variables[i];
1131       /*
1132       printf("Param %d: %s %s \n", i,
1133              slang_type_qual_string(p->type.qualifier),
1134              (char *) p->a_name);
1135       */
1136       if (p->type.qualifier == SLANG_QUAL_INOUT ||
1137           p->type.qualifier == SLANG_QUAL_OUT) {
1138          /* an output param */
1139          slang_operation *arg;
1140          if (i < numArgs)
1141             arg = &args[i];
1142          else
1143             arg = returnOper;
1144          paramMode[i] = SUBST;
1145
1146          if (arg->type == SLANG_OPER_IDENTIFIER)
1147             slang_resolve_variable(arg);
1148
1149          /* replace parameter 'p' with argument 'arg' */
1150          substOld[substCount] = p;
1151          substNew[substCount] = arg; /* will get copied */
1152          substCount++;
1153       }
1154       else if (p->type.qualifier == SLANG_QUAL_CONST) {
1155          /* a constant input param */
1156          if (args[i].type == SLANG_OPER_IDENTIFIER ||
1157              args[i].type == SLANG_OPER_LITERAL_FLOAT) {
1158             /* replace all occurances of this parameter variable with the
1159              * actual argument variable or a literal.
1160              */
1161             paramMode[i] = SUBST;
1162             slang_resolve_variable(&args[i]);
1163             substOld[substCount] = p;
1164             substNew[substCount] = &args[i]; /* will get copied */
1165             substCount++;
1166          }
1167          else {
1168             paramMode[i] = COPY_IN;
1169          }
1170       }
1171       else {
1172          paramMode[i] = COPY_IN;
1173       }
1174       assert(paramMode[i]);
1175    }
1176
1177    /* actual code inlining: */
1178    slang_operation_copy(inlined, fun->body);
1179
1180    /*** XXX review this */
1181    assert(inlined->type == SLANG_OPER_BLOCK_NO_NEW_SCOPE ||
1182           inlined->type == SLANG_OPER_BLOCK_NEW_SCOPE);
1183    inlined->type = SLANG_OPER_BLOCK_NEW_SCOPE;
1184
1185 #if 0
1186    printf("======================= orig body code ======================\n");
1187    printf("=== params scope = %p\n", (void*) fun->parameters);
1188    slang_print_tree(fun->body, 8);
1189    printf("======================= copied code =========================\n");
1190    slang_print_tree(inlined, 8);
1191 #endif
1192
1193    /* do parameter substitution in inlined code: */
1194    slang_substitute(A, inlined, substCount, substOld, substNew, GL_FALSE);
1195
1196 #if 0
1197    printf("======================= subst code ==========================\n");
1198    slang_print_tree(inlined, 8);
1199    printf("=============================================================\n");
1200 #endif
1201
1202    /* New prolog statements: (inserted before the inlined code)
1203     * Copy the 'in' arguments.
1204     */
1205    numCopyIn = 0;
1206    for (i = 0; i < numArgs; i++) {
1207       if (paramMode[i] == COPY_IN) {
1208          slang_variable *p = fun->parameters->variables[i];
1209          /* declare parameter 'p' */
1210          slang_operation *decl = slang_operation_insert(&inlined->num_children,
1211                                                         &inlined->children,
1212                                                         numCopyIn);
1213
1214          decl->type = SLANG_OPER_VARIABLE_DECL;
1215          assert(decl->locals);
1216          decl->locals->outer_scope = inlined->locals;
1217          decl->a_id = p->a_name;
1218          decl->num_children = 1;
1219          decl->children = slang_operation_new(1);
1220
1221          /* child[0] is the var's initializer */
1222          slang_operation_copy(&decl->children[0], args + i);
1223
1224          /* add parameter 'p' to the local variable scope here */
1225          {
1226             slang_variable *pCopy = slang_variable_scope_grow(inlined->locals);
1227             pCopy->type = p->type;
1228             pCopy->a_name = p->a_name;
1229             pCopy->array_len = p->array_len;
1230          }
1231
1232          newScope = inlined->locals;
1233          numCopyIn++;
1234       }
1235    }
1236
1237    /* Now add copies of the function's local vars to the new variable scope */
1238    for (i = totalArgs; i < fun->parameters->num_variables; i++) {
1239       slang_variable *p = fun->parameters->variables[i];
1240       slang_variable *pCopy = slang_variable_scope_grow(inlined->locals);
1241       pCopy->type = p->type;
1242       pCopy->a_name = p->a_name;
1243       pCopy->array_len = p->array_len;
1244    }
1245
1246
1247    /* New epilog statements:
1248     * 1. Create end of function label to jump to from return statements.
1249     * 2. Copy the 'out' parameter vars
1250     */
1251    {
1252       slang_operation *lab = slang_operation_insert(&inlined->num_children,
1253                                                     &inlined->children,
1254                                                     inlined->num_children);
1255       lab->type = SLANG_OPER_LABEL;
1256       lab->label = A->curFuncEndLabel;
1257    }
1258
1259    for (i = 0; i < totalArgs; i++) {
1260       if (paramMode[i] == COPY_OUT) {
1261          const slang_variable *p = fun->parameters->variables[i];
1262          /* actualCallVar = outParam */
1263          /*if (i > 0 || !haveRetValue)*/
1264          slang_operation *ass = slang_operation_insert(&inlined->num_children,
1265                                                        &inlined->children,
1266                                                        inlined->num_children);
1267          ass->type = SLANG_OPER_ASSIGN;
1268          ass->num_children = 2;
1269          ass->locals->outer_scope = inlined->locals;
1270          ass->children = slang_operation_new(2);
1271          ass->children[0] = args[i]; /*XXX copy */
1272          ass->children[1].type = SLANG_OPER_IDENTIFIER;
1273          ass->children[1].a_id = p->a_name;
1274          ass->children[1].locals->outer_scope = ass->locals;
1275       }
1276    }
1277
1278    _slang_free(paramMode);
1279    _slang_free(substOld);
1280    _slang_free(substNew);
1281
1282    /* Update scoping to use the new local vars instead of the
1283     * original function's vars.  This is especially important
1284     * for nested inlining.
1285     */
1286    if (newScope)
1287       slang_replace_scope(inlined, fun->parameters, newScope);
1288
1289 #if 0
1290    printf("Done Inline call to %s  (total vars=%d  nparams=%d)\n\n",
1291           (char *) fun->header.a_name,
1292           fun->parameters->num_variables, numArgs);
1293    slang_print_tree(top, 0);
1294 #endif
1295
1296    /* pop */
1297    A->CurFunction = prevFunction;
1298
1299    return top;
1300 }
1301
1302
1303 static slang_ir_node *
1304 _slang_gen_function_call(slang_assemble_ctx *A, slang_function *fun,
1305                          slang_operation *oper, slang_operation *dest)
1306 {
1307    slang_ir_node *n;
1308    slang_operation *inlined;
1309    slang_label *prevFuncEndLabel;
1310    char name[200];
1311
1312    prevFuncEndLabel = A->curFuncEndLabel;
1313    sprintf(name, "__endOfFunc_%s_", (char *) fun->header.a_name);
1314    A->curFuncEndLabel = _slang_label_new(name);
1315    assert(A->curFuncEndLabel);
1316
1317    if (slang_is_asm_function(fun) && !dest) {
1318       /* assemble assembly function - tree style */
1319       inlined = slang_inline_asm_function(A, fun, oper);
1320    }
1321    else {
1322       /* non-assembly function */
1323       /* We always generate an "inline-able" block of code here.
1324        * We may either:
1325        *  1. insert the inline code
1326        *  2. Generate a call to the "inline" code as a subroutine
1327        */
1328
1329
1330       slang_operation *ret = NULL;
1331
1332       inlined = slang_inline_function_call(A, fun, oper, dest);
1333       if (!inlined)
1334          return NULL;
1335
1336       ret = _slang_find_node_type(inlined, SLANG_OPER_RETURN);
1337       if (ret) {
1338          /* check if this is a "tail" return */
1339          if (_slang_count_node_type(inlined, SLANG_OPER_RETURN) == 1 &&
1340              _slang_is_tail_return(inlined)) {
1341             /* The only RETURN is the last stmt in the function, no-op it
1342              * and inline the function body.
1343              */
1344             ret->type = SLANG_OPER_NONE;
1345          }
1346          else {
1347             slang_operation *callOper;
1348             /* The function we're calling has one or more 'return' statements.
1349              * So, we can't truly inline this function because we need to
1350              * implement 'return' with RET (and CAL).
1351              * Nevertheless, we performed "inlining" to make a new instance
1352              * of the function body to deal with static register allocation.
1353              *
1354              * XXX check if there's one 'return' and if it's the very last
1355              * statement in the function - we can optimize that case.
1356              */
1357             assert(inlined->type == SLANG_OPER_BLOCK_NEW_SCOPE ||
1358                    inlined->type == SLANG_OPER_SEQUENCE);
1359
1360             if (_slang_function_has_return_value(fun) && !dest) {
1361                assert(inlined->children[0].type == SLANG_OPER_VARIABLE_DECL);
1362                assert(inlined->children[2].type == SLANG_OPER_IDENTIFIER);
1363                callOper = &inlined->children[1];
1364             }
1365             else {
1366                callOper = inlined;
1367             }
1368             callOper->type = SLANG_OPER_NON_INLINED_CALL;
1369             callOper->fun = fun;
1370             callOper->label = _slang_label_new_unique((char*) fun->header.a_name);
1371          }
1372       }
1373    }
1374
1375    if (!inlined)
1376       return NULL;
1377
1378    /* Replace the function call with the inlined block (or new CALL stmt) */
1379    slang_operation_destruct(oper);
1380    *oper = *inlined;
1381    _slang_free(inlined);
1382
1383 #if 0
1384    assert(inlined->locals);
1385    printf("*** Inlined code for call to %s:\n",
1386           (char*) fun->header.a_name);
1387    slang_print_tree(oper, 10);
1388    printf("\n");
1389 #endif
1390
1391    n = _slang_gen_operation(A, oper);
1392
1393    /*_slang_label_delete(A->curFuncEndLabel);*/
1394    A->curFuncEndLabel = prevFuncEndLabel;
1395
1396    return n;
1397 }
1398
1399
1400 static slang_asm_info *
1401 slang_find_asm_info(const char *name)
1402 {
1403    GLuint i;
1404    for (i = 0; AsmInfo[i].Name; i++) {
1405       if (_mesa_strcmp(AsmInfo[i].Name, name) == 0) {
1406          return AsmInfo + i;
1407       }
1408    }
1409    return NULL;
1410 }
1411
1412
1413 /**
1414  * Return the default swizzle mask for accessing a variable of the
1415  * given size (in floats).  If size = 1, comp is used to identify
1416  * which component [0..3] of the register holds the variable.
1417  */
1418 static GLuint
1419 _slang_var_swizzle(GLint size, GLint comp)
1420 {
1421    switch (size) {
1422    case 1:
1423       return MAKE_SWIZZLE4(comp, comp, comp, comp);
1424    case 2:
1425       return MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_Y, SWIZZLE_NIL, SWIZZLE_NIL);
1426    case 3:
1427       return MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_NIL);
1428    default:
1429       return SWIZZLE_XYZW;
1430    }
1431 }
1432
1433
1434 /**
1435  * Some write-masked assignments are simple, but others are hard.
1436  * Simple example:
1437  *    vec3 v;
1438  *    v.xy = vec2(a, b);
1439  * Hard example:
1440  *    vec3 v;
1441  *    v.zy = vec2(a, b);
1442  * this gets transformed/swizzled into:
1443  *    v.zy = vec2(a, b).*yx*         (* = don't care)
1444  * This function helps to determine simple vs. non-simple.
1445  */
1446 static GLboolean
1447 _slang_simple_writemask(GLuint writemask, GLuint swizzle)
1448 {
1449    switch (writemask) {
1450    case WRITEMASK_X:
1451       return GET_SWZ(swizzle, 0) == SWIZZLE_X;
1452    case WRITEMASK_Y:
1453       return GET_SWZ(swizzle, 1) == SWIZZLE_Y;
1454    case WRITEMASK_Z:
1455       return GET_SWZ(swizzle, 2) == SWIZZLE_Z;
1456    case WRITEMASK_W:
1457       return GET_SWZ(swizzle, 3) == SWIZZLE_W;
1458    case WRITEMASK_XY:
1459       return (GET_SWZ(swizzle, 0) == SWIZZLE_X)
1460          && (GET_SWZ(swizzle, 1) == SWIZZLE_Y);
1461    case WRITEMASK_XYZ:
1462       return (GET_SWZ(swizzle, 0) == SWIZZLE_X)
1463          && (GET_SWZ(swizzle, 1) == SWIZZLE_Y)
1464          && (GET_SWZ(swizzle, 2) == SWIZZLE_Z);
1465    case WRITEMASK_XYZW:
1466       return swizzle == SWIZZLE_NOOP;
1467    default:
1468       return GL_FALSE;
1469    }
1470 }
1471
1472
1473 /**
1474  * Convert the given swizzle into a writemask.  In some cases this
1475  * is trivial, in other cases, we'll need to also swizzle the right
1476  * hand side to put components in the right places.
1477  * See comment above for more info.
1478  * XXX this function could be simplified and should probably be renamed.
1479  * \param swizzle  the incoming swizzle
1480  * \param writemaskOut  returns the writemask
1481  * \param swizzleOut  swizzle to apply to the right-hand-side
1482  * \return GL_FALSE for simple writemasks, GL_TRUE for non-simple
1483  */
1484 static GLboolean
1485 swizzle_to_writemask(slang_assemble_ctx *A, GLuint swizzle,
1486                      GLuint *writemaskOut, GLuint *swizzleOut)
1487 {
1488    GLuint mask = 0x0, newSwizzle[4];
1489    GLint i, size;
1490
1491    /* make new dst writemask, compute size */
1492    for (i = 0; i < 4; i++) {
1493       const GLuint swz = GET_SWZ(swizzle, i);
1494       if (swz == SWIZZLE_NIL) {
1495          /* end */
1496          break;
1497       }
1498       assert(swz >= 0 && swz <= 3);
1499
1500       if (swizzle != SWIZZLE_XXXX &&
1501           swizzle != SWIZZLE_YYYY &&
1502           swizzle != SWIZZLE_ZZZZ &&
1503           swizzle != SWIZZLE_WWWW &&
1504           (mask & (1 << swz))) {
1505          /* a channel can't be specified twice (ex: ".xyyz") */
1506          slang_info_log_error(A->log, "Invalid writemask '%s'",
1507                               _mesa_swizzle_string(swizzle, 0, 0));
1508          return GL_FALSE;
1509       }
1510
1511       mask |= (1 << swz);
1512    }
1513    assert(mask <= 0xf);
1514    size = i;  /* number of components in mask/swizzle */
1515
1516    *writemaskOut = mask;
1517
1518    /* make new src swizzle, by inversion */
1519    for (i = 0; i < 4; i++) {
1520       newSwizzle[i] = i; /*identity*/
1521    }
1522    for (i = 0; i < size; i++) {
1523       const GLuint swz = GET_SWZ(swizzle, i);
1524       newSwizzle[swz] = i;
1525    }
1526    *swizzleOut = MAKE_SWIZZLE4(newSwizzle[0],
1527                                newSwizzle[1],
1528                                newSwizzle[2],
1529                                newSwizzle[3]);
1530
1531    if (_slang_simple_writemask(mask, *swizzleOut)) {
1532       if (size >= 1)
1533          assert(GET_SWZ(*swizzleOut, 0) == SWIZZLE_X);
1534       if (size >= 2)
1535          assert(GET_SWZ(*swizzleOut, 1) == SWIZZLE_Y);
1536       if (size >= 3)
1537          assert(GET_SWZ(*swizzleOut, 2) == SWIZZLE_Z);
1538       if (size >= 4)
1539          assert(GET_SWZ(*swizzleOut, 3) == SWIZZLE_W);
1540       return GL_TRUE;
1541    }
1542    else
1543       return GL_FALSE;
1544 }
1545
1546
1547 /**
1548  * Recursively traverse 'oper' to produce a swizzle mask in the event
1549  * of any vector subscripts and swizzle suffixes.
1550  * Ex:  for "vec4 v",  "v[2].x" resolves to v.z
1551  */
1552 static GLuint
1553 resolve_swizzle(const slang_operation *oper)
1554 {
1555    if (oper->type == SLANG_OPER_FIELD) {
1556       /* writemask from .xyzw suffix */
1557       slang_swizzle swz;
1558       if (_slang_is_swizzle((char*) oper->a_id, 4, &swz)) {
1559          GLuint swizzle = MAKE_SWIZZLE4(swz.swizzle[0],
1560                                         swz.swizzle[1],
1561                                         swz.swizzle[2],
1562                                         swz.swizzle[3]);
1563          GLuint child_swizzle = resolve_swizzle(&oper->children[0]);
1564          GLuint s = _slang_swizzle_swizzle(child_swizzle, swizzle);
1565          return s;
1566       }
1567       else
1568          return SWIZZLE_XYZW;
1569    }
1570    else if (oper->type == SLANG_OPER_SUBSCRIPT &&
1571             oper->children[1].type == SLANG_OPER_LITERAL_INT) {
1572       /* writemask from [index] */
1573       GLuint child_swizzle = resolve_swizzle(&oper->children[0]);
1574       GLuint i = (GLuint) oper->children[1].literal[0];
1575       GLuint swizzle;
1576       GLuint s;
1577       switch (i) {
1578       case 0:
1579          swizzle = SWIZZLE_XXXX;
1580          break;
1581       case 1:
1582          swizzle = SWIZZLE_YYYY;
1583          break;
1584       case 2:
1585          swizzle = SWIZZLE_ZZZZ;
1586          break;
1587       case 3:
1588          swizzle = SWIZZLE_WWWW;
1589          break;
1590       default:
1591          swizzle = SWIZZLE_XYZW;
1592       }
1593       s = _slang_swizzle_swizzle(child_swizzle, swizzle);
1594       return s;
1595    }
1596    else {
1597       return SWIZZLE_XYZW;
1598    }
1599 }
1600
1601
1602 /**
1603  * Recursively descend through swizzle nodes to find the node's storage info.
1604  */
1605 static slang_ir_storage *
1606 get_store(const slang_ir_node *n)
1607 {
1608    if (n->Opcode == IR_SWIZZLE) {
1609       return get_store(n->Children[0]);
1610    }
1611    return n->Store;
1612 }
1613
1614
1615
1616 /**
1617  * Generate IR tree for an asm instruction/operation such as:
1618  *    __asm vec4_dot __retVal.x, v1, v2;
1619  */
1620 static slang_ir_node *
1621 _slang_gen_asm(slang_assemble_ctx *A, slang_operation *oper,
1622                slang_operation *dest)
1623 {
1624    const slang_asm_info *info;
1625    slang_ir_node *kids[3], *n;
1626    GLuint j, firstOperand;
1627
1628    assert(oper->type == SLANG_OPER_ASM);
1629
1630    info = slang_find_asm_info((char *) oper->a_id);
1631    if (!info) {
1632       _mesa_problem(NULL, "undefined __asm function %s\n",
1633                     (char *) oper->a_id);
1634       assert(info);
1635    }
1636    assert(info->NumParams <= 3);
1637
1638    if (info->NumParams == oper->num_children) {
1639       /* Storage for result is not specified.
1640        * Children[0], [1], [2] are the operands.
1641        */
1642       firstOperand = 0;
1643    }
1644    else {
1645       /* Storage for result (child[0]) is specified.
1646        * Children[1], [2], [3] are the operands.
1647        */
1648       firstOperand = 1;
1649    }
1650
1651    /* assemble child(ren) */
1652    kids[0] = kids[1] = kids[2] = NULL;
1653    for (j = 0; j < info->NumParams; j++) {
1654       kids[j] = _slang_gen_operation(A, &oper->children[firstOperand + j]);
1655       if (!kids[j])
1656          return NULL;
1657    }
1658
1659    n = new_node3(info->Opcode, kids[0], kids[1], kids[2]);
1660
1661    if (firstOperand) {
1662       /* Setup n->Store to be a particular location.  Otherwise, storage
1663        * for the result (a temporary) will be allocated later.
1664        */
1665       slang_operation *dest_oper;
1666       slang_ir_node *n0;
1667
1668       dest_oper = &oper->children[0];
1669
1670       n0 = _slang_gen_operation(A, dest_oper);
1671       if (!n0)
1672          return NULL;
1673
1674       assert(!n->Store);
1675       n->Store = n0->Store;
1676
1677       assert(n->Store->File != PROGRAM_UNDEFINED || n->Store->Parent);
1678
1679       _slang_free(n0);
1680    }
1681
1682    return n;
1683 }
1684
1685
1686 static void
1687 print_funcs(struct slang_function_scope_ *scope, const char *name)
1688 {
1689    GLuint i;
1690    for (i = 0; i < scope->num_functions; i++) {
1691       slang_function *f = &scope->functions[i];
1692       if (!name || strcmp(name, (char*) f->header.a_name) == 0)
1693           printf("  %s (%d args)\n", name, f->param_count);
1694
1695    }
1696    if (scope->outer_scope)
1697       print_funcs(scope->outer_scope, name);
1698 }
1699
1700
1701 /**
1702  * Find a function of the given name, taking 'numArgs' arguments.
1703  * This is the function we'll try to call when there is no exact match
1704  * between function parameters and call arguments.
1705  *
1706  * XXX we should really create a list of candidate functions and try
1707  * all of them...
1708  */
1709 static slang_function *
1710 _slang_find_function_by_argc(slang_function_scope *scope,
1711                              const char *name, int numArgs)
1712 {
1713    while (scope) {
1714       GLuint i;
1715       for (i = 0; i < scope->num_functions; i++) {
1716          slang_function *f = &scope->functions[i];
1717          if (strcmp(name, (char*) f->header.a_name) == 0) {
1718             int haveRetValue = _slang_function_has_return_value(f);
1719             if (numArgs == f->param_count - haveRetValue)
1720                return f;
1721          }
1722       }
1723       scope = scope->outer_scope;
1724    }
1725
1726    return NULL;
1727 }
1728
1729
1730 static slang_function *
1731 _slang_find_function_by_max_argc(slang_function_scope *scope,
1732                                  const char *name)
1733 {
1734    slang_function *maxFunc = NULL;
1735    GLuint maxArgs = 0;
1736
1737    while (scope) {
1738       GLuint i;
1739       for (i = 0; i < scope->num_functions; i++) {
1740          slang_function *f = &scope->functions[i];
1741          if (strcmp(name, (char*) f->header.a_name) == 0) {
1742             if (f->param_count > maxArgs) {
1743                maxArgs = f->param_count;
1744                maxFunc = f;
1745             }
1746          }
1747       }
1748       scope = scope->outer_scope;
1749    }
1750
1751    return maxFunc;
1752 }
1753
1754
1755 /**
1756  * Generate a new slang_function which is a constructor for a user-defined
1757  * struct type.
1758  */
1759 static slang_function *
1760 _slang_make_constructor(slang_assemble_ctx *A, slang_struct *str)
1761 {
1762    const GLint numFields = str->fields->num_variables;
1763
1764    slang_function *fun = (slang_function *) _mesa_malloc(sizeof(slang_function));
1765    if (!fun)
1766       return NULL;
1767
1768    slang_function_construct(fun);
1769
1770    /* function header (name, return type) */
1771    fun->kind = SLANG_FUNC_CONSTRUCTOR;
1772    fun->header.a_name = str->a_name;
1773    fun->header.type.qualifier = SLANG_QUAL_NONE;
1774    fun->header.type.specifier.type = SLANG_SPEC_STRUCT;
1775    fun->header.type.specifier._struct = str;
1776
1777    /* function parameters (= struct's fields) */
1778    {
1779       GLint i;
1780       for (i = 0; i < numFields; i++) {
1781          /*
1782          printf("Field %d: %s\n", i, (char*) str->fields->variables[i]->a_name);
1783          */
1784          slang_variable *p = slang_variable_scope_grow(fun->parameters);
1785          *p = *str->fields->variables[i]; /* copy the type */
1786          p->type.qualifier = SLANG_QUAL_CONST;
1787       }
1788       fun->param_count = fun->parameters->num_variables;
1789    }
1790
1791    /* Add __retVal to params */
1792    {
1793       slang_variable *p = slang_variable_scope_grow(fun->parameters);
1794       slang_atom a_retVal = slang_atom_pool_atom(A->atoms, "__retVal");
1795       assert(a_retVal);
1796       p->a_name = a_retVal;
1797       p->type = fun->header.type;
1798       p->type.qualifier = SLANG_QUAL_OUT;
1799       fun->param_count++;
1800    }
1801
1802    /* function body is:
1803     *    block:
1804     *       declare T;
1805     *       T.f1 = p1;
1806     *       T.f2 = p2;
1807     *       ...
1808     *       T.fn = pn;
1809     *       return T;
1810     */
1811    {
1812       slang_variable_scope *scope;
1813       slang_variable *var;
1814       GLint i;
1815
1816       fun->body = slang_operation_new(1);
1817       fun->body->type = SLANG_OPER_BLOCK_NEW_SCOPE;
1818       fun->body->num_children = numFields + 2;
1819       fun->body->children = slang_operation_new(numFields + 2);
1820
1821       scope = fun->body->locals;
1822       scope->outer_scope = fun->parameters;
1823
1824       /* create local var 't' */
1825       var = slang_variable_scope_grow(scope);
1826       var->a_name = slang_atom_pool_atom(A->atoms, "t");
1827       var->type = fun->header.type;
1828
1829       /* declare t */
1830       {
1831          slang_operation *decl;
1832
1833          decl = &fun->body->children[0];
1834          decl->type = SLANG_OPER_VARIABLE_DECL;
1835          decl->locals = _slang_variable_scope_new(scope);
1836          decl->a_id = var->a_name;
1837       }
1838
1839       /* assign params to fields of t */
1840       for (i = 0; i < numFields; i++) {
1841          slang_operation *assign = &fun->body->children[1 + i];
1842
1843          assign->type = SLANG_OPER_ASSIGN;
1844          assign->locals = _slang_variable_scope_new(scope);
1845          assign->num_children = 2;
1846          assign->children = slang_operation_new(2);
1847
1848          {
1849             slang_operation *lhs = &assign->children[0];
1850
1851             lhs->type = SLANG_OPER_FIELD;
1852             lhs->locals = _slang_variable_scope_new(scope);
1853             lhs->num_children = 1;
1854             lhs->children = slang_operation_new(1);
1855             lhs->a_id = str->fields->variables[i]->a_name;
1856
1857             lhs->children[0].type = SLANG_OPER_IDENTIFIER;
1858             lhs->children[0].a_id = var->a_name;
1859             lhs->children[0].locals = _slang_variable_scope_new(scope);
1860
1861 #if 0
1862             lhs->children[1].num_children = 1;
1863             lhs->children[1].children = slang_operation_new(1);
1864             lhs->children[1].children[0].type = SLANG_OPER_IDENTIFIER;
1865             lhs->children[1].children[0].a_id = str->fields->variables[i]->a_name;
1866             lhs->children[1].children->locals = _slang_variable_scope_new(scope);
1867 #endif
1868          }
1869
1870          {
1871             slang_operation *rhs = &assign->children[1];
1872
1873             rhs->type = SLANG_OPER_IDENTIFIER;
1874             rhs->locals = _slang_variable_scope_new(scope);
1875             rhs->a_id = str->fields->variables[i]->a_name;
1876          }
1877       }
1878
1879       /* return t; */
1880       {
1881          slang_operation *ret = &fun->body->children[numFields + 1];
1882
1883          ret->type = SLANG_OPER_RETURN;
1884          ret->locals = _slang_variable_scope_new(scope);
1885          ret->num_children = 1;
1886          ret->children = slang_operation_new(1);
1887          ret->children[0].type = SLANG_OPER_IDENTIFIER;
1888          ret->children[0].a_id = var->a_name;
1889          ret->children[0].locals = _slang_variable_scope_new(scope);
1890
1891       }
1892    }
1893    /*
1894    slang_print_function(fun, 1);
1895    */
1896    return fun;
1897 }
1898
1899
1900 /**
1901  * Find/create a function (constructor) for the given structure name.
1902  */
1903 static slang_function *
1904 _slang_locate_struct_constructor(slang_assemble_ctx *A, const char *name)
1905 {
1906    unsigned int i;
1907    for (i = 0; i < A->space.structs->num_structs; i++) {
1908       slang_struct *str = &A->space.structs->structs[i];
1909       if (strcmp(name, (const char *) str->a_name) == 0) {
1910          /* found a structure type that matches the function name */
1911          if (!str->constructor) {
1912             /* create the constructor function now */
1913             str->constructor = _slang_make_constructor(A, str);
1914          }
1915          return str->constructor;
1916       }
1917    }
1918    return NULL;
1919 }
1920
1921
1922
1923 static GLboolean
1924 _slang_is_vec_mat_type(const char *name)
1925 {
1926    static const char *vecmat_types[] = {
1927       "float", "int", "bool",
1928       "vec2", "vec3", "vec4",
1929       "ivec2", "ivec3", "ivec4",
1930       "bvec2", "bvec3", "bvec4",
1931       "mat2", "mat3", "mat4",
1932       "mat2x3", "mat2x4", "mat3x2", "mat3x4", "mat4x2", "mat4x3",
1933       NULL
1934    };
1935    int i;
1936    for (i = 0; vecmat_types[i]; i++)
1937       if (_mesa_strcmp(name, vecmat_types[i]) == 0)
1938          return GL_TRUE;
1939    return GL_FALSE;
1940 }
1941
1942
1943 /**
1944  * Assemble a function call, given a particular function name.
1945  * \param name  the function's name (operators like '*' are possible).
1946  */
1947 static slang_ir_node *
1948 _slang_gen_function_call_name(slang_assemble_ctx *A, const char *name,
1949                               slang_operation *oper, slang_operation *dest)
1950 {
1951    slang_operation *params = oper->children;
1952    const GLuint param_count = oper->num_children;
1953    slang_atom atom;
1954    slang_function *fun;
1955    GLboolean error;
1956    slang_ir_node *n;
1957
1958    atom = slang_atom_pool_atom(A->atoms, name);
1959    if (atom == SLANG_ATOM_NULL)
1960       return NULL;
1961
1962    /*
1963     * First, try to find function by name and exact argument type matching.
1964     */
1965    fun = _slang_locate_function(A->space.funcs, atom, params, param_count,
1966                                 &A->space, A->atoms, A->log, &error);
1967
1968    if (error) {
1969       slang_info_log_error(A->log,
1970                            "Function '%s' not found (check argument types)",
1971                            name);
1972       return NULL;
1973    }
1974
1975    if (!fun) {
1976       /* Next, try locating a constructor function for a user-defined type */
1977       fun = _slang_locate_struct_constructor(A, name);
1978    }
1979
1980    /*
1981     * At this point, some heuristics are used to try to find a function
1982     * that matches the calling signature by means of casting or "unrolling"
1983     * of constructors.
1984     */
1985
1986    if (!fun && _slang_is_vec_mat_type(name)) {
1987       /* Next, if this call looks like a vec() or mat() constructor call,
1988        * try "unwinding" the args to satisfy a constructor.
1989        */
1990       fun = _slang_find_function_by_max_argc(A->space.funcs, name);
1991       if (fun) {
1992          if (!_slang_adapt_call(oper, fun, &A->space, A->atoms, A->log)) {
1993             slang_info_log_error(A->log,
1994                                  "Function '%s' not found (check argument types)",
1995                                  name);
1996             return NULL;
1997          }
1998       }
1999    }
2000
2001    if (!fun && _slang_is_vec_mat_type(name)) {
2002       /* Next, try casting args to the types of the formal parameters */
2003       int numArgs = oper->num_children;
2004       fun = _slang_find_function_by_argc(A->space.funcs, name, numArgs);
2005       if (!fun || !_slang_cast_func_params(oper, fun, &A->space, A->atoms, A->log)) {
2006          slang_info_log_error(A->log,
2007                               "Function '%s' not found (check argument types)",
2008                               name);
2009          return NULL;
2010       }
2011       assert(fun);
2012    }
2013
2014    if (!fun) {
2015       slang_info_log_error(A->log,
2016                            "Function '%s' not found (check argument types)",
2017                            name);
2018       return NULL;
2019    }
2020    if (!fun->body) {
2021       slang_info_log_error(A->log,
2022                            "Function '%s' prototyped but not defined.  "
2023                            "Separate compilation units not supported.",
2024                            name);
2025       return NULL;
2026    }
2027
2028    /* type checking to be sure function's return type matches 'dest' type */
2029    if (dest) {
2030       slang_typeinfo t0;
2031
2032       slang_typeinfo_construct(&t0);
2033       _slang_typeof_operation(A, dest, &t0);
2034
2035       if (!slang_type_specifier_equal(&t0.spec, &fun->header.type.specifier)) {
2036          slang_info_log_error(A->log,
2037                               "Incompatible type returned by call to '%s'",
2038                               name);
2039          return NULL;
2040       }
2041    }
2042
2043    n = _slang_gen_function_call(A, fun, oper, dest);
2044
2045    if (n && !n->Store && !dest
2046        && fun->header.type.specifier.type != SLANG_SPEC_VOID) {
2047       /* setup n->Store for the result of the function call */
2048       GLint size = _slang_sizeof_type_specifier(&fun->header.type.specifier);
2049       n->Store = _slang_new_ir_storage(PROGRAM_TEMPORARY, -1, size);
2050       /*printf("Alloc storage for function result, size %d \n", size);*/
2051    }
2052
2053    return n;
2054 }
2055
2056
2057 static slang_ir_node *
2058 _slang_gen_method_call(slang_assemble_ctx *A, slang_operation *oper)
2059 {
2060    slang_atom *a_length = slang_atom_pool_atom(A->atoms, "length");
2061    slang_ir_node *n;
2062    slang_variable *var;
2063
2064    /* NOTE: In GLSL 1.20, there's only one kind of method
2065     * call: array.length().  Anything else is an error.
2066     */
2067    if (oper->a_id != a_length) {
2068       slang_info_log_error(A->log,
2069                            "Undefined method call '%s'", (char *) oper->a_id);
2070       return NULL;
2071    }
2072
2073    /* length() takes no arguments */
2074    if (oper->num_children > 0) {
2075       slang_info_log_error(A->log, "Invalid arguments to length() method");
2076       return NULL;
2077    }
2078
2079    /* lookup the object/variable */
2080    var = _slang_locate_variable(oper->locals, oper->a_obj, GL_TRUE);
2081    if (!var || var->type.specifier.type != SLANG_SPEC_ARRAY) {
2082       slang_info_log_error(A->log,
2083                            "Undefined object '%s'", (char *) oper->a_obj);
2084       return NULL;
2085    }
2086
2087    /* Create a float/literal IR node encoding the array length */
2088    n = new_node0(IR_FLOAT);
2089    if (n) {
2090       n->Value[0] = (float) var->array_len;
2091       n->Store = _slang_new_ir_storage(PROGRAM_CONSTANT, -1, 1);
2092    }
2093    return n;
2094 }
2095
2096
2097 static GLboolean
2098 _slang_is_constant_cond(const slang_operation *oper, GLboolean *value)
2099 {
2100    if (oper->type == SLANG_OPER_LITERAL_FLOAT ||
2101        oper->type == SLANG_OPER_LITERAL_INT ||
2102        oper->type == SLANG_OPER_LITERAL_BOOL) {
2103       if (oper->literal[0])
2104          *value = GL_TRUE;
2105       else
2106          *value = GL_FALSE;
2107       return GL_TRUE;
2108    }
2109    else if (oper->type == SLANG_OPER_EXPRESSION &&
2110             oper->num_children == 1) {
2111       return _slang_is_constant_cond(&oper->children[0], value);
2112    }
2113    return GL_FALSE;
2114 }
2115
2116
2117 /**
2118  * Test if an operation is a scalar or boolean.
2119  */
2120 static GLboolean
2121 _slang_is_scalar_or_boolean(slang_assemble_ctx *A, slang_operation *oper)
2122 {
2123    slang_typeinfo type;
2124    GLint size;
2125
2126    slang_typeinfo_construct(&type);
2127    _slang_typeof_operation(A, oper, &type);
2128    size = _slang_sizeof_type_specifier(&type.spec);
2129    slang_typeinfo_destruct(&type);
2130    return size == 1;
2131 }
2132
2133
2134 /**
2135  * Test if an operation is boolean.
2136  */
2137 static GLboolean
2138 _slang_is_boolean(slang_assemble_ctx *A, slang_operation *oper)
2139 {
2140    slang_typeinfo type;
2141    GLboolean isBool;
2142
2143    slang_typeinfo_construct(&type);
2144    _slang_typeof_operation(A, oper, &type);
2145    isBool = (type.spec.type == SLANG_SPEC_BOOL);
2146    slang_typeinfo_destruct(&type);
2147    return isBool;
2148 }
2149
2150
2151 /**
2152  * Generate loop code using high-level IR_LOOP instruction
2153  */
2154 static slang_ir_node *
2155 _slang_gen_while(slang_assemble_ctx * A, const slang_operation *oper)
2156 {
2157    /*
2158     * LOOP:
2159     *    BREAK if !expr (child[0])
2160     *    body code (child[1])
2161     */
2162    slang_ir_node *prevLoop, *loop, *breakIf, *body;
2163    GLboolean isConst, constTrue;
2164
2165    /* type-check expression */
2166    if (!_slang_is_boolean(A, &oper->children[0])) {
2167       slang_info_log_error(A->log, "scalar/boolean expression expected for 'while'");
2168       return NULL;
2169    }
2170
2171    /* Check if loop condition is a constant */
2172    isConst = _slang_is_constant_cond(&oper->children[0], &constTrue);
2173
2174    if (isConst && !constTrue) {
2175       /* loop is never executed! */
2176       return new_node0(IR_NOP);
2177    }
2178
2179    loop = new_loop(NULL);
2180
2181    /* save old, push new loop */
2182    prevLoop = A->CurLoop;
2183    A->CurLoop = loop;
2184
2185    if (isConst && constTrue) {
2186       /* while(nonzero constant), no conditional break */
2187       breakIf = NULL;
2188    }
2189    else {
2190       slang_ir_node *cond
2191          = new_cond(new_not(_slang_gen_operation(A, &oper->children[0])));
2192       breakIf = new_break_if_true(A->CurLoop, cond);
2193    }
2194    body = _slang_gen_operation(A, &oper->children[1]);
2195    loop->Children[0] = new_seq(breakIf, body);
2196
2197    /* Do infinite loop detection */
2198    /* loop->List is head of linked list of break/continue nodes */
2199    if (!loop->List && isConst && constTrue) {
2200       /* infinite loop detected */
2201       A->CurLoop = prevLoop; /* clean-up */
2202       slang_info_log_error(A->log, "Infinite loop detected!");
2203       return NULL;
2204    }
2205
2206    /* pop loop, restore prev */
2207    A->CurLoop = prevLoop;
2208
2209    return loop;
2210 }
2211
2212
2213 /**
2214  * Generate IR tree for a do-while loop using high-level LOOP, IF instructions.
2215  */
2216 static slang_ir_node *
2217 _slang_gen_do(slang_assemble_ctx * A, const slang_operation *oper)
2218 {
2219    /*
2220     * LOOP:
2221     *    body code (child[0])
2222     *    tail code:
2223     *       BREAK if !expr (child[1])
2224     */
2225    slang_ir_node *prevLoop, *loop;
2226    GLboolean isConst, constTrue;
2227
2228    /* type-check expression */
2229    if (!_slang_is_boolean(A, &oper->children[1])) {
2230       slang_info_log_error(A->log, "scalar/boolean expression expected for 'do/while'");
2231       return NULL;
2232    }
2233
2234    loop = new_loop(NULL);
2235
2236    /* save old, push new loop */
2237    prevLoop = A->CurLoop;
2238    A->CurLoop = loop;
2239
2240    /* loop body: */
2241    loop->Children[0] = _slang_gen_operation(A, &oper->children[0]);
2242
2243    /* Check if loop condition is a constant */
2244    isConst = _slang_is_constant_cond(&oper->children[1], &constTrue);
2245    if (isConst && constTrue) {
2246       /* do { } while(1)   ==> no conditional break */
2247       loop->Children[1] = NULL; /* no tail code */
2248    }
2249    else {
2250       slang_ir_node *cond
2251          = new_cond(new_not(_slang_gen_operation(A, &oper->children[1])));
2252       loop->Children[1] = new_break_if_true(A->CurLoop, cond);
2253    }
2254
2255    /* XXX we should do infinite loop detection, as above */
2256
2257    /* pop loop, restore prev */
2258    A->CurLoop = prevLoop;
2259
2260    return loop;
2261 }
2262
2263
2264 /**
2265  * Generate for-loop using high-level IR_LOOP instruction.
2266  */
2267 static slang_ir_node *
2268 _slang_gen_for(slang_assemble_ctx * A, const slang_operation *oper)
2269 {
2270    /*
2271     * init code (child[0])
2272     * LOOP:
2273     *    BREAK if !expr (child[1])
2274     *    body code (child[3])
2275     *    tail code:
2276     *       incr code (child[2])   // XXX continue here
2277     */
2278    slang_ir_node *prevLoop, *loop, *cond, *breakIf, *body, *init, *incr;
2279
2280    init = _slang_gen_operation(A, &oper->children[0]);
2281    loop = new_loop(NULL);
2282
2283    /* save old, push new loop */
2284    prevLoop = A->CurLoop;
2285    A->CurLoop = loop;
2286
2287    cond = new_cond(new_not(_slang_gen_operation(A, &oper->children[1])));
2288    breakIf = new_break_if_true(A->CurLoop, cond);
2289    body = _slang_gen_operation(A, &oper->children[3]);
2290    incr = _slang_gen_operation(A, &oper->children[2]);
2291
2292    loop->Children[0] = new_seq(breakIf, body);
2293    loop->Children[1] = incr;  /* tail code */
2294
2295    /* pop loop, restore prev */
2296    A->CurLoop = prevLoop;
2297
2298    return new_seq(init, loop);
2299 }
2300
2301
2302 static slang_ir_node *
2303 _slang_gen_continue(slang_assemble_ctx * A, const slang_operation *oper)
2304 {
2305    slang_ir_node *n, *loopNode;
2306    assert(oper->type == SLANG_OPER_CONTINUE);
2307    loopNode = A->CurLoop;
2308    assert(loopNode);
2309    assert(loopNode->Opcode == IR_LOOP);
2310    n = new_node0(IR_CONT);
2311    if (n) {
2312       n->Parent = loopNode;
2313       /* insert this node at head of linked list */
2314       n->List = loopNode->List;
2315       loopNode->List = n;
2316    }
2317    return n;
2318 }
2319
2320
2321 /**
2322  * Determine if the given operation is of a specific type.
2323  */
2324 static GLboolean
2325 is_operation_type(const slang_operation *oper, slang_operation_type type)
2326 {
2327    if (oper->type == type)
2328       return GL_TRUE;
2329    else if ((oper->type == SLANG_OPER_BLOCK_NEW_SCOPE ||
2330              oper->type == SLANG_OPER_BLOCK_NO_NEW_SCOPE) &&
2331             oper->num_children == 1)
2332       return is_operation_type(&oper->children[0], type);
2333    else
2334       return GL_FALSE;
2335 }
2336
2337
2338 /**
2339  * Generate IR tree for an if/then/else conditional using high-level
2340  * IR_IF instruction.
2341  */
2342 static slang_ir_node *
2343 _slang_gen_if(slang_assemble_ctx * A, const slang_operation *oper)
2344 {
2345    /*
2346     * eval expr (child[0])
2347     * IF expr THEN
2348     *    if-body code
2349     * ELSE
2350     *    else-body code
2351     * ENDIF
2352     */
2353    const GLboolean haveElseClause = !_slang_is_noop(&oper->children[2]);
2354    slang_ir_node *ifNode, *cond, *ifBody, *elseBody;
2355    GLboolean isConst, constTrue;
2356
2357    /* type-check expression */
2358    if (!_slang_is_boolean(A, &oper->children[0])) {
2359       slang_info_log_error(A->log, "boolean expression expected for 'if'");
2360       return NULL;
2361    }
2362
2363    if (!_slang_is_scalar_or_boolean(A, &oper->children[0])) {
2364       slang_info_log_error(A->log, "scalar/boolean expression expected for 'if'");
2365       return NULL;
2366    }
2367
2368    isConst = _slang_is_constant_cond(&oper->children[0], &constTrue);
2369    if (isConst) {
2370       if (constTrue) {
2371          /* if (true) ... */
2372          return _slang_gen_operation(A, &oper->children[1]);
2373       }
2374       else {
2375          /* if (false) ... */
2376          return _slang_gen_operation(A, &oper->children[2]);
2377       }
2378    }
2379
2380    cond = _slang_gen_operation(A, &oper->children[0]);
2381    cond = new_cond(cond);
2382
2383    if (is_operation_type(&oper->children[1], SLANG_OPER_BREAK)
2384        && !haveElseClause) {
2385       /* Special case: generate a conditional break */
2386       ifBody = new_break_if_true(A->CurLoop, cond);
2387       return ifBody;
2388    }
2389    else if (is_operation_type(&oper->children[1], SLANG_OPER_CONTINUE)
2390             && !haveElseClause) {
2391       /* Special case: generate a conditional break */
2392       ifBody = new_cont_if_true(A->CurLoop, cond);
2393       return ifBody;
2394    }
2395    else {
2396       /* general case */
2397       ifBody = _slang_gen_operation(A, &oper->children[1]);
2398       if (haveElseClause)
2399          elseBody = _slang_gen_operation(A, &oper->children[2]);
2400       else
2401          elseBody = NULL;
2402       ifNode = new_if(cond, ifBody, elseBody);
2403       return ifNode;
2404    }
2405 }
2406
2407
2408
2409 static slang_ir_node *
2410 _slang_gen_not(slang_assemble_ctx * A, const slang_operation *oper)
2411 {
2412    slang_ir_node *n;
2413
2414    assert(oper->type == SLANG_OPER_NOT);
2415
2416    /* type-check expression */
2417    if (!_slang_is_scalar_or_boolean(A, &oper->children[0])) {
2418       slang_info_log_error(A->log,
2419                            "scalar/boolean expression expected for '!'");
2420       return NULL;
2421    }
2422
2423    n = _slang_gen_operation(A, &oper->children[0]);
2424    if (n)
2425       return new_not(n);
2426    else
2427       return NULL;
2428 }
2429
2430
2431 static slang_ir_node *
2432 _slang_gen_xor(slang_assemble_ctx * A, const slang_operation *oper)
2433 {
2434    slang_ir_node *n1, *n2;
2435
2436    assert(oper->type == SLANG_OPER_LOGICALXOR);
2437
2438    if (!_slang_is_scalar_or_boolean(A, &oper->children[0]) ||
2439        !_slang_is_scalar_or_boolean(A, &oper->children[0])) {
2440       slang_info_log_error(A->log,
2441                            "scalar/boolean expressions expected for '^^'");
2442       return NULL;
2443    }
2444
2445    n1 = _slang_gen_operation(A, &oper->children[0]);
2446    if (!n1)
2447       return NULL;
2448    n2 = _slang_gen_operation(A, &oper->children[1]);
2449    if (!n2)
2450       return NULL;
2451    return new_node2(IR_NOTEQUAL, n1, n2);
2452 }
2453
2454
2455 /**
2456  * Generate IR node for storage of a temporary of given size.
2457  */
2458 static slang_ir_node *
2459 _slang_gen_temporary(GLint size)
2460 {
2461    slang_ir_storage *store;
2462    slang_ir_node *n = NULL;
2463
2464    store = _slang_new_ir_storage(PROGRAM_TEMPORARY, -2, size);
2465    if (store) {
2466       n = new_node0(IR_VAR_DECL);
2467       if (n) {
2468          n->Store = store;
2469       }
2470       else {
2471          _slang_free(store);
2472       }
2473    }
2474    return n;
2475 }
2476
2477
2478 /**
2479  * Generate IR node for allocating/declaring a variable.
2480  */
2481 static slang_ir_node *
2482 _slang_gen_var_decl(slang_assemble_ctx *A, slang_variable *var)
2483 {
2484    slang_ir_node *n;
2485
2486    /*assert(!var->declared);*/
2487    var->declared = GL_TRUE;
2488
2489    n = new_node0(IR_VAR_DECL);
2490    if (!n)
2491       return NULL;
2492
2493    _slang_attach_storage(n, var);
2494    assert(var->store);
2495    assert(n->Store == var->store);
2496    assert(n->Store);
2497    assert(n->Store->Index < 0);
2498
2499    if (is_sampler_type(&var->type)) {
2500       n->Store->File = PROGRAM_SAMPLER;
2501    }
2502    else {
2503       n->Store->File = PROGRAM_TEMPORARY;
2504    }
2505
2506    n->Store->Size = _slang_sizeof_type_specifier(&n->Var->type.specifier);
2507
2508    if (n->Store->Size <= 0) {
2509       slang_info_log_error(A->log, "invalid declaration for '%s'",
2510                            (char*) var->a_name);
2511       return NULL;
2512    }
2513 #if 0
2514    printf("%s var %p %s  store=%p index=%d size=%d\n",
2515           __FUNCTION__, (void *) var, (char *) var->a_name,
2516           (void *) n->Store, n->Store->Index, n->Store->Size);
2517 #endif
2518
2519    if (var->array_len > 0) {
2520       /* this is an array */
2521       /* round up the element size to a multiple of 4 */
2522       GLint sz = (n->Store->Size + 3) & ~3;
2523       /* total size = element size * array length */
2524       sz *= var->array_len;
2525       n->Store->Size = sz;
2526    }
2527
2528    /* setup default swizzle for storing the variable */
2529    /* XXX this may not be needed anymore - remove & test */
2530    switch (n->Store->Size) {
2531    case 2:
2532       n->Store->Swizzle = MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_Y,
2533                                         SWIZZLE_NIL, SWIZZLE_NIL);
2534       break;
2535    case 3:
2536       n->Store->Swizzle = MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_Y,
2537                                         SWIZZLE_Z, SWIZZLE_NIL);
2538       break;
2539    default:
2540       /* Note that float-sized vars may be allocated in any x/y/z/w
2541        * slot, but that won't be determined until code emit time.
2542        */
2543       n->Store->Swizzle = SWIZZLE_NOOP;
2544    }
2545
2546    return n;
2547 }
2548
2549
2550 /**
2551  * Generate code for a selection expression:   b ? x : y
2552  * XXX In some cases we could implement a selection expression
2553  * with an LRP instruction (use the boolean as the interpolant).
2554  * Otherwise, we use an IF/ELSE/ENDIF construct.
2555  */
2556 static slang_ir_node *
2557 _slang_gen_select(slang_assemble_ctx *A, slang_operation *oper)
2558 {
2559    slang_ir_node *cond, *ifNode, *trueExpr, *falseExpr, *trueNode, *falseNode;
2560    slang_ir_node *tmpDecl, *tmpVar, *tree;
2561    slang_typeinfo type0, type1, type2;
2562    int size, isBool, isEqual;
2563
2564    assert(oper->type == SLANG_OPER_SELECT);
2565    assert(oper->num_children == 3);
2566
2567    /* type of children[0] must be boolean */
2568    slang_typeinfo_construct(&type0);
2569    _slang_typeof_operation(A, &oper->children[0], &type0);
2570    isBool = (type0.spec.type == SLANG_SPEC_BOOL);
2571    slang_typeinfo_destruct(&type0);
2572    if (!isBool) {
2573       slang_info_log_error(A->log, "selector type is not boolean");
2574       return NULL;
2575    }
2576
2577    slang_typeinfo_construct(&type1);
2578    slang_typeinfo_construct(&type2);
2579    _slang_typeof_operation(A, &oper->children[1], &type1);
2580    _slang_typeof_operation(A, &oper->children[2], &type2);
2581    isEqual = slang_type_specifier_equal(&type1.spec, &type2.spec);
2582    slang_typeinfo_destruct(&type1);
2583    slang_typeinfo_destruct(&type2);
2584    if (!isEqual) {
2585       slang_info_log_error(A->log, "incompatible types for ?: operator");
2586       return NULL;
2587    }
2588
2589    /* size of x or y's type */
2590    size = _slang_sizeof_type_specifier(&type1.spec);
2591    assert(size > 0);
2592
2593    /* temporary var */
2594    tmpDecl = _slang_gen_temporary(size);
2595
2596    /* the condition (child 0) */
2597    cond = _slang_gen_operation(A, &oper->children[0]);
2598    cond = new_cond(cond);
2599
2600    /* if-true body (child 1) */
2601    tmpVar = new_node0(IR_VAR);
2602    tmpVar->Store = tmpDecl->Store;
2603    trueExpr = _slang_gen_operation(A, &oper->children[1]);
2604    trueNode = new_node2(IR_COPY, tmpVar, trueExpr);
2605
2606    /* if-false body (child 2) */
2607    tmpVar = new_node0(IR_VAR);
2608    tmpVar->Store = tmpDecl->Store;
2609    falseExpr = _slang_gen_operation(A, &oper->children[2]);
2610    falseNode = new_node2(IR_COPY, tmpVar, falseExpr);
2611
2612    ifNode = new_if(cond, trueNode, falseNode);
2613
2614    /* tmp var value */
2615    tmpVar = new_node0(IR_VAR);
2616    tmpVar->Store = tmpDecl->Store;
2617
2618    tree = new_seq(ifNode, tmpVar);
2619    tree = new_seq(tmpDecl, tree);
2620
2621    /*_slang_print_ir_tree(tree, 10);*/
2622    return tree;
2623 }
2624
2625
2626 /**
2627  * Generate code for &&.
2628  */
2629 static slang_ir_node *
2630 _slang_gen_logical_and(slang_assemble_ctx *A, slang_operation *oper)
2631 {
2632    /* rewrite "a && b" as  "a ? b : false" */
2633    slang_operation *select;
2634    slang_ir_node *n;
2635
2636    select = slang_operation_new(1);
2637    select->type = SLANG_OPER_SELECT;
2638    select->num_children = 3;
2639    select->children = slang_operation_new(3);
2640
2641    slang_operation_copy(&select->children[0], &oper->children[0]);
2642    slang_operation_copy(&select->children[1], &oper->children[1]);
2643    select->children[2].type = SLANG_OPER_LITERAL_BOOL;
2644    ASSIGN_4V(select->children[2].literal, 0, 0, 0, 0); /* false */
2645    select->children[2].literal_size = 1;
2646
2647    n = _slang_gen_select(A, select);
2648    return n;
2649 }
2650
2651
2652 /**
2653  * Generate code for ||.
2654  */
2655 static slang_ir_node *
2656 _slang_gen_logical_or(slang_assemble_ctx *A, slang_operation *oper)
2657 {
2658    /* rewrite "a || b" as  "a ? true : b" */
2659    slang_operation *select;
2660    slang_ir_node *n;
2661
2662    select = slang_operation_new(1);
2663    select->type = SLANG_OPER_SELECT;
2664    select->num_children = 3;
2665    select->children = slang_operation_new(3);
2666
2667    slang_operation_copy(&select->children[0], &oper->children[0]);
2668    select->children[1].type = SLANG_OPER_LITERAL_BOOL;
2669    ASSIGN_4V(select->children[1].literal, 1, 1, 1, 1); /* true */
2670    select->children[1].literal_size = 1;
2671    slang_operation_copy(&select->children[2], &oper->children[1]);
2672
2673    n = _slang_gen_select(A, select);
2674    return n;
2675 }
2676
2677
2678 /**
2679  * Generate IR tree for a return statement.
2680  */
2681 static slang_ir_node *
2682 _slang_gen_return(slang_assemble_ctx * A, slang_operation *oper)
2683 {
2684    const GLboolean haveReturnValue
2685       = (oper->num_children == 1 && oper->children[0].type != SLANG_OPER_VOID);
2686
2687    /* error checking */
2688    assert(A->CurFunction);
2689    if (haveReturnValue &&
2690        A->CurFunction->header.type.specifier.type == SLANG_SPEC_VOID) {
2691       slang_info_log_error(A->log, "illegal return expression");
2692       return NULL;
2693    }
2694    else if (!haveReturnValue &&
2695             A->CurFunction->header.type.specifier.type != SLANG_SPEC_VOID) {
2696       slang_info_log_error(A->log, "return statement requires an expression");
2697       return NULL;
2698    }
2699
2700    if (!haveReturnValue) {
2701       return new_return(A->curFuncEndLabel);
2702    }
2703    else {
2704       /*
2705        * Convert from:
2706        *   return expr;
2707        * To:
2708        *   __retVal = expr;
2709        *   return;  // goto __endOfFunction
2710        */
2711       slang_operation *assign;
2712       slang_atom a_retVal;
2713       slang_ir_node *n;
2714
2715       a_retVal = slang_atom_pool_atom(A->atoms, "__retVal");
2716       assert(a_retVal);
2717
2718 #if 1 /* DEBUG */
2719       {
2720          slang_variable *v
2721             = _slang_locate_variable(oper->locals, a_retVal, GL_TRUE);
2722          if (!v) {
2723             /* trying to return a value in a void-valued function */
2724             return NULL;
2725          }
2726       }
2727 #endif
2728
2729       assign = slang_operation_new(1);
2730       assign->type = SLANG_OPER_ASSIGN;
2731       assign->num_children = 2;
2732       assign->children = slang_operation_new(2);
2733       /* lhs (__retVal) */
2734       assign->children[0].type = SLANG_OPER_IDENTIFIER;
2735       assign->children[0].a_id = a_retVal;
2736       assign->children[0].locals->outer_scope = assign->locals;
2737       /* rhs (expr) */
2738       /* XXX we might be able to avoid this copy someday */
2739       slang_operation_copy(&assign->children[1], &oper->children[0]);
2740
2741       /* assemble the new code */
2742       n = new_seq(_slang_gen_operation(A, assign),
2743                   new_return(A->curFuncEndLabel));
2744
2745       slang_operation_delete(assign);
2746       return n;
2747    }
2748 }
2749
2750
2751 /**
2752  * Determine if the given operation/expression is const-valued.
2753  */
2754 static GLboolean
2755 _slang_is_constant_expr(const slang_operation *oper)
2756 {
2757    slang_variable *var;
2758    GLuint i;
2759
2760    switch (oper->type) {
2761    case SLANG_OPER_IDENTIFIER:
2762       var = _slang_locate_variable(oper->locals, oper->a_id, GL_TRUE);
2763       if (var && var->type.qualifier == SLANG_QUAL_CONST)
2764          return GL_TRUE;
2765       return GL_FALSE;
2766    default:
2767       for (i = 0; i < oper->num_children; i++) {
2768          if (!_slang_is_constant_expr(&oper->children[i]))
2769             return GL_FALSE;
2770       }
2771       return GL_TRUE;
2772    }
2773 }
2774
2775
2776 /**
2777  * Check if an assignment of type t1 to t0 is legal.
2778  * XXX more cases needed.
2779  */
2780 static GLboolean
2781 _slang_assignment_compatible(slang_assemble_ctx *A,
2782                              slang_operation *op0,
2783                              slang_operation *op1)
2784 {
2785    slang_typeinfo t0, t1;
2786    GLuint sz0, sz1;
2787
2788    if (op0->type == SLANG_OPER_POSTINCREMENT ||
2789        op0->type == SLANG_OPER_POSTDECREMENT) {
2790       return GL_FALSE;
2791    }
2792
2793    slang_typeinfo_construct(&t0);
2794    _slang_typeof_operation(A, op0, &t0);
2795
2796    slang_typeinfo_construct(&t1);
2797    _slang_typeof_operation(A, op1, &t1);
2798
2799    sz0 = _slang_sizeof_type_specifier(&t0.spec);
2800    sz1 = _slang_sizeof_type_specifier(&t1.spec);
2801
2802 #if 1
2803    if (sz0 != sz1) {
2804       /*printf("assignment size mismatch %u vs %u\n", sz0, sz1);*/
2805       return GL_FALSE;
2806    }
2807 #endif
2808
2809    if (t0.spec.type == SLANG_SPEC_STRUCT &&
2810        t1.spec.type == SLANG_SPEC_STRUCT &&
2811        t0.spec._struct->a_name != t1.spec._struct->a_name)
2812       return GL_FALSE;
2813
2814    if (t0.spec.type == SLANG_SPEC_FLOAT &&
2815        t1.spec.type == SLANG_SPEC_BOOL)
2816       return GL_FALSE;
2817
2818 #if 0 /* not used just yet - causes problems elsewhere */
2819    if (t0.spec.type == SLANG_SPEC_INT &&
2820        t1.spec.type == SLANG_SPEC_FLOAT)
2821       return GL_FALSE;
2822 #endif
2823
2824    if (t0.spec.type == SLANG_SPEC_BOOL &&
2825        t1.spec.type == SLANG_SPEC_FLOAT)
2826       return GL_FALSE;
2827
2828    if (t0.spec.type == SLANG_SPEC_BOOL &&
2829        t1.spec.type == SLANG_SPEC_INT)
2830       return GL_FALSE;
2831
2832    return GL_TRUE;
2833 }
2834
2835
2836
2837 /**
2838  * Generate IR tree for a variable declaration.
2839  */
2840 static slang_ir_node *
2841 _slang_gen_declaration(slang_assemble_ctx *A, slang_operation *oper)
2842 {
2843    slang_ir_node *n;
2844    slang_ir_node *varDecl;
2845    slang_variable *var;
2846    const char *varName = (char *) oper->a_id;
2847    slang_operation *initializer;
2848
2849    assert(oper->type == SLANG_OPER_VARIABLE_DECL);
2850    assert(oper->num_children <= 1);
2851
2852    var = _slang_locate_variable(oper->locals, oper->a_id, GL_TRUE);
2853    if (!var)
2854       return NULL;  /* "shouldn't happen" */
2855
2856    if (var->type.qualifier == SLANG_QUAL_ATTRIBUTE ||
2857        var->type.qualifier == SLANG_QUAL_VARYING ||
2858        var->type.qualifier == SLANG_QUAL_UNIFORM) {
2859       /* can't declare attribute/uniform vars inside functions */
2860       slang_info_log_error(A->log,
2861                 "local variable '%s' cannot be an attribute/uniform/varying",
2862                 varName);
2863       return NULL;
2864    }
2865
2866 #if 0
2867    if (v->declared) {
2868       slang_info_log_error(A->log, "variable '%s' redeclared", varName);
2869       return NULL;
2870    }
2871 #endif
2872
2873    varDecl = _slang_gen_var_decl(A, var);
2874    if (!varDecl)
2875       return NULL;
2876
2877    /* check if the var has an initializer */
2878    if (oper->num_children > 0) {
2879       assert(oper->num_children == 1);
2880       initializer = &oper->children[0];
2881    }
2882    else if (var->initializer) {
2883       initializer = var->initializer;
2884    }
2885    else {
2886       initializer = NULL;
2887    }
2888
2889    if (var->type.qualifier == SLANG_QUAL_CONST && !initializer) {
2890       slang_info_log_error(A->log,
2891                            "const-qualified variable '%s' requires initializer",
2892                            varName);
2893       return NULL;
2894    }
2895
2896
2897    if (initializer) {
2898       slang_ir_node *varRef, *init;
2899
2900       /* type check/compare var and initializer */
2901       if (!_slang_assignment_compatible(A, oper, initializer)) {
2902          slang_info_log_error(A->log, "incompatible types in assignment");
2903          return NULL;
2904       }
2905
2906       varRef = new_var(A, var);
2907       if (!varRef) {
2908          slang_info_log_error(A->log, "undefined variable '%s'", varName);
2909          return NULL;
2910       }
2911
2912       if (var->type.qualifier == SLANG_QUAL_CONST) {
2913          /* if the variable is const, the initializer must be a const
2914           * expression as well.
2915           */
2916 #if 0
2917          if (!_slang_is_constant_expr(initializer)) {
2918             slang_info_log_error(A->log,
2919                                  "initializer for %s not constant", varName);
2920             return NULL;
2921          }
2922 #endif
2923       }
2924
2925       _slang_simplify(initializer, &A->space, A->atoms);
2926
2927       init = _slang_gen_operation(A, initializer);
2928       if (!init)
2929          return NULL;
2930
2931       /*assert(init->Store);*/
2932
2933       /* XXX remove this when type checking is added above */
2934       if (init->Store && varRef->Store->Size != init->Store->Size) {
2935          slang_info_log_error(A->log, "invalid assignment (wrong types)");
2936          return NULL;
2937       }
2938
2939       n = new_node2(IR_COPY, varRef, init);
2940       n = new_seq(varDecl, n);
2941    }
2942    else {
2943       n = varDecl;
2944    }
2945
2946    return n;
2947 }
2948
2949
2950 /**
2951  * Generate IR tree for a variable (such as in an expression).
2952  */
2953 static slang_ir_node *
2954 _slang_gen_variable(slang_assemble_ctx * A, slang_operation *oper)
2955 {
2956    /* If there's a variable associated with this oper (from inlining)
2957     * use it.  Otherwise, use the oper's var id.
2958     */
2959    slang_atom name = oper->var ? oper->var->a_name : oper->a_id;
2960    slang_variable *var = _slang_locate_variable(oper->locals, name, GL_TRUE);
2961    slang_ir_node *n = new_var(A, var);
2962    if (!n) {
2963       slang_info_log_error(A->log, "undefined variable '%s'", (char *) name);
2964       return NULL;
2965    }
2966    return n;
2967 }
2968
2969
2970
2971 /**
2972  * Return the number of components actually named by the swizzle.
2973  * Recall that swizzles may have undefined/don't-care values.
2974  */
2975 static GLuint
2976 swizzle_size(GLuint swizzle)
2977 {
2978    GLuint size = 0, i;
2979    for (i = 0; i < 4; i++) {
2980       GLuint swz = GET_SWZ(swizzle, i);
2981       size += (swz >= 0 && swz <= 3);
2982    }
2983    return size;
2984 }
2985
2986
2987 static slang_ir_node *
2988 _slang_gen_swizzle(slang_ir_node *child, GLuint swizzle)
2989 {
2990    slang_ir_node *n = new_node1(IR_SWIZZLE, child);
2991    assert(child);
2992    if (n) {
2993       assert(!n->Store);
2994       n->Store = _slang_new_ir_storage_relative(0,
2995                                                 swizzle_size(swizzle),
2996                                                 child->Store);
2997       n->Store->Swizzle = swizzle;
2998    }
2999    return n;
3000 }
3001
3002
3003 static GLboolean
3004 is_store_writable(const slang_assemble_ctx *A, const slang_ir_storage *store)
3005 {
3006    while (store->Parent)
3007       store = store->Parent;
3008
3009    if (!(store->File == PROGRAM_OUTPUT ||
3010          store->File == PROGRAM_TEMPORARY ||
3011          (store->File == PROGRAM_VARYING &&
3012           A->program->Target == GL_VERTEX_PROGRAM_ARB))) {
3013       return GL_FALSE;
3014    }
3015    else {
3016       return GL_TRUE;
3017    }
3018 }
3019
3020
3021 /**
3022  * Generate IR tree for an assignment (=).
3023  */
3024 static slang_ir_node *
3025 _slang_gen_assignment(slang_assemble_ctx * A, slang_operation *oper)
3026 {
3027    if (oper->children[0].type == SLANG_OPER_IDENTIFIER) {
3028       /* Check that var is writeable */
3029       slang_variable *var
3030          = _slang_locate_variable(oper->children[0].locals,
3031                                   oper->children[0].a_id, GL_TRUE);
3032       if (!var) {
3033          slang_info_log_error(A->log, "undefined variable '%s'",
3034                               (char *) oper->children[0].a_id);
3035          return NULL;
3036       }
3037       if (var->type.qualifier == SLANG_QUAL_CONST ||
3038           var->type.qualifier == SLANG_QUAL_ATTRIBUTE ||
3039           var->type.qualifier == SLANG_QUAL_UNIFORM ||
3040           (var->type.qualifier == SLANG_QUAL_VARYING &&
3041            A->program->Target == GL_FRAGMENT_PROGRAM_ARB)) {
3042          slang_info_log_error(A->log,
3043                               "illegal assignment to read-only variable '%s'",
3044                               (char *) oper->children[0].a_id);
3045          return NULL;
3046       }
3047    }
3048
3049    if (oper->children[0].type == SLANG_OPER_IDENTIFIER &&
3050        oper->children[1].type == SLANG_OPER_CALL) {
3051       /* Special case of:  x = f(a, b)
3052        * Replace with f(a, b, x)  (where x == hidden __retVal out param)
3053        *
3054        * XXX this could be even more effective if we could accomodate
3055        * cases such as "v.x = f();"  - would help with typical vertex
3056        * transformation.
3057        */
3058       slang_ir_node *n;
3059       n = _slang_gen_function_call_name(A,
3060                                       (const char *) oper->children[1].a_id,
3061                                       &oper->children[1], &oper->children[0]);
3062       return n;
3063    }
3064    else {
3065       slang_ir_node *n, *lhs, *rhs;
3066
3067       /* lhs and rhs type checking */
3068       if (!_slang_assignment_compatible(A,
3069                                         &oper->children[0],
3070                                         &oper->children[1])) {
3071          slang_info_log_error(A->log, "incompatible types in assignment");
3072          return NULL;
3073       }
3074
3075       lhs = _slang_gen_operation(A, &oper->children[0]);
3076       if (!lhs) {
3077          return NULL;
3078       }
3079
3080       if (!lhs->Store) {
3081          slang_info_log_error(A->log,
3082                               "invalid left hand side for assignment");
3083          return NULL;
3084       }
3085
3086       /* check that lhs is writable */
3087       if (!is_store_writable(A, lhs->Store)) {
3088          slang_info_log_error(A->log,
3089                               "illegal assignment to read-only l-value");
3090          return NULL;
3091       }
3092
3093       rhs = _slang_gen_operation(A, &oper->children[1]);
3094       if (lhs && rhs) {
3095          /* convert lhs swizzle into writemask */
3096          GLuint writemask, newSwizzle;
3097          if (!swizzle_to_writemask(A, lhs->Store->Swizzle,
3098                                    &writemask, &newSwizzle)) {
3099             /* Non-simple writemask, need to swizzle right hand side in
3100              * order to put components into the right place.
3101              */
3102             rhs = _slang_gen_swizzle(rhs, newSwizzle);
3103          }
3104          n = new_node2(IR_COPY, lhs, rhs);
3105          return n;
3106       }
3107       else {
3108          return NULL;
3109       }
3110    }
3111 }
3112
3113
3114 /**
3115  * Generate IR tree for referencing a field in a struct (or basic vector type)
3116  */
3117 static slang_ir_node *
3118 _slang_gen_struct_field(slang_assemble_ctx * A, slang_operation *oper)
3119 {
3120    slang_typeinfo ti;
3121
3122    /* type of struct */
3123    slang_typeinfo_construct(&ti);
3124    _slang_typeof_operation(A, &oper->children[0], &ti);
3125
3126    if (_slang_type_is_vector(ti.spec.type)) {
3127       /* the field should be a swizzle */
3128       const GLuint rows = _slang_type_dim(ti.spec.type);
3129       slang_swizzle swz;
3130       slang_ir_node *n;
3131       GLuint swizzle;
3132       if (!_slang_is_swizzle((char *) oper->a_id, rows, &swz)) {
3133          slang_info_log_error(A->log, "Bad swizzle");
3134          return NULL;
3135       }
3136       swizzle = MAKE_SWIZZLE4(swz.swizzle[0],
3137                               swz.swizzle[1],
3138                               swz.swizzle[2],
3139                               swz.swizzle[3]);
3140
3141       n = _slang_gen_operation(A, &oper->children[0]);
3142       /* create new parent node with swizzle */
3143       if (n)
3144          n = _slang_gen_swizzle(n, swizzle);
3145       return n;
3146    }
3147    else if (   ti.spec.type == SLANG_SPEC_FLOAT
3148             || ti.spec.type == SLANG_SPEC_INT
3149             || ti.spec.type == SLANG_SPEC_BOOL) {
3150       const GLuint rows = 1;
3151       slang_swizzle swz;
3152       slang_ir_node *n;
3153       GLuint swizzle;
3154       if (!_slang_is_swizzle((char *) oper->a_id, rows, &swz)) {
3155          slang_info_log_error(A->log, "Bad swizzle");
3156       }
3157       swizzle = MAKE_SWIZZLE4(swz.swizzle[0],
3158                               swz.swizzle[1],
3159                               swz.swizzle[2],
3160                               swz.swizzle[3]);
3161       n = _slang_gen_operation(A, &oper->children[0]);
3162       /* create new parent node with swizzle */
3163       n = _slang_gen_swizzle(n, swizzle);
3164       return n;
3165    }
3166    else {
3167       /* the field is a structure member (base.field) */
3168       /* oper->children[0] is the base */
3169       /* oper->a_id is the field name */
3170       slang_ir_node *base, *n;
3171       slang_typeinfo field_ti;
3172       GLint fieldSize, fieldOffset = -1;
3173
3174       /* type of field */
3175       slang_typeinfo_construct(&field_ti);
3176       _slang_typeof_operation(A, oper, &field_ti);
3177
3178       fieldSize = _slang_sizeof_type_specifier(&field_ti.spec);
3179       if (fieldSize > 0)
3180          fieldOffset = _slang_field_offset(&ti.spec, oper->a_id);
3181
3182       if (fieldSize == 0 || fieldOffset < 0) {
3183          const char *structName;
3184          if (ti.spec._struct)
3185             structName = (char *) ti.spec._struct->a_name;
3186          else
3187             structName = "unknown";
3188          slang_info_log_error(A->log,
3189                               "\"%s\" is not a member of struct \"%s\"",
3190                               (char *) oper->a_id, structName);
3191          return NULL;
3192       }
3193       assert(fieldSize >= 0);
3194
3195       base = _slang_gen_operation(A, &oper->children[0]);
3196       if (!base) {
3197          /* error msg should have already been logged */
3198          return NULL;
3199       }
3200
3201       n = new_node1(IR_FIELD, base);
3202       if (!n)
3203          return NULL;
3204
3205       n->Field = (char *) oper->a_id;
3206
3207       /* Store the field's offset in storage->Index */
3208       n->Store = _slang_new_ir_storage(base->Store->File,
3209                                        fieldOffset,
3210                                        fieldSize);
3211
3212       return n;
3213    }
3214 }
3215
3216
3217 /**
3218  * Gen code for array indexing.
3219  */
3220 static slang_ir_node *
3221 _slang_gen_array_element(slang_assemble_ctx * A, slang_operation *oper)
3222 {
3223    slang_typeinfo array_ti;
3224
3225    /* get array's type info */
3226    slang_typeinfo_construct(&array_ti);
3227    _slang_typeof_operation(A, &oper->children[0], &array_ti);
3228
3229    if (_slang_type_is_vector(array_ti.spec.type)) {
3230       /* indexing a simple vector type: "vec4 v; v[0]=p;" */
3231       /* translate the index into a swizzle/writemask: "v.x=p" */
3232       const GLuint max = _slang_type_dim(array_ti.spec.type);
3233       GLint index;
3234       slang_ir_node *n;
3235
3236       index = (GLint) oper->children[1].literal[0];
3237       if (oper->children[1].type != SLANG_OPER_LITERAL_INT ||
3238           index >= (GLint) max) {
3239          slang_info_log_error(A->log, "Invalid array index for vector type");
3240          return NULL;
3241       }
3242
3243       n = _slang_gen_operation(A, &oper->children[0]);
3244       if (n) {
3245          /* use swizzle to access the element */
3246          GLuint swizzle = MAKE_SWIZZLE4(SWIZZLE_X + index,
3247                                         SWIZZLE_NIL,
3248                                         SWIZZLE_NIL,
3249                                         SWIZZLE_NIL);
3250          n = _slang_gen_swizzle(n, swizzle);
3251       }
3252       assert(n->Store);
3253       return n;
3254    }
3255    else {
3256       /* conventional array */
3257       slang_typeinfo elem_ti;
3258       slang_ir_node *elem, *array, *index;
3259       GLint elemSize, arrayLen;
3260
3261       /* size of array element */
3262       slang_typeinfo_construct(&elem_ti);
3263       _slang_typeof_operation(A, oper, &elem_ti);
3264       elemSize = _slang_sizeof_type_specifier(&elem_ti.spec);
3265
3266       if (_slang_type_is_matrix(array_ti.spec.type))
3267          arrayLen = _slang_type_dim(array_ti.spec.type);
3268       else
3269          arrayLen = array_ti.array_len;
3270
3271       slang_typeinfo_destruct(&array_ti);
3272       slang_typeinfo_destruct(&elem_ti);
3273
3274       if (elemSize <= 0) {
3275          /* unknown var or type */
3276          slang_info_log_error(A->log, "Undefined variable or type");
3277          return NULL;
3278       }
3279
3280       array = _slang_gen_operation(A, &oper->children[0]);
3281       index = _slang_gen_operation(A, &oper->children[1]);
3282       if (array && index) {
3283          /* bounds check */
3284          GLint constIndex = -1;
3285          if (index->Opcode == IR_FLOAT) {
3286             constIndex = (int) index->Value[0];
3287             if (constIndex < 0 || constIndex >= arrayLen) {
3288                slang_info_log_error(A->log,
3289                                 "Array index out of bounds (index=%d size=%d)",
3290                                  constIndex, arrayLen);
3291                _slang_free_ir_tree(array);
3292                _slang_free_ir_tree(index);
3293                return NULL;
3294             }
3295          }
3296
3297          if (!array->Store) {
3298             slang_info_log_error(A->log, "Invalid array");
3299             return NULL;
3300          }
3301
3302          elem = new_node2(IR_ELEMENT, array, index);
3303
3304          /* The storage info here will be updated during code emit */
3305          elem->Store = _slang_new_ir_storage(array->Store->File,
3306                                              array->Store->Index,
3307                                              elemSize);
3308
3309          return elem;
3310       }
3311       else {
3312          _slang_free_ir_tree(array);
3313          _slang_free_ir_tree(index);
3314          return NULL;
3315       }
3316    }
3317 }
3318
3319
3320 static slang_ir_node *
3321 _slang_gen_compare(slang_assemble_ctx *A, slang_operation *oper,
3322                    slang_ir_opcode opcode)
3323 {
3324    slang_typeinfo t0, t1;
3325    slang_ir_node *n;
3326
3327    slang_typeinfo_construct(&t0);
3328    _slang_typeof_operation(A, &oper->children[0], &t0);
3329
3330    slang_typeinfo_construct(&t1);
3331    _slang_typeof_operation(A, &oper->children[0], &t1);
3332
3333    if (t0.spec.type == SLANG_SPEC_ARRAY ||
3334        t1.spec.type == SLANG_SPEC_ARRAY) {
3335       slang_info_log_error(A->log, "Illegal array comparison");
3336       return NULL;
3337    }
3338
3339    if (oper->type != SLANG_OPER_EQUAL &&
3340        oper->type != SLANG_OPER_NOTEQUAL) {
3341       /* <, <=, >, >= can only be used with scalars */
3342       if ((t0.spec.type != SLANG_SPEC_INT &&
3343            t0.spec.type != SLANG_SPEC_FLOAT) ||
3344           (t1.spec.type != SLANG_SPEC_INT &&
3345            t1.spec.type != SLANG_SPEC_FLOAT)) {
3346          slang_info_log_error(A->log, "Incompatible type(s) for inequality operator");
3347          return NULL;
3348       }
3349    }
3350
3351    n =  new_node2(opcode,
3352                   _slang_gen_operation(A, &oper->children[0]),
3353                   _slang_gen_operation(A, &oper->children[1]));
3354
3355    /* result is a bool (size 1) */
3356    n->Store = _slang_new_ir_storage(PROGRAM_TEMPORARY, -1, 1);
3357
3358    return n;
3359 }
3360
3361
3362 #if 0
3363 static void
3364 print_vars(slang_variable_scope *s)
3365 {
3366    int i;
3367    printf("vars: ");
3368    for (i = 0; i < s->num_variables; i++) {
3369       printf("%s %d, \n",
3370              (char*) s->variables[i]->a_name,
3371              s->variables[i]->declared);
3372    }
3373
3374    printf("\n");
3375 }
3376 #endif
3377
3378
3379 #if 0
3380 static void
3381 _slang_undeclare_vars(slang_variable_scope *locals)
3382 {
3383    if (locals->num_variables > 0) {
3384       int i;
3385       for (i = 0; i < locals->num_variables; i++) {
3386          slang_variable *v = locals->variables[i];
3387          printf("undeclare %s at %p\n", (char*) v->a_name, v);
3388          v->declared = GL_FALSE;
3389       }
3390    }
3391 }
3392 #endif
3393
3394
3395 /**
3396  * Generate IR tree for a slang_operation (AST node)
3397  */
3398 static slang_ir_node *
3399 _slang_gen_operation(slang_assemble_ctx * A, slang_operation *oper)
3400 {
3401    switch (oper->type) {
3402    case SLANG_OPER_BLOCK_NEW_SCOPE:
3403       {
3404          slang_ir_node *n;
3405
3406          _slang_push_var_table(A->vartable);
3407
3408          oper->type = SLANG_OPER_BLOCK_NO_NEW_SCOPE; /* temp change */
3409          n = _slang_gen_operation(A, oper);
3410          oper->type = SLANG_OPER_BLOCK_NEW_SCOPE; /* restore */
3411
3412          _slang_pop_var_table(A->vartable);
3413
3414          /*_slang_undeclare_vars(oper->locals);*/
3415          /*print_vars(oper->locals);*/
3416
3417          if (n)
3418             n = new_node1(IR_SCOPE, n);
3419          return n;
3420       }
3421       break;
3422
3423    case SLANG_OPER_BLOCK_NO_NEW_SCOPE:
3424       /* list of operations */
3425       if (oper->num_children > 0)
3426       {
3427          slang_ir_node *n, *tree = NULL;
3428          GLuint i;
3429
3430          for (i = 0; i < oper->num_children; i++) {
3431             n = _slang_gen_operation(A, &oper->children[i]);
3432             if (!n) {
3433                _slang_free_ir_tree(tree);
3434                return NULL; /* error must have occured */
3435             }
3436             tree = new_seq(tree, n);
3437          }
3438
3439          return tree;
3440       }
3441       else {
3442          return new_node0(IR_NOP);
3443       }
3444
3445    case SLANG_OPER_EXPRESSION:
3446       return _slang_gen_operation(A, &oper->children[0]);
3447
3448    case SLANG_OPER_FOR:
3449       return _slang_gen_for(A, oper);
3450    case SLANG_OPER_DO:
3451       return _slang_gen_do(A, oper);
3452    case SLANG_OPER_WHILE:
3453       return _slang_gen_while(A, oper);
3454    case SLANG_OPER_BREAK:
3455       if (!A->CurLoop) {
3456          slang_info_log_error(A->log, "'break' not in loop");
3457          return NULL;
3458       }
3459       return new_break(A->CurLoop);
3460    case SLANG_OPER_CONTINUE:
3461       if (!A->CurLoop) {
3462          slang_info_log_error(A->log, "'continue' not in loop");
3463          return NULL;
3464       }
3465       return _slang_gen_continue(A, oper);
3466    case SLANG_OPER_DISCARD:
3467       return new_node0(IR_KILL);
3468
3469    case SLANG_OPER_EQUAL:
3470       return _slang_gen_compare(A, oper, IR_EQUAL);
3471    case SLANG_OPER_NOTEQUAL:
3472       return _slang_gen_compare(A, oper, IR_NOTEQUAL);
3473    case SLANG_OPER_GREATER:
3474       return _slang_gen_compare(A, oper, IR_SGT);
3475    case SLANG_OPER_LESS:
3476       return _slang_gen_compare(A, oper, IR_SLT);
3477    case SLANG_OPER_GREATEREQUAL:
3478       return _slang_gen_compare(A, oper, IR_SGE);
3479    case SLANG_OPER_LESSEQUAL:
3480       return _slang_gen_compare(A, oper, IR_SLE);
3481    case SLANG_OPER_ADD:
3482       {
3483          slang_ir_node *n;
3484          assert(oper->num_children == 2);
3485          n = _slang_gen_function_call_name(A, "+", oper, NULL);
3486          return n;
3487       }
3488    case SLANG_OPER_SUBTRACT:
3489       {
3490          slang_ir_node *n;
3491          assert(oper->num_children == 2);
3492          n = _slang_gen_function_call_name(A, "-", oper, NULL);
3493          return n;
3494       }
3495    case SLANG_OPER_MULTIPLY:
3496       {
3497          slang_ir_node *n;
3498          assert(oper->num_children == 2);
3499          n = _slang_gen_function_call_name(A, "*", oper, NULL);
3500          return n;
3501       }
3502    case SLANG_OPER_DIVIDE:
3503       {
3504          slang_ir_node *n;
3505          assert(oper->num_children == 2);
3506          n = _slang_gen_function_call_name(A, "/", oper, NULL);
3507          return n;
3508       }
3509    case SLANG_OPER_MINUS:
3510       {
3511          slang_ir_node *n;
3512          assert(oper->num_children == 1);
3513          n = _slang_gen_function_call_name(A, "-", oper, NULL);
3514          return n;
3515       }
3516    case SLANG_OPER_PLUS:
3517       /* +expr   --> do nothing */
3518       return _slang_gen_operation(A, &oper->children[0]);
3519    case SLANG_OPER_VARIABLE_DECL:
3520       return _slang_gen_declaration(A, oper);
3521    case SLANG_OPER_ASSIGN:
3522       return _slang_gen_assignment(A, oper);
3523    case SLANG_OPER_ADDASSIGN:
3524       {
3525          slang_ir_node *n;
3526          assert(oper->num_children == 2);
3527          n = _slang_gen_function_call_name(A, "+=", oper, NULL);
3528          return n;
3529       }
3530    case SLANG_OPER_SUBASSIGN:
3531       {
3532          slang_ir_node *n;
3533          assert(oper->num_children == 2);
3534          n = _slang_gen_function_call_name(A, "-=", oper, NULL);
3535          return n;
3536       }
3537       break;
3538    case SLANG_OPER_MULASSIGN:
3539       {
3540          slang_ir_node *n;
3541          assert(oper->num_children == 2);
3542          n = _slang_gen_function_call_name(A, "*=", oper, NULL);
3543          return n;
3544       }
3545    case SLANG_OPER_DIVASSIGN:
3546       {
3547          slang_ir_node *n;
3548          assert(oper->num_children == 2);
3549          n = _slang_gen_function_call_name(A, "/=", oper, NULL);
3550          return n;
3551       }
3552    case SLANG_OPER_LOGICALAND:
3553       {
3554          slang_ir_node *n;
3555          assert(oper->num_children == 2);
3556          n = _slang_gen_logical_and(A, oper);
3557          return n;
3558       }
3559    case SLANG_OPER_LOGICALOR:
3560       {
3561          slang_ir_node *n;
3562          assert(oper->num_children == 2);
3563          n = _slang_gen_logical_or(A, oper);
3564          return n;
3565       }
3566    case SLANG_OPER_LOGICALXOR:
3567       return _slang_gen_xor(A, oper);
3568    case SLANG_OPER_NOT:
3569       return _slang_gen_not(A, oper);
3570    case SLANG_OPER_SELECT:  /* b ? x : y */
3571       {
3572          slang_ir_node *n;
3573          assert(oper->num_children == 3);
3574          n = _slang_gen_select(A, oper);
3575          return n;
3576       }
3577
3578    case SLANG_OPER_ASM:
3579       return _slang_gen_asm(A, oper, NULL);
3580    case SLANG_OPER_CALL:
3581       return _slang_gen_function_call_name(A, (const char *) oper->a_id,
3582                                            oper, NULL);
3583    case SLANG_OPER_METHOD:
3584       return _slang_gen_method_call(A, oper);
3585    case SLANG_OPER_RETURN:
3586       return _slang_gen_return(A, oper);
3587    case SLANG_OPER_LABEL:
3588       return new_label(oper->label);
3589    case SLANG_OPER_IDENTIFIER:
3590       return _slang_gen_variable(A, oper);
3591    case SLANG_OPER_IF:
3592       return _slang_gen_if(A, oper);
3593    case SLANG_OPER_FIELD:
3594       return _slang_gen_struct_field(A, oper);
3595    case SLANG_OPER_SUBSCRIPT:
3596       return _slang_gen_array_element(A, oper);
3597    case SLANG_OPER_LITERAL_FLOAT:
3598       /* fall-through */
3599    case SLANG_OPER_LITERAL_INT:
3600       /* fall-through */
3601    case SLANG_OPER_LITERAL_BOOL:
3602       return new_float_literal(oper->literal, oper->literal_size);
3603
3604    case SLANG_OPER_POSTINCREMENT:   /* var++ */
3605       {
3606          slang_ir_node *n;
3607          assert(oper->num_children == 1);
3608          n = _slang_gen_function_call_name(A, "__postIncr", oper, NULL);
3609          return n;
3610       }
3611    case SLANG_OPER_POSTDECREMENT:   /* var-- */
3612       {
3613          slang_ir_node *n;
3614          assert(oper->num_children == 1);
3615          n = _slang_gen_function_call_name(A, "__postDecr", oper, NULL);
3616          return n;
3617       }
3618    case SLANG_OPER_PREINCREMENT:   /* ++var */
3619       {
3620          slang_ir_node *n;
3621          assert(oper->num_children == 1);
3622          n = _slang_gen_function_call_name(A, "++", oper, NULL);
3623          return n;
3624       }
3625    case SLANG_OPER_PREDECREMENT:   /* --var */
3626       {
3627          slang_ir_node *n;
3628          assert(oper->num_children == 1);
3629          n = _slang_gen_function_call_name(A, "--", oper, NULL);
3630          return n;
3631       }
3632
3633    case SLANG_OPER_NON_INLINED_CALL:
3634    case SLANG_OPER_SEQUENCE:
3635       {
3636          slang_ir_node *tree = NULL;
3637          GLuint i;
3638          for (i = 0; i < oper->num_children; i++) {
3639             slang_ir_node *n = _slang_gen_operation(A, &oper->children[i]);
3640             tree = new_seq(tree, n);
3641             if (n)
3642                tree->Store = n->Store;
3643          }
3644          if (oper->type == SLANG_OPER_NON_INLINED_CALL) {
3645             tree = new_function_call(tree, oper->label);
3646          }
3647          return tree;
3648       }
3649
3650    case SLANG_OPER_NONE:
3651    case SLANG_OPER_VOID:
3652       /* returning NULL here would generate an error */
3653       return new_node0(IR_NOP);
3654
3655    default:
3656       _mesa_problem(NULL, "bad node type %d in _slang_gen_operation",
3657                     oper->type);
3658       return new_node0(IR_NOP);
3659    }
3660
3661    return NULL;
3662 }
3663
3664
3665 /**
3666  * Compute total size of array give size of element, number of elements.
3667  */
3668 static GLint
3669 array_size(GLint baseSize, GLint arrayLen)
3670 {
3671    GLint total;
3672    if (arrayLen > 1) {
3673       /* round up base type to multiple of 4 */
3674       total = ((baseSize + 3) & ~0x3) * MAX2(arrayLen, 1);
3675    }
3676    else {
3677       total = baseSize;
3678    }
3679    return total;
3680 }
3681
3682
3683 /**
3684  * Called by compiler when a global variable has been parsed/compiled.
3685  * Here we examine the variable's type to determine what kind of register
3686  * storage will be used.
3687  *
3688  * A uniform such as "gl_Position" will become the register specification
3689  * (PROGRAM_OUTPUT, VERT_RESULT_HPOS).  Or, uniform "gl_FogFragCoord"
3690  * will be (PROGRAM_INPUT, FRAG_ATTRIB_FOGC).
3691  *
3692  * Samplers are interesting.  For "uniform sampler2D tex;" we'll specify
3693  * (PROGRAM_SAMPLER, index) where index is resolved at link-time to an
3694  * actual texture unit (as specified by the user calling glUniform1i()).
3695  */
3696 GLboolean
3697 _slang_codegen_global_variable(slang_assemble_ctx *A, slang_variable *var,
3698                                slang_unit_type type)
3699 {
3700    struct gl_program *prog = A->program;
3701    const char *varName = (char *) var->a_name;
3702    GLboolean success = GL_TRUE;
3703    slang_ir_storage *store = NULL;
3704    int dbg = 0;
3705    const GLenum datatype = _slang_gltype_from_specifier(&var->type.specifier);
3706    const GLint texIndex = sampler_to_texture_index(var->type.specifier.type);
3707    const GLint size = _slang_sizeof_type_specifier(&var->type.specifier);
3708
3709    if (texIndex != -1) {
3710       /* This is a texture sampler variable...
3711        * store->File = PROGRAM_SAMPLER
3712        * store->Index = sampler number (0..7, typically)
3713        * store->Size = texture type index (1D, 2D, 3D, cube, etc)
3714        */
3715       if (var->initializer) {
3716          slang_info_log_error(A->log, "illegal assignment to '%s'", varName);
3717          return GL_FALSE;
3718       }
3719 #if FEATURE_es2_glsl /* XXX should use FEATURE_texture_rect */
3720       /* disallow rect samplers */
3721       if (var->type.specifier.type == SLANG_SPEC_SAMPLER2DRECT ||
3722           var->type.specifier.type == SLANG_SPEC_SAMPLER2DRECTSHADOW) {
3723          slang_info_log_error(A->log, "invalid sampler type for '%s'", varName);
3724          return GL_FALSE;
3725       }
3726 #endif
3727       {
3728          GLint sampNum = _mesa_add_sampler(prog->Parameters, varName, datatype);
3729          store = _slang_new_ir_storage(PROGRAM_SAMPLER, sampNum, texIndex);
3730       }
3731       if (dbg) printf("SAMPLER ");
3732    }
3733    else if (var->type.qualifier == SLANG_QUAL_UNIFORM) {
3734       /* Uniform variable */
3735       const GLint totalSize = array_size(size, var->array_len);
3736       const GLuint swizzle = _slang_var_swizzle(totalSize, 0);
3737
3738       if (prog) {
3739          /* user-defined uniform */
3740          if (datatype == GL_NONE) {
3741             if (var->type.specifier.type == SLANG_SPEC_STRUCT) {
3742                /* temporary work-around */
3743                GLenum datatype = GL_FLOAT;
3744                GLint uniformLoc = _mesa_add_uniform(prog->Parameters, varName,
3745                                                     totalSize, datatype, NULL);
3746                store = _slang_new_ir_storage_swz(PROGRAM_UNIFORM, uniformLoc,
3747                                                  totalSize, swizzle);
3748
3749                /* XXX what we need to do is unroll the struct into its
3750                 * basic types, creating a uniform variable for each.
3751                 * For example:
3752                 * struct foo {
3753                 *   vec3 a;
3754                 *   vec4 b;
3755                 * };
3756                 * uniform foo f;
3757                 *
3758                 * Should produce uniforms:
3759                 * "f.a"  (GL_FLOAT_VEC3)
3760                 * "f.b"  (GL_FLOAT_VEC4)
3761                 */
3762
3763                if (var->initializer) {
3764                   slang_info_log_error(A->log,
3765                      "unsupported initializer for uniform '%s'", varName);
3766                   return GL_FALSE;
3767                }
3768             }
3769             else {
3770                slang_info_log_error(A->log,
3771                                     "invalid datatype for uniform variable %s",
3772                                     varName);
3773                return GL_FALSE;
3774             }
3775          }
3776          else {
3777             GLint uniformLoc;
3778             const GLfloat *initialValues = NULL;
3779             if (var->initializer) {
3780                _slang_simplify(var->initializer, &A->space, A->atoms);
3781                if (var->initializer->type == SLANG_OPER_LITERAL_FLOAT ||
3782                    var->initializer->type == SLANG_OPER_LITERAL_INT) {
3783                   /* simple float/vector initializer */
3784                   initialValues = var->initializer->literal;
3785                }
3786                else {
3787                   /* complex initializer */
3788                   slang_info_log_error(A->log,
3789                      "unsupported initializer for uniform '%s'", varName);
3790                   return GL_FALSE;
3791                }
3792             }
3793
3794             uniformLoc = _mesa_add_uniform(prog->Parameters, varName,
3795                                            totalSize, datatype, initialValues);
3796             store = _slang_new_ir_storage_swz(PROGRAM_UNIFORM, uniformLoc,
3797                                               totalSize, swizzle);
3798          }
3799       }
3800       else {
3801          /* pre-defined uniform, like gl_ModelviewMatrix */
3802          /* We know it's a uniform, but don't allocate storage unless
3803           * it's really used.
3804           */
3805          store = _slang_new_ir_storage_swz(PROGRAM_STATE_VAR, -1,
3806                                            totalSize, swizzle);
3807       }
3808       if (dbg) printf("UNIFORM (sz %d) ", totalSize);
3809    }
3810    else if (var->type.qualifier == SLANG_QUAL_VARYING) {
3811       const GLint totalSize = array_size(size, var->array_len);
3812
3813       /* varyings must be float, vec or mat */
3814       if (!_slang_type_is_float_vec_mat(var->type.specifier.type) &&
3815           var->type.specifier.type != SLANG_SPEC_ARRAY) {
3816          slang_info_log_error(A->log,
3817                               "varying '%s' must be float/vector/matrix",
3818                               varName);
3819          return GL_FALSE;
3820       }
3821
3822       if (var->initializer) {
3823          slang_info_log_error(A->log, "illegal initializer for varying '%s'",
3824                               varName);
3825          return GL_FALSE;
3826       }
3827
3828       if (prog) {
3829          /* user-defined varying */
3830          GLbitfield flags;
3831          GLint varyingLoc;
3832          GLuint swizzle;
3833
3834          flags = 0x0;
3835          if (var->type.centroid == SLANG_CENTROID)
3836             flags |= PROG_PARAM_BIT_CENTROID;
3837          if (var->type.variant == SLANG_INVARIANT)
3838             flags |= PROG_PARAM_BIT_INVARIANT;
3839
3840          varyingLoc = _mesa_add_varying(prog->Varying, varName,
3841                                         totalSize, flags);
3842          swizzle = _slang_var_swizzle(size, 0);
3843          store = _slang_new_ir_storage_swz(PROGRAM_VARYING, varyingLoc,
3844                                            totalSize, swizzle);
3845       }
3846       else {
3847          /* pre-defined varying, like gl_Color or gl_TexCoord */
3848          if (type == SLANG_UNIT_FRAGMENT_BUILTIN) {
3849             /* fragment program input */
3850             GLuint swizzle;
3851             GLint index = _slang_input_index(varName, GL_FRAGMENT_PROGRAM_ARB,
3852                                              &swizzle);
3853             assert(index >= 0);
3854             assert(index < FRAG_ATTRIB_MAX);
3855             store = _slang_new_ir_storage_swz(PROGRAM_INPUT, index,
3856                                               size, swizzle);
3857          }
3858          else {
3859             /* vertex program output */
3860             GLint index = _slang_output_index(varName, GL_VERTEX_PROGRAM_ARB);
3861             GLuint swizzle = _slang_var_swizzle(size, 0);
3862             assert(index >= 0);
3863             assert(index < VERT_RESULT_MAX);
3864             assert(type == SLANG_UNIT_VERTEX_BUILTIN);
3865             store = _slang_new_ir_storage_swz(PROGRAM_OUTPUT, index,
3866                                               size, swizzle);
3867          }
3868          if (dbg) printf("V/F ");
3869       }
3870       if (dbg) printf("VARYING ");
3871    }
3872    else if (var->type.qualifier == SLANG_QUAL_ATTRIBUTE) {
3873       GLuint swizzle;
3874       GLint index;
3875       /* attributes must be float, vec or mat */
3876       if (!_slang_type_is_float_vec_mat(var->type.specifier.type)) {
3877          slang_info_log_error(A->log,
3878                               "attribute '%s' must be float/vector/matrix",
3879                               varName);
3880          return GL_FALSE;
3881       }
3882
3883       if (prog) {
3884          /* user-defined vertex attribute */
3885          const GLint attr = -1; /* unknown */
3886          swizzle = _slang_var_swizzle(size, 0);
3887          index = _mesa_add_attribute(prog->Attributes, varName,
3888                                      size, datatype, attr);
3889          assert(index >= 0);
3890          index = VERT_ATTRIB_GENERIC0 + index;
3891       }
3892       else {
3893          /* pre-defined vertex attrib */
3894          index = _slang_input_index(varName, GL_VERTEX_PROGRAM_ARB, &swizzle);
3895          assert(index >= 0);
3896       }
3897       store = _slang_new_ir_storage_swz(PROGRAM_INPUT, index, size, swizzle);
3898       if (dbg) printf("ATTRIB ");
3899    }
3900    else if (var->type.qualifier == SLANG_QUAL_FIXEDINPUT) {
3901       GLuint swizzle = SWIZZLE_XYZW; /* silence compiler warning */
3902       GLint index = _slang_input_index(varName, GL_FRAGMENT_PROGRAM_ARB,
3903                                        &swizzle);
3904       store = _slang_new_ir_storage_swz(PROGRAM_INPUT, index, size, swizzle);
3905       if (dbg) printf("INPUT ");
3906    }
3907    else if (var->type.qualifier == SLANG_QUAL_FIXEDOUTPUT) {
3908       if (type == SLANG_UNIT_VERTEX_BUILTIN) {
3909          GLint index = _slang_output_index(varName, GL_VERTEX_PROGRAM_ARB);
3910          store = _slang_new_ir_storage(PROGRAM_OUTPUT, index, size);
3911       }
3912       else {
3913          GLint index = _slang_output_index(varName, GL_FRAGMENT_PROGRAM_ARB);
3914          GLint specialSize = 4; /* treat all fragment outputs as float[4] */
3915          assert(type == SLANG_UNIT_FRAGMENT_BUILTIN);
3916          store = _slang_new_ir_storage(PROGRAM_OUTPUT, index, specialSize);
3917       }
3918       if (dbg) printf("OUTPUT ");
3919    }
3920    else if (var->type.qualifier == SLANG_QUAL_CONST && !prog) {
3921       /* pre-defined global constant, like gl_MaxLights */
3922       store = _slang_new_ir_storage(PROGRAM_CONSTANT, -1, size);
3923       if (dbg) printf("CONST ");
3924    }
3925    else {
3926       /* ordinary variable (may be const) */
3927       slang_ir_node *n;
3928
3929       /* IR node to declare the variable */
3930       n = _slang_gen_var_decl(A, var);
3931
3932       /* IR code for the var's initializer, if present */
3933       if (var->initializer) {
3934          slang_ir_node *lhs, *rhs, *init;
3935
3936          /* Generate IR_COPY instruction to initialize the variable */
3937          lhs = new_node0(IR_VAR);
3938          lhs->Var = var;
3939          lhs->Store = n->Store;
3940
3941          /* constant folding, etc */
3942          _slang_simplify(var->initializer, &A->space, A->atoms);
3943
3944          rhs = _slang_gen_operation(A, var->initializer);
3945          assert(rhs);
3946          init = new_node2(IR_COPY, lhs, rhs);
3947          n = new_seq(n, init);
3948       }
3949
3950       success = _slang_emit_code(n, A->vartable, A->program, GL_FALSE, A->log);
3951
3952       _slang_free_ir_tree(n);
3953    }
3954
3955    if (dbg) printf("GLOBAL VAR %s  idx %d\n", (char*) var->a_name,
3956                    store ? store->Index : -2);
3957
3958    if (store)
3959       var->store = store;  /* save var's storage info */
3960
3961    var->declared = GL_TRUE;
3962
3963    return success;
3964 }
3965
3966
3967 /**
3968  * Produce an IR tree from a function AST (fun->body).
3969  * Then call the code emitter to convert the IR tree into gl_program
3970  * instructions.
3971  */
3972 GLboolean
3973 _slang_codegen_function(slang_assemble_ctx * A, slang_function * fun)
3974 {
3975    slang_ir_node *n;
3976    GLboolean success = GL_TRUE;
3977
3978    if (_mesa_strcmp((char *) fun->header.a_name, "main") != 0) {
3979       /* we only really generate code for main, all other functions get
3980        * inlined or codegen'd upon an actual call.
3981        */
3982 #if 0
3983       /* do some basic error checking though */
3984       if (fun->header.type.specifier.type != SLANG_SPEC_VOID) {
3985          /* check that non-void functions actually return something */
3986          slang_operation *op
3987             = _slang_find_node_type(fun->body, SLANG_OPER_RETURN);
3988          if (!op) {
3989             slang_info_log_error(A->log,
3990                                  "function \"%s\" has no return statement",
3991                                  (char *) fun->header.a_name);
3992             printf(
3993                    "function \"%s\" has no return statement\n",
3994                    (char *) fun->header.a_name);
3995             return GL_FALSE;
3996          }
3997       }
3998 #endif
3999       return GL_TRUE;  /* not an error */
4000    }
4001
4002 #if 0
4003    printf("\n*********** codegen_function %s\n", (char *) fun->header.a_name);
4004    slang_print_function(fun, 1);
4005 #endif
4006
4007    /* should have been allocated earlier: */
4008    assert(A->program->Parameters );
4009    assert(A->program->Varying);
4010    assert(A->vartable);
4011    A->CurLoop = NULL;
4012    A->CurFunction = fun;
4013
4014    /* fold constant expressions, etc. */
4015    _slang_simplify(fun->body, &A->space, A->atoms);
4016
4017 #if 0
4018    printf("\n*********** simplified %s\n", (char *) fun->header.a_name);
4019    slang_print_function(fun, 1);
4020 #endif
4021
4022    /* Create an end-of-function label */
4023    A->curFuncEndLabel = _slang_label_new("__endOfFunc__main");
4024
4025    /* push new vartable scope */
4026    _slang_push_var_table(A->vartable);
4027
4028    /* Generate IR tree for the function body code */
4029    n = _slang_gen_operation(A, fun->body);
4030    if (n)
4031       n = new_node1(IR_SCOPE, n);
4032
4033    /* pop vartable, restore previous */
4034    _slang_pop_var_table(A->vartable);
4035
4036    if (!n) {
4037       /* XXX record error */
4038       return GL_FALSE;
4039    }
4040
4041    /* append an end-of-function-label to IR tree */
4042    n = new_seq(n, new_label(A->curFuncEndLabel));
4043
4044    /*_slang_label_delete(A->curFuncEndLabel);*/
4045    A->curFuncEndLabel = NULL;
4046
4047 #if 0
4048    printf("************* New AST for %s *****\n", (char*)fun->header.a_name);
4049    slang_print_function(fun, 1);
4050 #endif
4051 #if 0
4052    printf("************* IR for %s *******\n", (char*)fun->header.a_name);
4053    _slang_print_ir_tree(n, 0);
4054 #endif
4055 #if 0
4056    printf("************* End codegen function ************\n\n");
4057 #endif
4058
4059    /* Emit program instructions */
4060    success = _slang_emit_code(n, A->vartable, A->program, GL_TRUE, A->log);
4061    _slang_free_ir_tree(n);
4062
4063    /* free codegen context */
4064    /*
4065    _mesa_free(A->codegen);
4066    */
4067
4068    return success;
4069 }
4070