src/gallium/auxiliary/gallivm/lp_bld_tgsi.h

   1 /**************************************************************************
   2  *
   3  * Copyright 2011-2012 Advanced Micro Devices, Inc.
   4  * Copyright 2009 VMware, Inc.
   5  * 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
   9  * "Software"), to deal in the Software without restriction, including
  10  * without limitation the rights to use, copy, modify, merge, publish,
  11  * distribute, sub license, and/or sell copies of the Software, and to
  12  * permit persons to whom the Software is furnished to do so, subject to
  13  * the following conditions:
  14  *
  15  * The above copyright notice and this permission notice (including the
  16  * next paragraph) shall be included in all copies or substantial portions
  17  * of the Software.
  18  *
  19  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  20  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  21  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  22  * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
  23  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  24  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  25  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  26  *
  27  **************************************************************************/
  28
  29 /**
  30  * @file
  31  * TGSI to LLVM IR translation.
  32  *
  33  * @author Jose Fonseca <jfonseca@vmware.com>
  34  * @author Tom Stellard <thomas.stellard@amd.com>
  35  */
  36
  37 #ifndef LP_BLD_TGSI_H
  38 #define LP_BLD_TGSI_H
  39
  40 #include "gallivm/lp_bld.h"
  41 #include "gallivm/lp_bld_tgsi_action.h"
  42 #include "gallivm/lp_bld_limits.h"
  43 #include "gallivm/lp_bld_sample.h"
  44 #include "gallivm/lp_bld_ir_common.h"
  45 #include "lp_bld_type.h"
  46 #include "pipe/p_compiler.h"
  47 #include "pipe/p_state.h"
  48 #include "tgsi/tgsi_exec.h"
  49 #include "tgsi/tgsi_scan.h"
  50 #include "tgsi/tgsi_info.h"
  51
  52 #ifdef __cplusplus
  53 extern "C" {
  54 #endif
  55
  56 #define LP_CHAN_ALL ~0u
  57
  58 #define LP_MAX_INSTRUCTIONS 256
  59
  60 struct tgsi_full_declaration;
  61 struct tgsi_full_immediate;
  62 struct tgsi_full_instruction;
  63 struct tgsi_full_src_register;
  64 struct tgsi_full_dst_register;
  65 struct tgsi_opcode_info;
  66 struct tgsi_token;
  67 struct tgsi_shader_info;
  68 struct lp_build_mask_context;
  69 struct gallivm_state;
  70 struct lp_derivatives;
  71 struct lp_build_gs_iface;
  72
  73 enum lp_build_tex_modifier {
  74    LP_BLD_TEX_MODIFIER_NONE = 0,
  75    LP_BLD_TEX_MODIFIER_PROJECTED,
  76    LP_BLD_TEX_MODIFIER_LOD_BIAS,
  77    LP_BLD_TEX_MODIFIER_EXPLICIT_LOD,
  78    LP_BLD_TEX_MODIFIER_EXPLICIT_DERIV,
  79    LP_BLD_TEX_MODIFIER_LOD_ZERO
  80 };
  81
  82
  83 /**
  84  * Describe a channel of a register.
  85  *
  86  * The value can be a:
  87  * - immediate value (i.e. derived from a IMM register)
  88  * - CONST[n].x/y/z/w
  89  * - IN[n].x/y/z/w
  90  * - undetermined (when .file == TGSI_FILE_NULL)
  91  *
  92  * This is one of the analysis results, and is used to described
  93  * the output color in terms of inputs.
  94  */
  95 struct lp_tgsi_channel_info
  96 {
  97    unsigned file:4; /* TGSI_FILE_* */
  98    unsigned swizzle:3; /* PIPE_SWIZZLE_x */
  99    union {
 100       uint32_t index;
 101       float value; /* for TGSI_FILE_IMMEDIATE */
 102    } u;
 103 };
 104
 105
 106 /**
 107  * Describe a texture sampler interpolator.
 108  *
 109  * The interpolation is described in terms of regular inputs.
 110  */
 111 struct lp_tgsi_texture_info
 112 {
 113    struct lp_tgsi_channel_info coord[4];
 114    unsigned target:8; /* TGSI_TEXTURE_* */
 115    unsigned sampler_unit:8;  /* Sampler unit */
 116    unsigned texture_unit:8;  /* Texture unit */
 117    unsigned modifier:8; /* LP_BLD_TEX_MODIFIER_* */
 118 };
 119
 120
 121 struct lp_tgsi_info
 122 {
 123    struct tgsi_shader_info base;
 124
 125    /*
 126     * Whether any of the texture opcodes access a register file other than
 127     * TGSI_FILE_INPUT.
 128     *
 129     * We could also handle TGSI_FILE_CONST/IMMEDIATE here, but there is little
 130     * benefit.
 131     */
 132    unsigned indirect_textures:1;
 133
 134    /*
 135     * Whether any of the texture (sample) ocpodes use different sampler
 136     * and sampler view unit.
 137     */
 138    unsigned sampler_texture_units_different:1;
 139
 140    /*
 141     * Whether any immediate values are outside the range of 0 and 1
 142     */
 143    unsigned unclamped_immediates:1;
 144
 145    /*
 146     * Texture opcode description. Aimed at detecting and described direct
 147     * texture opcodes.
 148     */
 149    unsigned num_texs;
 150    struct lp_tgsi_texture_info tex[PIPE_MAX_SAMPLERS];
 151
 152    /*
 153     * Output description. Aimed at detecting and describing simple blit
 154     * shaders.
 155     */
 156    struct lp_tgsi_channel_info output[PIPE_MAX_SHADER_OUTPUTS][4];
 157
 158    /*
 159     * Shortcut pointers into the above (for fragment shaders).
 160     */
 161    const struct lp_tgsi_channel_info *cbuf[PIPE_MAX_COLOR_BUFS];
 162 };
 163
 164 /**
 165  * Reference to system values.
 166  */
 167 struct lp_bld_tgsi_system_values {
 168    LLVMValueRef instance_id;
 169    LLVMValueRef base_instance;
 170    LLVMValueRef vertex_id;
 171    LLVMValueRef vertex_id_nobase;
 172    LLVMValueRef prim_id;
 173    LLVMValueRef basevertex;
 174    LLVMValueRef invocation_id;
 175    LLVMValueRef draw_id;
 176    LLVMValueRef thread_id;
 177    LLVMValueRef block_id;
 178    LLVMValueRef grid_size;
 179    LLVMValueRef front_facing;
 180    LLVMValueRef work_dim;
 181    LLVMValueRef block_size;
 182    LLVMValueRef tess_coord;
 183    LLVMValueRef tess_outer;
 184    LLVMValueRef tess_inner;
 185    LLVMValueRef vertices_in;
 186    LLVMValueRef sample_id;
 187    LLVMValueRef sample_pos;
 188    LLVMValueRef sample_mask_in;
 189 };
 190
 191
 192 /**
 193  * Sampler code generation interface.
 194  *
 195  * Although texture sampling is a requirement for TGSI translation, it is
 196  * a very different problem with several different approaches to it. This
 197  * structure establishes an interface for texture sampling code generation, so
 198  * that we can easily use different texture sampling strategies.
 199  */
 200 struct lp_build_sampler_soa
 201 {
 202    void
 203    (*destroy)( struct lp_build_sampler_soa *sampler );
 204
 205    void
 206    (*emit_tex_sample)(const struct lp_build_sampler_soa *sampler,
 207                       struct gallivm_state *gallivm,
 208                       const struct lp_sampler_params *params);
 209
 210    void
 211    (*emit_size_query)( const struct lp_build_sampler_soa *sampler,
 212                        struct gallivm_state *gallivm,
 213                        const struct lp_sampler_size_query_params *params);
 214 };
 215
 216
 217 struct lp_build_sampler_aos
 218 {
 219    LLVMValueRef
 220    (*emit_fetch_texel)( const struct lp_build_sampler_aos *sampler,
 221                         struct lp_build_context *bld,
 222                         unsigned target, /* TGSI_TEXTURE_* */
 223                         unsigned unit,
 224                         LLVMValueRef coords,
 225                         const struct lp_derivatives derivs,
 226                         enum lp_build_tex_modifier modifier);
 227 };
 228
 229 struct lp_img_params;
 230
 231 struct lp_build_image_soa
 232 {
 233    void
 234    (*destroy)( struct lp_build_image_soa *image );
 235
 236    void
 237    (*emit_op)(const struct lp_build_image_soa *image,
 238               struct gallivm_state *gallivm,
 239               const struct lp_img_params *params);
 240
 241    void
 242    (*emit_size_query)( const struct lp_build_image_soa *sampler,
 243                        struct gallivm_state *gallivm,
 244                        const struct lp_sampler_size_query_params *params);
 245 };
 246
 247 struct lp_build_fs_iface;
 248 struct lp_build_fs_iface {
 249    LLVMValueRef (*interp_fn)(const struct lp_build_fs_iface *iface,
 250                              struct lp_build_context *bld,
 251                              unsigned attrib, unsigned chan,
 252                              bool centroid, bool sample,
 253                              LLVMValueRef indir_index, LLVMValueRef offsets[2]);
 254 };
 255
 256 void
 257 lp_build_tgsi_info(const struct tgsi_token *tokens,
 258                    struct lp_tgsi_info *info);
 259
 260
 261 struct lp_build_tgsi_params {
 262    struct lp_type type;
 263    struct lp_build_mask_context *mask;
 264    LLVMValueRef consts_ptr;
 265    LLVMValueRef const_sizes_ptr;
 266    const struct lp_bld_tgsi_system_values *system_values;
 267    const LLVMValueRef (*inputs)[4];
 268    LLVMValueRef context_ptr;
 269    LLVMValueRef thread_data_ptr;
 270    const struct lp_build_sampler_soa *sampler;
 271    const struct tgsi_shader_info *info;
 272    const struct lp_build_gs_iface *gs_iface;
 273    const struct lp_build_tcs_iface *tcs_iface;
 274    const struct lp_build_tes_iface *tes_iface;
 275    LLVMValueRef ssbo_ptr;
 276    LLVMValueRef ssbo_sizes_ptr;
 277    const struct lp_build_image_soa *image;
 278    LLVMValueRef shared_ptr;
 279    const struct lp_build_coro_suspend_info *coro;
 280    LLVMValueRef kernel_args;
 281    const struct lp_build_fs_iface *fs_iface;
 282 };
 283
 284 void
 285 lp_build_tgsi_soa(struct gallivm_state *gallivm,
 286                   const struct tgsi_token *tokens,
 287                   const struct lp_build_tgsi_params *params,
 288                   LLVMValueRef (*outputs)[4]);
 289
 290 void
 291 lp_build_tgsi_aos(struct gallivm_state *gallivm,
 292                   const struct tgsi_token *tokens,
 293                   struct lp_type type,
 294                   const unsigned char swizzles[4],
 295                   LLVMValueRef consts_ptr,
 296                   const LLVMValueRef *inputs,
 297                   LLVMValueRef *outputs,
 298                   const struct lp_build_sampler_aos *sampler,
 299                   const struct tgsi_shader_info *info);
 300
 301
 302 struct lp_build_tgsi_inst_list
 303 {
 304    struct tgsi_full_instruction *instructions;
 305    uint max_instructions;
 306    uint num_instructions;
 307 };
 308
 309 unsigned lp_bld_tgsi_list_init(struct lp_build_tgsi_context * bld_base);
 310
 311
 312 unsigned lp_bld_tgsi_add_instruction(
 313    struct lp_build_tgsi_context * bld_base,
 314    const struct tgsi_full_instruction *inst_to_add);
 315
 316
 317 struct lp_build_tgsi_context;
 318
 319
 320 typedef LLVMValueRef (*lp_build_emit_fetch_fn)(struct lp_build_tgsi_context *,
 321                                         const struct tgsi_full_src_register *,
 322                                         enum tgsi_opcode_type,
 323                                         unsigned);
 324
 325 typedef void (*lp_build_emit_store_reg_fn)(struct lp_build_tgsi_context *,
 326                               enum tgsi_opcode_type,
 327                               const struct tgsi_full_dst_register *,
 328                               unsigned,
 329                               unsigned,
 330                               LLVMValueRef,
 331                               LLVMValueRef);
 332
 333 struct lp_build_tgsi_context
 334 {
 335    struct lp_build_context base;
 336
 337    struct lp_build_context uint_bld;
 338    struct lp_build_context int_bld;
 339
 340    struct lp_build_context dbl_bld;
 341
 342    struct lp_build_context uint64_bld;
 343    struct lp_build_context int64_bld;
 344
 345    /** This array stores functions that are used to transform TGSI opcodes to
 346      * LLVM instructions.
 347      */
 348    struct lp_build_tgsi_action op_actions[TGSI_OPCODE_LAST];
 349
 350    /* TGSI_OPCODE_RSQ is defined as 1 / sqrt( abs(src0.x) ), rsq_action
 351     * should compute 1 / sqrt (src0.x) */
 352    struct lp_build_tgsi_action rsq_action;
 353
 354    struct lp_build_tgsi_action sqrt_action;
 355
 356    struct lp_build_tgsi_action drsq_action;
 357
 358    struct lp_build_tgsi_action dsqrt_action;
 359    const struct tgsi_shader_info *info;
 360
 361    lp_build_emit_fetch_fn emit_fetch_funcs[TGSI_FILE_COUNT];
 362    lp_build_emit_store_reg_fn emit_store_reg_funcs[TGSI_FILE_COUNT];
 363
 364    LLVMValueRef (*emit_swizzle)(struct lp_build_tgsi_context *,
 365                          LLVMValueRef, unsigned, unsigned, unsigned, unsigned);
 366
 367
 368    void (*emit_debug)(struct lp_build_tgsi_context *,
 369                       const struct tgsi_full_instruction *,
 370                       const struct tgsi_opcode_info *);
 371
 372    void (*emit_store)(struct lp_build_tgsi_context *,
 373                       const struct tgsi_full_instruction *,
 374                       const struct tgsi_opcode_info *,
 375                       unsigned index,
 376                       LLVMValueRef dst[4]);
 377
 378    void (*emit_declaration)(struct lp_build_tgsi_context *,
 379                              const struct tgsi_full_declaration *decl);
 380
 381    void (*emit_immediate)(struct lp_build_tgsi_context *,
 382                           const struct tgsi_full_immediate *imm);
 383
 384
 385    /* Allow the user to store data in this structure rather than passing it
 386     * to every function. */
 387    void * userdata;
 388
 389    boolean soa;
 390
 391    int pc;
 392
 393    struct tgsi_full_instruction *instructions;
 394    uint max_instructions;
 395    uint num_instructions;
 396
 397    /** This function allows the user to insert some instructions at the
 398      * beginning of the program.  It is optional and does not need to be
 399      * implemented.
 400      */
 401    void (*emit_prologue)(struct lp_build_tgsi_context*);
 402
 403    /** This function allows the user to insert some instructions after
 404      * declarations section, but before any other code.
 405      * It is optional and does not need to be implemented.
 406      */
 407    void (*emit_prologue_post_decl)(struct lp_build_tgsi_context*);
 408
 409    /** This function allows the user to insert some instructions at the end of
 410      * the program.  This callback is intended to be used for emitting
 411      * instructions to handle the export for the output registers, but it can
 412      * be used for any purpose.  Implementing this function is optiona, but
 413      * recommended.
 414      */
 415    void (*emit_epilogue)(struct lp_build_tgsi_context*);
 416 };
 417
 418 struct lp_build_gs_iface
 419 {
 420    LLVMValueRef (*fetch_input)(const struct lp_build_gs_iface *gs_iface,
 421                                struct lp_build_context * bld,
 422                                boolean is_vindex_indirect,
 423                                LLVMValueRef vertex_index,
 424                                boolean is_aindex_indirect,
 425                                LLVMValueRef attrib_index,
 426                                LLVMValueRef swizzle_index);
 427    void (*emit_vertex)(const struct lp_build_gs_iface *gs_iface,
 428                        struct lp_build_context * bld,
 429                        LLVMValueRef (*outputs)[4],
 430                        LLVMValueRef emitted_vertices_vec,
 431                        LLVMValueRef stream_id);
 432    void (*end_primitive)(const struct lp_build_gs_iface *gs_iface,
 433                          struct lp_build_context * bld,
 434                          LLVMValueRef total_emitted_vertices_vec,
 435                          LLVMValueRef verts_per_prim_vec,
 436                          LLVMValueRef emitted_prims_vec,
 437                          LLVMValueRef mask_vec);
 438    void (*gs_epilogue)(const struct lp_build_gs_iface *gs_iface,
 439                        LLVMValueRef total_emitted_vertices_vec,
 440                        LLVMValueRef emitted_prims_vec, unsigned stream);
 441 };
 442
 443 struct lp_build_tcs_iface
 444 {
 445    void (*emit_prologue)(struct lp_build_context * bld);
 446    void (*emit_epilogue)(struct lp_build_context * bld);
 447    void (*emit_barrier)(struct lp_build_context *bld_base);
 448
 449    void (*emit_store_output)(const struct lp_build_tcs_iface *tcs_iface,
 450                              struct lp_build_context * bld,
 451                              unsigned name,
 452                              boolean is_vindex_indirect,
 453                              LLVMValueRef vertex_index,
 454                              boolean is_aindex_indirect,
 455                              LLVMValueRef attrib_index,
 456                              LLVMValueRef swizzle_index,
 457                              LLVMValueRef value,
 458                              LLVMValueRef mask_vec);
 459
 460    LLVMValueRef (*emit_fetch_input)(const struct lp_build_tcs_iface *tcs_iface,
 461                                     struct lp_build_context * bld,
 462                                     boolean is_vindex_indirect,
 463                                     LLVMValueRef vertex_index,
 464                                     boolean is_aindex_indirect,
 465                                     LLVMValueRef attrib_index,
 466                                     LLVMValueRef swizzle_index);
 467
 468    LLVMValueRef (*emit_fetch_output)(const struct lp_build_tcs_iface *tcs_iface,
 469                                     struct lp_build_context * bld,
 470                                     boolean is_vindex_indirect,
 471                                     LLVMValueRef vertex_index,
 472                                     boolean is_aindex_indirect,
 473                                     LLVMValueRef attrib_index,
 474                                     LLVMValueRef swizzle_index,
 475                                     uint32_t name);
 476 };
 477
 478 struct lp_build_tes_iface
 479 {
 480    LLVMValueRef (*fetch_vertex_input)(const struct lp_build_tes_iface *tes_iface,
 481                                       struct lp_build_context * bld,
 482                                       boolean is_vindex_indirect,
 483                                       LLVMValueRef vertex_index,
 484                                       boolean is_aindex_indirect,
 485                                       LLVMValueRef attrib_index,
 486                                       LLVMValueRef swizzle_index);
 487
 488    LLVMValueRef (*fetch_patch_input)(const struct lp_build_tes_iface *tes_iface,
 489                                      struct lp_build_context * bld,
 490                                      boolean is_aindex_indirect,
 491                                      LLVMValueRef attrib_index,
 492                                      LLVMValueRef swizzle_index);
 493 };
 494
 495 struct lp_build_tgsi_soa_context
 496 {
 497    struct lp_build_tgsi_context bld_base;
 498
 499    /* Builder for scalar elements of shader's data type (float) */
 500    struct lp_build_context elem_bld;
 501
 502    const struct lp_build_gs_iface *gs_iface;
 503    const struct lp_build_tcs_iface *tcs_iface;
 504    const struct lp_build_tes_iface *tes_iface;
 505
 506    LLVMValueRef emitted_prims_vec_ptr;
 507    LLVMValueRef total_emitted_vertices_vec_ptr;
 508    LLVMValueRef emitted_vertices_vec_ptr;
 509    LLVMValueRef max_output_vertices_vec;
 510
 511    LLVMValueRef consts_ptr;
 512    LLVMValueRef const_sizes_ptr;
 513    LLVMValueRef consts[LP_MAX_TGSI_CONST_BUFFERS];
 514    LLVMValueRef consts_sizes[LP_MAX_TGSI_CONST_BUFFERS];
 515    const LLVMValueRef (*inputs)[TGSI_NUM_CHANNELS];
 516    LLVMValueRef (*outputs)[TGSI_NUM_CHANNELS];
 517    LLVMValueRef context_ptr;
 518    LLVMValueRef thread_data_ptr;
 519
 520    LLVMValueRef ssbo_ptr;
 521    LLVMValueRef ssbo_sizes_ptr;
 522    LLVMValueRef ssbos[LP_MAX_TGSI_SHADER_BUFFERS];
 523    LLVMValueRef ssbo_sizes[LP_MAX_TGSI_SHADER_BUFFERS];
 524
 525    LLVMValueRef shared_ptr;
 526
 527    const struct lp_build_coro_suspend_info *coro;
 528
 529    const struct lp_build_sampler_soa *sampler;
 530    const struct lp_build_image_soa *image;
 531
 532    struct tgsi_declaration_sampler_view sv[PIPE_MAX_SHADER_SAMPLER_VIEWS];
 533
 534    LLVMValueRef immediates[LP_MAX_INLINED_IMMEDIATES][TGSI_NUM_CHANNELS];
 535    LLVMValueRef temps[LP_MAX_INLINED_TEMPS][TGSI_NUM_CHANNELS];
 536    LLVMValueRef addr[LP_MAX_TGSI_ADDRS][TGSI_NUM_CHANNELS];
 537
 538    /* We allocate/use this array of temps if (1 << TGSI_FILE_TEMPORARY) is
 539     * set in the indirect_files field.
 540     * The temps[] array above is unused then.
 541     */
 542    LLVMValueRef temps_array;
 543
 544    /* We allocate/use this array of output if (1 << TGSI_FILE_OUTPUT) is
 545     * set in the indirect_files field.
 546     * The outputs[] array above is unused then.
 547     */
 548    LLVMValueRef outputs_array;
 549
 550    /* We allocate/use this array of inputs if (1 << TGSI_FILE_INPUT) is
 551     * set in the indirect_files field.
 552     * The inputs[] array above is unused then.
 553     */
 554    LLVMValueRef inputs_array;
 555
 556    /* We allocate/use this array of temps if (1 << TGSI_FILE_IMMEDIATE) is
 557     * set in the indirect_files field.
 558     */
 559    LLVMValueRef imms_array;
 560
 561
 562    struct lp_bld_tgsi_system_values system_values;
 563
 564    /** bitmask indicating which register files are accessed indirectly */
 565    unsigned indirect_files;
 566
 567    struct lp_build_mask_context *mask;
 568    struct lp_exec_mask exec_mask;
 569
 570    uint num_immediates;
 571    boolean use_immediates_array;
 572 };
 573
 574 void
 575 lp_emit_declaration_soa(
 576    struct lp_build_tgsi_context *bld,
 577    const struct tgsi_full_declaration *decl);
 578
 579 void lp_emit_immediate_soa(
 580    struct lp_build_tgsi_context *bld_base,
 581    const struct tgsi_full_immediate *imm);
 582
 583 boolean
 584 lp_emit_instruction_soa(
 585    struct lp_build_tgsi_soa_context *bld,
 586    const struct tgsi_full_instruction *inst,
 587    const struct tgsi_opcode_info *info);
 588
 589
 590 LLVMValueRef
 591 lp_get_temp_ptr_soa(
 592    struct lp_build_tgsi_soa_context *bld,
 593    unsigned index,
 594    unsigned chan);
 595
 596 LLVMValueRef
 597 lp_get_output_ptr(
 598    struct lp_build_tgsi_soa_context *bld,
 599    unsigned index,
 600    unsigned chan);
 601
 602 struct lp_build_tgsi_aos_context
 603 {
 604    struct lp_build_tgsi_context bld_base;
 605
 606    /* Builder for integer masks and indices */
 607    struct lp_build_context int_bld;
 608
 609    /*
 610     * AoS swizzle used:
 611     * - swizzles[0] = red index
 612     * - swizzles[1] = green index
 613     * - swizzles[2] = blue index
 614     * - swizzles[3] = alpha index
 615     */
 616    unsigned char swizzles[4];
 617    unsigned char inv_swizzles[4];
 618
 619    LLVMValueRef consts_ptr;
 620    const LLVMValueRef *inputs;
 621    LLVMValueRef *outputs;
 622
 623    const struct lp_build_sampler_aos *sampler;
 624
 625    struct tgsi_declaration_sampler_view sv[PIPE_MAX_SHADER_SAMPLER_VIEWS];
 626
 627    LLVMValueRef immediates[LP_MAX_INLINED_IMMEDIATES];
 628    LLVMValueRef temps[LP_MAX_INLINED_TEMPS];
 629    LLVMValueRef addr[LP_MAX_TGSI_ADDRS];
 630
 631    /* We allocate/use this array of temps if (1 << TGSI_FILE_TEMPORARY) is
 632     * set in the indirect_files field.
 633     * The temps[] array above is unused then.
 634     */
 635    LLVMValueRef temps_array;
 636
 637    /** bitmask indicating which register files are accessed indirectly */
 638    unsigned indirect_files;
 639
 640 };
 641
 642 static inline struct lp_build_tgsi_soa_context *
 643 lp_soa_context(struct lp_build_tgsi_context *bld_base)
 644 {
 645    return (struct lp_build_tgsi_soa_context *)bld_base;
 646 }
 647
 648 static inline struct lp_build_tgsi_aos_context *
 649 lp_aos_context(struct lp_build_tgsi_context *bld_base)
 650 {
 651    return (struct lp_build_tgsi_aos_context *)bld_base;
 652 }
 653
 654 void
 655 lp_emit_declaration_aos(
 656    struct lp_build_tgsi_aos_context *bld,
 657    const struct tgsi_full_declaration *decl);
 658
 659
 660 boolean
 661 lp_emit_instruction_aos(
 662    struct lp_build_tgsi_aos_context *bld,
 663    const struct tgsi_full_instruction *inst,
 664    const struct tgsi_opcode_info *info,
 665    int *pc);
 666
 667 void
 668 lp_emit_store_aos(
 669    struct lp_build_tgsi_aos_context *bld,
 670    const struct tgsi_full_instruction *inst,
 671    unsigned index,
 672    LLVMValueRef value);
 673
 674 void lp_build_fetch_args(
 675    struct lp_build_tgsi_context * bld_base,
 676    struct lp_build_emit_data * emit_data);
 677
 678 LLVMValueRef
 679 lp_build_tgsi_inst_llvm_aos(
 680    struct lp_build_tgsi_context * bld_base,
 681    const struct tgsi_full_instruction *inst);
 682
 683 void
 684 lp_build_tgsi_intrinsic(
 685  const struct lp_build_tgsi_action * action,
 686  struct lp_build_tgsi_context * bld_base,
 687  struct lp_build_emit_data * emit_data);
 688
 689 LLVMValueRef
 690 lp_build_emit_llvm(
 691    struct lp_build_tgsi_context *bld_base,
 692    unsigned tgsi_opcode,
 693    struct lp_build_emit_data * emit_data);
 694
 695 LLVMValueRef
 696 lp_build_emit_llvm_unary(
 697    struct lp_build_tgsi_context *bld_base,
 698    unsigned tgsi_opcode,
 699    LLVMValueRef arg0);
 700
 701 LLVMValueRef
 702 lp_build_emit_llvm_binary(
 703    struct lp_build_tgsi_context *bld_base,
 704    unsigned tgsi_opcode,
 705    LLVMValueRef arg0,
 706    LLVMValueRef arg1);
 707
 708 LLVMValueRef
 709 lp_build_emit_llvm_ternary(
 710    struct lp_build_tgsi_context *bld_base,
 711    unsigned tgsi_opcode,
 712    LLVMValueRef arg0,
 713    LLVMValueRef arg1,
 714    LLVMValueRef arg2);
 715
 716 boolean
 717 lp_build_tgsi_inst_llvm(
 718    struct lp_build_tgsi_context * bld_base,
 719    const struct tgsi_full_instruction *inst);
 720
 721 LLVMValueRef
 722 lp_build_emit_fetch_src(
 723    struct lp_build_tgsi_context *bld_base,
 724    const struct tgsi_full_src_register *reg,
 725    enum tgsi_opcode_type stype,
 726    const unsigned chan_index);
 727
 728 LLVMValueRef
 729 lp_build_emit_fetch(
 730    struct lp_build_tgsi_context *bld_base,
 731    const struct tgsi_full_instruction *inst,
 732    unsigned src_op,
 733    const unsigned chan_index);
 734
 735
 736 LLVMValueRef
 737 lp_build_emit_fetch_texoffset(
 738    struct lp_build_tgsi_context *bld_base,
 739    const struct tgsi_full_instruction *inst,
 740    unsigned tex_off_op,
 741    const unsigned chan_index);
 742
 743 boolean
 744 lp_build_tgsi_llvm(
 745    struct lp_build_tgsi_context * bld_base,
 746    const struct tgsi_token *tokens);
 747
 748 #ifdef __cplusplus
 749 }
 750 #endif
 751
 752 #endif /* LP_BLD_TGSI_H */