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    LLVMValueRef loop_limiter;
 255 };
 256
 257 struct lp_build_tgsi_inst_list
 258 {
 259    struct tgsi_full_instruction *instructions;
 260    uint max_instructions;
 261    uint num_instructions;
 262 };
 263
 264 unsigned lp_bld_tgsi_list_init(struct lp_build_tgsi_context * bld_base);
 265
 266
 267 unsigned lp_bld_tgsi_add_instruction(
 268    struct lp_build_tgsi_context * bld_base,
 269    struct tgsi_full_instruction *inst_to_add);
 270
 271
 272 struct lp_build_tgsi_context;
 273
 274
 275 typedef LLVMValueRef (*lp_build_emit_fetch_fn)(struct lp_build_tgsi_context *,
 276                                         const struct tgsi_full_src_register *,
 277                                         enum tgsi_opcode_type,
 278                                         unsigned);
 279
 280 struct lp_build_tgsi_context
 281 {
 282    struct lp_build_context base;
 283
 284    struct lp_build_context uint_bld;
 285    struct lp_build_context int_bld;
 286
 287    /** This array stores functions that are used to transform TGSI opcodes to
 288      * LLVM instructions.
 289      */
 290    struct lp_build_tgsi_action op_actions[TGSI_OPCODE_LAST];
 291
 292    /* TGSI_OPCODE_RSQ is defined as 1 / sqrt( abs(src0.x) ), rsq_action
 293     * should compute 1 / sqrt (src0.x) */
 294    struct lp_build_tgsi_action rsq_action;
 295
 296    const struct tgsi_shader_info *info;
 297
 298    lp_build_emit_fetch_fn emit_fetch_funcs[TGSI_FILE_COUNT];
 299
 300    LLVMValueRef (*emit_swizzle)(struct lp_build_tgsi_context *,
 301                          LLVMValueRef, unsigned, unsigned, unsigned, unsigned);
 302
 303    void (*emit_store)(struct lp_build_tgsi_context *,
 304                       const struct tgsi_full_instruction *,
 305                       const struct tgsi_opcode_info *,
 306                       LLVMValueRef dst[4]);
 307
 308    void (*emit_declaration)(struct lp_build_tgsi_context *,
 309                              const struct tgsi_full_declaration *decl);
 310
 311    void (*emit_immediate)(struct lp_build_tgsi_context *,
 312                           const struct tgsi_full_immediate *imm);
 313
 314
 315    /* Allow the user to store data in this structure rather than passing it
 316     * to every function. */
 317    void * userdata;
 318
 319    boolean soa;
 320
 321    int pc;
 322
 323    struct tgsi_full_instruction *instructions;
 324    uint max_instructions;
 325    uint num_instructions;
 326
 327    /** This function allows the user to insert some instructions at the
 328      * beginning of the program.  It is optional and does not need to be
 329      * implemented.
 330      */
 331    void (*emit_prologue)(struct lp_build_tgsi_context*);
 332
 333    /** This function allows the user to insert some instructions at the end of
 334      * the program.  This callback is intended to be used for emitting
 335      * instructions to handle the export for the output registers, but it can
 336      * be used for any purpose.  Implementing this function is optiona, but
 337      * recommended.
 338      */
 339    void (*emit_epilogue)(struct lp_build_tgsi_context*);
 340 };
 341
 342 struct lp_build_tgsi_soa_context
 343 {
 344    struct lp_build_tgsi_context bld_base;
 345
 346    /* Builder for scalar elements of shader's data type (float) */
 347    struct lp_build_context elem_bld;
 348
 349    LLVMValueRef consts_ptr;
 350    const LLVMValueRef *pos;
 351    const LLVMValueRef (*inputs)[TGSI_NUM_CHANNELS];
 352    LLVMValueRef (*outputs)[TGSI_NUM_CHANNELS];
 353
 354    const struct lp_build_sampler_soa *sampler;
 355
 356    LLVMValueRef immediates[LP_MAX_TGSI_IMMEDIATES][TGSI_NUM_CHANNELS];
 357    LLVMValueRef temps[LP_MAX_TGSI_TEMPS][TGSI_NUM_CHANNELS];
 358    LLVMValueRef addr[LP_MAX_TGSI_ADDRS][TGSI_NUM_CHANNELS];
 359    LLVMValueRef preds[LP_MAX_TGSI_PREDS][TGSI_NUM_CHANNELS];
 360
 361    /* We allocate/use this array of temps if (1 << TGSI_FILE_TEMPORARY) is
 362     * set in the indirect_files field.
 363     * The temps[] array above is unused then.
 364     */
 365    LLVMValueRef temps_array;
 366
 367    /* We allocate/use this array of output if (1 << TGSI_FILE_OUTPUT) is
 368     * set in the indirect_files field.
 369     * The outputs[] array above is unused then.
 370     */
 371    LLVMValueRef outputs_array;
 372
 373    /* We allocate/use this array of inputs if (1 << TGSI_FILE_INPUT) is
 374     * set in the indirect_files field.
 375     * The inputs[] array above is unused then.
 376     */
 377    LLVMValueRef inputs_array;
 378
 379    LLVMValueRef system_values_array;
 380
 381    /** bitmask indicating which register files are accessed indirectly */
 382    unsigned indirect_files;
 383
 384    struct lp_build_mask_context *mask;
 385    struct lp_exec_mask exec_mask;
 386
 387    uint num_immediates;
 388
 389 };
 390
 391 void
 392 lp_emit_declaration_soa(
 393    struct lp_build_tgsi_context *bld,
 394    const struct tgsi_full_declaration *decl);
 395
 396 void lp_emit_immediate_soa(
 397    struct lp_build_tgsi_context *bld_base,
 398    const struct tgsi_full_immediate *imm);
 399
 400 boolean
 401 lp_emit_instruction_soa(
 402    struct lp_build_tgsi_soa_context *bld,
 403    const struct tgsi_full_instruction *inst,
 404    const struct tgsi_opcode_info *info);
 405
 406
 407 LLVMValueRef
 408 lp_get_temp_ptr_soa(
 409    struct lp_build_tgsi_soa_context *bld,
 410    unsigned index,
 411    unsigned chan);
 412
 413 LLVMValueRef
 414 lp_get_output_ptr(
 415    struct lp_build_tgsi_soa_context *bld,
 416    unsigned index,
 417    unsigned chan);
 418
 419 struct lp_build_tgsi_aos_context
 420 {
 421    struct lp_build_tgsi_context bld_base;
 422
 423    /* Builder for integer masks and indices */
 424    struct lp_build_context int_bld;
 425
 426    /*
 427     * AoS swizzle used:
 428     * - swizzles[0] = red index
 429     * - swizzles[1] = green index
 430     * - swizzles[2] = blue index
 431     * - swizzles[3] = alpha index
 432     */
 433    unsigned char swizzles[4];
 434    unsigned char inv_swizzles[4];
 435
 436    LLVMValueRef consts_ptr;
 437    const LLVMValueRef *inputs;
 438    LLVMValueRef *outputs;
 439
 440    struct lp_build_sampler_aos *sampler;
 441
 442    LLVMValueRef immediates[LP_MAX_TGSI_IMMEDIATES];
 443    LLVMValueRef temps[LP_MAX_TGSI_TEMPS];
 444    LLVMValueRef addr[LP_MAX_TGSI_ADDRS];
 445    LLVMValueRef preds[LP_MAX_TGSI_PREDS];
 446
 447    /* We allocate/use this array of temps if (1 << TGSI_FILE_TEMPORARY) is
 448     * set in the indirect_files field.
 449     * The temps[] array above is unused then.
 450     */
 451    LLVMValueRef temps_array;
 452
 453    /** bitmask indicating which register files are accessed indirectly */
 454    unsigned indirect_files;
 455
 456 };
 457
 458 static INLINE struct lp_build_tgsi_soa_context *
 459 lp_soa_context(struct lp_build_tgsi_context *bld_base)
 460 {
 461    return (struct lp_build_tgsi_soa_context *)bld_base;
 462 }
 463
 464 static INLINE struct lp_build_tgsi_aos_context *
 465 lp_aos_context(struct lp_build_tgsi_context *bld_base)
 466 {
 467    return (struct lp_build_tgsi_aos_context *)bld_base;
 468 }
 469
 470 void
 471 lp_emit_declaration_aos(
 472    struct lp_build_tgsi_aos_context *bld,
 473    const struct tgsi_full_declaration *decl);
 474
 475
 476 boolean
 477 lp_emit_instruction_aos(
 478    struct lp_build_tgsi_aos_context *bld,
 479    const struct tgsi_full_instruction *inst,
 480    const struct tgsi_opcode_info *info,
 481    int *pc);
 482
 483 void
 484 lp_emit_store_aos(
 485    struct lp_build_tgsi_aos_context *bld,
 486    const struct tgsi_full_instruction *inst,
 487    unsigned index,
 488    LLVMValueRef value);
 489
 490 void lp_build_fetch_args(
 491    struct lp_build_tgsi_context * bld_base,
 492    struct lp_build_emit_data * emit_data);
 493
 494 LLVMValueRef
 495 lp_build_tgsi_inst_llvm_aos(
 496    struct lp_build_tgsi_context * bld_base,
 497    const struct tgsi_full_instruction *inst);
 498
 499 void
 500 lp_build_tgsi_intrinsic(
 501  const struct lp_build_tgsi_action * action,
 502  struct lp_build_tgsi_context * bld_base,
 503  struct lp_build_emit_data * emit_data);
 504
 505 LLVMValueRef
 506 lp_build_emit_llvm(
 507    struct lp_build_tgsi_context *bld_base,
 508    unsigned tgsi_opcode,
 509    struct lp_build_emit_data * emit_data);
 510
 511 LLVMValueRef
 512 lp_build_emit_llvm_unary(
 513    struct lp_build_tgsi_context *bld_base,
 514    unsigned tgsi_opcode,
 515    LLVMValueRef arg0);
 516
 517 LLVMValueRef
 518 lp_build_emit_llvm_binary(
 519    struct lp_build_tgsi_context *bld_base,
 520    unsigned tgsi_opcode,
 521    LLVMValueRef arg0,
 522    LLVMValueRef arg1);
 523
 524 LLVMValueRef
 525 lp_build_emit_llvm_ternary(
 526    struct lp_build_tgsi_context *bld_base,
 527    unsigned tgsi_opcode,
 528    LLVMValueRef arg0,
 529    LLVMValueRef arg1,
 530    LLVMValueRef arg2);
 531
 532 boolean
 533 lp_build_tgsi_inst_llvm(
 534    struct lp_build_tgsi_context * bld_base,
 535    const struct tgsi_full_instruction *inst);
 536
 537 LLVMValueRef
 538 lp_build_emit_fetch(
 539    struct lp_build_tgsi_context *bld_base,
 540    const struct tgsi_full_instruction *inst,
 541    unsigned src_op,
 542    const unsigned chan_index);
 543
 544 boolean
 545 lp_build_tgsi_llvm(
 546    struct lp_build_tgsi_context * bld_base,
 547    const struct tgsi_token *tokens);
 548
 549 #endif /* LP_BLD_TGSI_H */