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 "lp_bld_type.h"
  44 #include "pipe/p_compiler.h"
  45 #include "pipe/p_state.h"
  46 #include "tgsi/tgsi_exec.h"
  47 #include "tgsi/tgsi_scan.h"
  48 #include "tgsi/tgsi_info.h"
  49
  50 #define LP_CHAN_ALL ~0
  51
  52 #define LP_MAX_INSTRUCTIONS 256
  53
  54 struct tgsi_full_declaration;
  55 struct tgsi_full_immediate;
  56 struct tgsi_full_instruction;
  57 struct tgsi_full_src_register;
  58 struct tgsi_opcode_info;
  59 struct tgsi_token;
  60 struct tgsi_shader_info;
  61 struct lp_build_mask_context;
  62 struct gallivm_state;
  63
  64
  65 enum lp_build_tex_modifier {
  66    LP_BLD_TEX_MODIFIER_NONE = 0,
  67    LP_BLD_TEX_MODIFIER_PROJECTED,
  68    LP_BLD_TEX_MODIFIER_LOD_BIAS,
  69    LP_BLD_TEX_MODIFIER_EXPLICIT_LOD,
  70    LP_BLD_TEX_MODIFIER_EXPLICIT_DERIV
  71 };
  72
  73
  74 /**
  75  * Describe a channel of a register.
  76  *
  77  * The value can be a:
  78  * - immediate value (i.e. derived from a IMM register)
  79  * - CONST[n].x/y/z/w
  80  * - IN[n].x/y/z/w
  81  * - undetermined (when .file == TGSI_FILE_NULL)
  82  *
  83  * This is one of the analysis results, and is used to described
  84  * the output color in terms of inputs.
  85  */
  86 struct lp_tgsi_channel_info
  87 {
  88    unsigned file:4; /* TGSI_FILE_* */
  89    unsigned swizzle:3; /* PIPE_SWIZZLE_x */
  90    union {
  91       uint32_t index;
  92       float value; /* for TGSI_FILE_IMMEDIATE */
  93    } u;
  94 };
  95
  96
  97 /**
  98  * Describe a texture sampler interpolator.
  99  *
 100  * The interpolation is described in terms of regular inputs.
 101  */
 102 struct lp_tgsi_texture_info
 103 {
 104    struct lp_tgsi_channel_info coord[4];
 105    unsigned target:8; /* TGSI_TEXTURE_* */
 106    unsigned unit:8;  /* Sampler unit */
 107    unsigned modifier:8; /* LP_BLD_TEX_MODIFIER_* */
 108 };
 109
 110
 111 struct lp_tgsi_info
 112 {
 113    struct tgsi_shader_info base;
 114
 115    /*
 116     * Whether any of the texture opcodes access a register file other than
 117     * TGSI_FILE_INPUT.
 118     *
 119     * We could also handle TGSI_FILE_CONST/IMMEDIATE here, but there is little
 120     * benefit.
 121     */
 122    unsigned indirect_textures:1;
 123
 124    /*
 125     * Texture opcode description. Aimed at detecting and described direct
 126     * texture opcodes.
 127     */
 128    unsigned num_texs;
 129    struct lp_tgsi_texture_info tex[PIPE_MAX_SAMPLERS];
 130
 131    /*
 132     * Output description. Aimed at detecting and describing simple blit
 133     * shaders.
 134     */
 135    struct lp_tgsi_channel_info output[PIPE_MAX_SHADER_OUTPUTS][4];
 136
 137    /*
 138     * Shortcut pointers into the above (for fragment shaders).
 139     */
 140    const struct lp_tgsi_channel_info *cbuf[PIPE_MAX_COLOR_BUFS];
 141 };
 142
 143 /**
 144  * Sampler code generation interface.
 145  *
 146  * Although texture sampling is a requirement for TGSI translation, it is
 147  * a very different problem with several different approaches to it. This
 148  * structure establishes an interface for texture sampling code generation, so
 149  * that we can easily use different texture sampling strategies.
 150  */
 151 struct lp_build_sampler_soa
 152 {
 153    void
 154    (*destroy)( struct lp_build_sampler_soa *sampler );
 155
 156    void
 157    (*emit_fetch_texel)( const struct lp_build_sampler_soa *sampler,
 158                         struct gallivm_state *gallivm,
 159                         struct lp_type type,
 160                         unsigned unit,
 161                         unsigned num_coords,
 162                         const LLVMValueRef *coords,
 163                         const LLVMValueRef *ddx,
 164                         const LLVMValueRef *ddy,
 165                         LLVMValueRef lod_bias, /* optional */
 166                         LLVMValueRef explicit_lod, /* optional */
 167                         LLVMValueRef *texel);
 168 };
 169
 170
 171 struct lp_build_sampler_aos
 172 {
 173    LLVMValueRef
 174    (*emit_fetch_texel)( struct lp_build_sampler_aos *sampler,
 175                         struct lp_build_context *bld,
 176                         unsigned target, /* TGSI_TEXTURE_* */
 177                         unsigned unit,
 178                         LLVMValueRef coords,
 179                         LLVMValueRef ddx,
 180                         LLVMValueRef ddy,
 181                         enum lp_build_tex_modifier modifier);
 182 };
 183
 184
 185 void
 186 lp_build_tgsi_info(const struct tgsi_token *tokens,
 187                    struct lp_tgsi_info *info);
 188
 189
 190 void
 191 lp_build_tgsi_soa(struct gallivm_state *gallivm,
 192                   const struct tgsi_token *tokens,
 193                   struct lp_type type,
 194                   struct lp_build_mask_context *mask,
 195                   LLVMValueRef consts_ptr,
 196                   LLVMValueRef system_values_array,
 197                   const LLVMValueRef *pos,
 198                   const LLVMValueRef (*inputs)[4],
 199                   LLVMValueRef (*outputs)[4],
 200                   struct lp_build_sampler_soa *sampler,
 201                   const struct tgsi_shader_info *info);
 202
 203
 204 void
 205 lp_build_tgsi_aos(struct gallivm_state *gallivm,
 206                   const struct tgsi_token *tokens,
 207                   struct lp_type type,
 208                   const unsigned char swizzles[4],
 209                   LLVMValueRef consts_ptr,
 210                   const LLVMValueRef *inputs,
 211                   LLVMValueRef *outputs,
 212                   struct lp_build_sampler_aos *sampler,
 213                   const struct tgsi_shader_info *info);
 214
 215
 216 LLVMValueRef
 217 lp_build_system_values_array(struct gallivm_state *gallivm,
 218                              const struct tgsi_shader_info *info,
 219                              LLVMValueRef instance_id,
 220                              LLVMValueRef facing);
 221
 222
 223 struct lp_exec_mask {
 224    struct lp_build_context *bld;
 225
 226    boolean has_mask;
 227
 228    LLVMTypeRef int_vec_type;
 229
 230    LLVMValueRef cond_stack[LP_MAX_TGSI_NESTING];
 231    int cond_stack_size;
 232    LLVMValueRef cond_mask;
 233
 234    LLVMBasicBlockRef loop_block;
 235    LLVMValueRef cont_mask;
 236    LLVMValueRef break_mask;
 237    LLVMValueRef break_var;
 238    struct {
 239       LLVMBasicBlockRef loop_block;
 240       LLVMValueRef cont_mask;
 241       LLVMValueRef break_mask;
 242       LLVMValueRef break_var;
 243    } loop_stack[LP_MAX_TGSI_NESTING];
 244    int loop_stack_size;
 245
 246    LLVMValueRef ret_mask;
 247    struct {
 248       int pc;
 249       LLVMValueRef ret_mask;
 250    } call_stack[LP_MAX_TGSI_NESTING];
 251    int call_stack_size;
 252
 253    LLVMValueRef exec_mask;
 254 };
 255
 256 struct lp_build_tgsi_inst_list
 257 {
 258    struct tgsi_full_instruction *instructions;
 259    uint max_instructions;
 260    uint num_instructions;
 261 };
 262
 263 unsigned lp_bld_tgsi_list_init(struct lp_build_tgsi_context * bld_base);
 264
 265
 266 unsigned lp_bld_tgsi_add_instruction(
 267    struct lp_build_tgsi_context * bld_base,
 268    struct tgsi_full_instruction *inst_to_add);
 269
 270
 271 struct lp_build_tgsi_context;
 272
 273
 274 typedef LLVMValueRef (*lp_build_emit_fetch_fn)(struct lp_build_tgsi_context *,
 275                                         const struct tgsi_full_src_register *,
 276                                         enum tgsi_opcode_type,
 277                                         unsigned);
 278
 279 struct lp_build_tgsi_context
 280 {
 281    struct lp_build_context base;
 282
 283    struct lp_build_context uint_bld;
 284    struct lp_build_context int_bld;
 285
 286    /** This array stores functions that are used to transform TGSI opcodes to
 287      * LLVM instructions.
 288      */
 289    struct lp_build_tgsi_action op_actions[TGSI_OPCODE_LAST];
 290
 291    /* TGSI_OPCODE_RSQ is defined as 1 / sqrt( abs(src0.x) ), rsq_action
 292     * should compute 1 / sqrt (src0.x) */
 293    struct lp_build_tgsi_action rsq_action;
 294
 295    const struct tgsi_shader_info *info;
 296
 297    lp_build_emit_fetch_fn emit_fetch_funcs[TGSI_FILE_COUNT];
 298
 299    LLVMValueRef (*emit_swizzle)(struct lp_build_tgsi_context *,
 300                          LLVMValueRef, unsigned, unsigned, unsigned, unsigned);
 301
 302    void (*emit_store)(struct lp_build_tgsi_context *,
 303                       const struct tgsi_full_instruction *,
 304                       const struct tgsi_opcode_info *,
 305                       LLVMValueRef dst[4]);
 306
 307    void (*emit_declaration)(struct lp_build_tgsi_context *,
 308                              const struct tgsi_full_declaration *decl);
 309
 310    void (*emit_immediate)(struct lp_build_tgsi_context *,
 311                           const struct tgsi_full_immediate *imm);
 312
 313
 314    /* Allow the user to store data in this structure rather than passing it
 315     * to every function. */
 316    void * userdata;
 317
 318    boolean soa;
 319
 320    int pc;
 321
 322    struct tgsi_full_instruction *instructions;
 323    uint max_instructions;
 324    uint num_instructions;
 325
 326    /** This function allows the user to insert some instructions at the
 327      * beginning of the program.  It is optional and does not need to be
 328      * implemented.
 329      */
 330    void (*emit_prologue)(struct lp_build_tgsi_context*);
 331
 332    /** This function allows the user to insert some instructions at the end of
 333      * the program.  This callback is intended to be used for emitting
 334      * instructions to handle the export for the output registers, but it can
 335      * be used for any purpose.  Implementing this function is optiona, but
 336      * recommended.
 337      */
 338    void (*emit_epilogue)(struct lp_build_tgsi_context*);
 339 };
 340
 341 struct lp_build_tgsi_soa_context
 342 {
 343    struct lp_build_tgsi_context bld_base;
 344
 345    /* Builder for scalar elements of shader's data type (float) */
 346    struct lp_build_context elem_bld;
 347
 348    LLVMValueRef consts_ptr;
 349    const LLVMValueRef *pos;
 350    const LLVMValueRef (*inputs)[TGSI_NUM_CHANNELS];
 351    LLVMValueRef (*outputs)[TGSI_NUM_CHANNELS];
 352
 353    const struct lp_build_sampler_soa *sampler;
 354
 355    LLVMValueRef immediates[LP_MAX_TGSI_IMMEDIATES][TGSI_NUM_CHANNELS];
 356    LLVMValueRef temps[LP_MAX_TGSI_TEMPS][TGSI_NUM_CHANNELS];
 357    LLVMValueRef addr[LP_MAX_TGSI_ADDRS][TGSI_NUM_CHANNELS];
 358    LLVMValueRef preds[LP_MAX_TGSI_PREDS][TGSI_NUM_CHANNELS];
 359
 360    /* We allocate/use this array of temps if (1 << TGSI_FILE_TEMPORARY) is
 361     * set in the indirect_files field.
 362     * The temps[] array above is unused then.
 363     */
 364    LLVMValueRef temps_array;
 365
 366    /* We allocate/use this array of output if (1 << TGSI_FILE_OUTPUT) is
 367     * set in the indirect_files field.
 368     * The outputs[] array above is unused then.
 369     */
 370    LLVMValueRef outputs_array;
 371
 372    /* We allocate/use this array of inputs if (1 << TGSI_FILE_INPUT) is
 373     * set in the indirect_files field.
 374     * The inputs[] array above is unused then.
 375     */
 376    LLVMValueRef inputs_array;
 377
 378    LLVMValueRef system_values_array;
 379
 380    /** bitmask indicating which register files are accessed indirectly */
 381    unsigned indirect_files;
 382
 383    struct lp_build_mask_context *mask;
 384    struct lp_exec_mask exec_mask;
 385
 386    uint num_immediates;
 387
 388 };
 389
 390 void
 391 lp_emit_declaration_soa(
 392    struct lp_build_tgsi_context *bld,
 393    const struct tgsi_full_declaration *decl);
 394
 395 void lp_emit_immediate_soa(
 396    struct lp_build_tgsi_context *bld_base,
 397    const struct tgsi_full_immediate *imm);
 398
 399 boolean
 400 lp_emit_instruction_soa(
 401    struct lp_build_tgsi_soa_context *bld,
 402    const struct tgsi_full_instruction *inst,
 403    const struct tgsi_opcode_info *info);
 404
 405
 406 LLVMValueRef
 407 lp_get_temp_ptr_soa(
 408    struct lp_build_tgsi_soa_context *bld,
 409    unsigned index,
 410    unsigned chan);
 411
 412 LLVMValueRef
 413 lp_get_output_ptr(
 414    struct lp_build_tgsi_soa_context *bld,
 415    unsigned index,
 416    unsigned chan);
 417
 418 struct lp_build_tgsi_aos_context
 419 {
 420    struct lp_build_tgsi_context bld_base;
 421
 422    /* Builder for integer masks and indices */
 423    struct lp_build_context int_bld;
 424
 425    /*
 426     * AoS swizzle used:
 427     * - swizzles[0] = red index
 428     * - swizzles[1] = green index
 429     * - swizzles[2] = blue index
 430     * - swizzles[3] = alpha index
 431     */
 432    unsigned char swizzles[4];
 433    unsigned char inv_swizzles[4];
 434
 435    LLVMValueRef consts_ptr;
 436    const LLVMValueRef *inputs;
 437    LLVMValueRef *outputs;
 438
 439    struct lp_build_sampler_aos *sampler;
 440
 441    LLVMValueRef immediates[LP_MAX_TGSI_IMMEDIATES];
 442    LLVMValueRef temps[LP_MAX_TGSI_TEMPS];
 443    LLVMValueRef addr[LP_MAX_TGSI_ADDRS];
 444    LLVMValueRef preds[LP_MAX_TGSI_PREDS];
 445
 446    /* We allocate/use this array of temps if (1 << TGSI_FILE_TEMPORARY) is
 447     * set in the indirect_files field.
 448     * The temps[] array above is unused then.
 449     */
 450    LLVMValueRef temps_array;
 451
 452    /** bitmask indicating which register files are accessed indirectly */
 453    unsigned indirect_files;
 454
 455 };
 456
 457 static INLINE struct lp_build_tgsi_soa_context *
 458 lp_soa_context(struct lp_build_tgsi_context *bld_base)
 459 {
 460    return (struct lp_build_tgsi_soa_context *)bld_base;
 461 }
 462
 463 static INLINE struct lp_build_tgsi_aos_context *
 464 lp_aos_context(struct lp_build_tgsi_context *bld_base)
 465 {
 466    return (struct lp_build_tgsi_aos_context *)bld_base;
 467 }
 468
 469 void
 470 lp_emit_declaration_aos(
 471    struct lp_build_tgsi_aos_context *bld,
 472    const struct tgsi_full_declaration *decl);
 473
 474
 475 boolean
 476 lp_emit_instruction_aos(
 477    struct lp_build_tgsi_aos_context *bld,
 478    const struct tgsi_full_instruction *inst,
 479    const struct tgsi_opcode_info *info,
 480    int *pc);
 481
 482 void
 483 lp_emit_store_aos(
 484    struct lp_build_tgsi_aos_context *bld,
 485    const struct tgsi_full_instruction *inst,
 486    unsigned index,
 487    LLVMValueRef value);
 488
 489 void lp_build_fetch_args(
 490    struct lp_build_tgsi_context * bld_base,
 491    struct lp_build_emit_data * emit_data);
 492
 493 LLVMValueRef
 494 lp_build_tgsi_inst_llvm_aos(
 495    struct lp_build_tgsi_context * bld_base,
 496    const struct tgsi_full_instruction *inst);
 497
 498 void
 499 lp_build_tgsi_intrinsic(
 500  const struct lp_build_tgsi_action * action,
 501  struct lp_build_tgsi_context * bld_base,
 502  struct lp_build_emit_data * emit_data);
 503
 504 LLVMValueRef
 505 lp_build_emit_llvm(
 506    struct lp_build_tgsi_context *bld_base,
 507    unsigned tgsi_opcode,
 508    struct lp_build_emit_data * emit_data);
 509
 510 LLVMValueRef
 511 lp_build_emit_llvm_unary(
 512    struct lp_build_tgsi_context *bld_base,
 513    unsigned tgsi_opcode,
 514    LLVMValueRef arg0);
 515
 516 LLVMValueRef
 517 lp_build_emit_llvm_binary(
 518    struct lp_build_tgsi_context *bld_base,
 519    unsigned tgsi_opcode,
 520    LLVMValueRef arg0,
 521    LLVMValueRef arg1);
 522
 523 LLVMValueRef
 524 lp_build_emit_llvm_ternary(
 525    struct lp_build_tgsi_context *bld_base,
 526    unsigned tgsi_opcode,
 527    LLVMValueRef arg0,
 528    LLVMValueRef arg1,
 529    LLVMValueRef arg2);
 530
 531 boolean
 532 lp_build_tgsi_inst_llvm(
 533    struct lp_build_tgsi_context * bld_base,
 534    const struct tgsi_full_instruction *inst);
 535
 536 LLVMValueRef
 537 lp_build_emit_fetch(
 538    struct lp_build_tgsi_context *bld_base,
 539    const struct tgsi_full_instruction *inst,
 540    unsigned src_op,
 541    const unsigned chan_index);
 542
 543 boolean
 544 lp_build_tgsi_llvm(
 545    struct lp_build_tgsi_context * bld_base,
 546    const struct tgsi_token *tokens);
 547
 548 #endif /* LP_BLD_TGSI_H */