src/gallium/auxiliary/gallivm/lp_bld_tgsi.c

   1 /**************************************************************************
   2  *
   3  * Copyright 2011-2012 Advanced Micro Devices, Inc.
   4  * Copyright 2010 VMware, Inc.
   5  * Copyright 2009 VMware, Inc.
   6  * Copyright 2007-2008 Tungsten Graphics, Inc., Cedar Park, Texas.
   7  * All Rights Reserved.
   8  *
   9  * Permission is hereby granted, free of charge, to any person obtaining a
  10  * copy of this software and associated documentation files (the
  11  * "Software"), to deal in the Software without restriction, including
  12  * without limitation the rights to use, copy, modify, merge, publish,
  13  * distribute, sub license, and/or sell copies of the Software, and to
  14  * permit persons to whom the Software is furnished to do so, subject to
  15  * the following conditions:
  16  *
  17  * The above copyright notice and this permission notice (including the
  18  * next paragraph) shall be included in all copies or substantial portions
  19  * of the Software.
  20  *
  21  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  22  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  23  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  24  * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
  25  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  26  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  27  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  28  *
  29  **************************************************************************/
  30
  31 #include "gallivm/lp_bld_tgsi.h"
  32
  33 #include "gallivm/lp_bld_arit.h"
  34 #include "gallivm/lp_bld_gather.h"
  35 #include "gallivm/lp_bld_init.h"
  36 #include "gallivm/lp_bld_intr.h"
  37 #include "tgsi/tgsi_info.h"
  38 #include "tgsi/tgsi_parse.h"
  39 #include "tgsi/tgsi_util.h"
  40 #include "util/u_memory.h"
  41
  42 /* The user is responsible for freeing list->instructions */
  43 unsigned lp_bld_tgsi_list_init(struct lp_build_tgsi_context * bld_base)
  44 {
  45    bld_base->instructions = (struct tgsi_full_instruction *)
  46          MALLOC( LP_MAX_INSTRUCTIONS * sizeof(struct tgsi_full_instruction) );
  47    if (!bld_base->instructions) {
  48       return 0;
  49    }
  50    bld_base->max_instructions = LP_MAX_INSTRUCTIONS;
  51    return 1;
  52 }
  53
  54
  55 unsigned lp_bld_tgsi_add_instruction(
  56    struct lp_build_tgsi_context * bld_base,
  57    struct tgsi_full_instruction *inst_to_add)
  58 {
  59
  60    if (bld_base->num_instructions == bld_base->max_instructions) {
  61       struct tgsi_full_instruction *instructions;
  62       instructions = REALLOC(bld_base->instructions, bld_base->max_instructions
  63                                       * sizeof(struct tgsi_full_instruction),
  64                                       (bld_base->max_instructions + LP_MAX_INSTRUCTIONS)
  65                                       * sizeof(struct tgsi_full_instruction));
  66       if (!instructions) {
  67          return 0;
  68       }
  69       bld_base->instructions = instructions;
  70       bld_base->max_instructions += LP_MAX_INSTRUCTIONS;
  71    }
  72    memcpy(bld_base->instructions + bld_base->num_instructions, inst_to_add,
  73           sizeof(bld_base->instructions[0]));
  74
  75    bld_base->num_instructions++;
  76
  77    return 1;
  78 }
  79
  80
  81 /**
  82  * This function assumes that all the args in emit_data have been set.
  83  */
  84 static void
  85 lp_build_action_set_dst_type(
  86    struct lp_build_emit_data * emit_data,
  87    struct lp_build_tgsi_context *bld_base,
  88    unsigned tgsi_opcode)
  89 {
  90    if (emit_data->arg_count == 0) {
  91       emit_data->dst_type = LLVMVoidTypeInContext(bld_base->base.gallivm->context);
  92    } else {
  93       /* XXX: Not all opcodes have the same src and dst types. */
  94       emit_data->dst_type = LLVMTypeOf(emit_data->args[0]);
  95    }
  96 }
  97
  98 void
  99 lp_build_tgsi_intrinsic(
 100  const struct lp_build_tgsi_action * action,
 101  struct lp_build_tgsi_context * bld_base,
 102  struct lp_build_emit_data * emit_data)
 103 {
 104    struct lp_build_context * base = &bld_base->base;
 105    emit_data->output[emit_data->chan] = lp_build_intrinsic(
 106                base->gallivm->builder, action->intr_name,
 107                emit_data->dst_type, emit_data->args, emit_data->arg_count);
 108 }
 109
 110 LLVMValueRef
 111 lp_build_emit_llvm(
 112    struct lp_build_tgsi_context *bld_base,
 113    unsigned tgsi_opcode,
 114    struct lp_build_emit_data * emit_data)
 115 {
 116    struct lp_build_tgsi_action * action = &bld_base->op_actions[tgsi_opcode];
 117    /* XXX: Assert that this is a componentwise or replicate instruction */
 118
 119    lp_build_action_set_dst_type(emit_data, bld_base, tgsi_opcode);
 120    emit_data->chan = 0;
 121    assert(action->emit);
 122    action->emit(action, bld_base, emit_data);
 123    return emit_data->output[0];
 124 }
 125
 126 LLVMValueRef
 127 lp_build_emit_llvm_unary(
 128    struct lp_build_tgsi_context *bld_base,
 129    unsigned tgsi_opcode,
 130    LLVMValueRef arg0)
 131 {
 132    struct lp_build_emit_data emit_data;
 133    emit_data.arg_count = 1;
 134    emit_data.args[0] = arg0;
 135    return lp_build_emit_llvm(bld_base, tgsi_opcode, &emit_data);
 136 }
 137
 138 LLVMValueRef
 139 lp_build_emit_llvm_binary(
 140    struct lp_build_tgsi_context *bld_base,
 141    unsigned tgsi_opcode,
 142    LLVMValueRef arg0,
 143    LLVMValueRef arg1)
 144 {
 145    struct lp_build_emit_data emit_data;
 146    emit_data.arg_count = 2;
 147    emit_data.args[0] = arg0;
 148    emit_data.args[1] = arg1;
 149    return lp_build_emit_llvm(bld_base, tgsi_opcode, &emit_data);
 150 }
 151
 152 LLVMValueRef
 153 lp_build_emit_llvm_ternary(
 154    struct lp_build_tgsi_context *bld_base,
 155    unsigned tgsi_opcode,
 156    LLVMValueRef arg0,
 157    LLVMValueRef arg1,
 158    LLVMValueRef arg2)
 159 {
 160    struct lp_build_emit_data emit_data;
 161    emit_data.arg_count = 3;
 162    emit_data.args[0] = arg0;
 163    emit_data.args[1] = arg1;
 164    emit_data.args[2] = arg2;
 165    return lp_build_emit_llvm(bld_base, tgsi_opcode, &emit_data);
 166 }
 167
 168 /**
 169  * The default fetch implementation.
 170  */
 171 void lp_build_fetch_args(
 172    struct lp_build_tgsi_context * bld_base,
 173    struct lp_build_emit_data * emit_data)
 174 {
 175    unsigned src;
 176    for (src = 0; src < emit_data->info->num_src; src++) {
 177       emit_data->args[src] = lp_build_emit_fetch(bld_base, emit_data->inst, src,
 178                                                emit_data->chan);
 179    }
 180    emit_data->arg_count = emit_data->info->num_src;
 181    lp_build_action_set_dst_type(emit_data, bld_base,
 182                 emit_data->inst->Instruction.Opcode);
 183 }
 184
 185 /* XXX: COMMENT
 186  * It should be assumed that this function ignores writemasks
 187  */
 188 boolean
 189 lp_build_tgsi_inst_llvm(
 190    struct lp_build_tgsi_context * bld_base,
 191    const struct tgsi_full_instruction * inst)
 192 {
 193    unsigned tgsi_opcode = inst->Instruction.Opcode;
 194    const struct tgsi_opcode_info * info = tgsi_get_opcode_info(tgsi_opcode);
 195    const struct lp_build_tgsi_action * action =
 196                                          &bld_base->op_actions[tgsi_opcode];
 197    struct lp_build_emit_data emit_data;
 198    unsigned chan_index;
 199    LLVMValueRef val;
 200
 201    bld_base->pc++;
 202
 203    /* Ignore deprecated instructions */
 204    switch (inst->Instruction.Opcode) {
 205
 206    case TGSI_OPCODE_RCC:
 207    case TGSI_OPCODE_UP2H:
 208    case TGSI_OPCODE_UP2US:
 209    case TGSI_OPCODE_UP4B:
 210    case TGSI_OPCODE_UP4UB:
 211    case TGSI_OPCODE_X2D:
 212    case TGSI_OPCODE_ARA:
 213    case TGSI_OPCODE_BRA:
 214    case TGSI_OPCODE_DIV:
 215    case TGSI_OPCODE_PUSHA:
 216    case TGSI_OPCODE_POPA:
 217    case TGSI_OPCODE_I2F:
 218    case TGSI_OPCODE_NOT:
 219    case TGSI_OPCODE_SHL:
 220    case TGSI_OPCODE_ISHR:
 221    case TGSI_OPCODE_AND:
 222    case TGSI_OPCODE_OR:
 223    case TGSI_OPCODE_MOD:
 224    case TGSI_OPCODE_XOR:
 225    case TGSI_OPCODE_SAD:
 226    case TGSI_OPCODE_TXF:
 227    case TGSI_OPCODE_TXQ:
 228       /* deprecated? */
 229       assert(0);
 230       return FALSE;
 231       break;
 232    }
 233
 234    /* Check if the opcode has been implemented */
 235    if (!action->emit) {
 236       return FALSE;
 237    }
 238
 239    memset(&emit_data, 0, sizeof(emit_data));
 240
 241    assert(info->num_dst <= 1);
 242    if (info->num_dst) {
 243       TGSI_FOR_EACH_DST0_ENABLED_CHANNEL( inst, chan_index ) {
 244          emit_data.output[chan_index] = bld_base->base.undef;
 245       }
 246    }
 247
 248    emit_data.inst = inst;
 249    emit_data.info = info;
 250
 251    /* Emit the instructions */
 252    if (info->output_mode == TGSI_OUTPUT_COMPONENTWISE && bld_base->soa) {
 253       TGSI_FOR_EACH_DST0_ENABLED_CHANNEL(inst, chan_index) {
 254          emit_data.chan = chan_index;
 255          if (!action->fetch_args) {
 256             lp_build_fetch_args(bld_base, &emit_data);
 257          } else {
 258              action->fetch_args(bld_base, &emit_data);
 259          }
 260          action->emit(action, bld_base, &emit_data);
 261       }
 262    } else {
 263       emit_data.chan = LP_CHAN_ALL;
 264       if (action->fetch_args) {
 265          action->fetch_args(bld_base, &emit_data);
 266       }
 267       /* Make sure the output value is stored in emit_data.output[0], unless
 268        * the opcode is channel dependent */
 269       if (info->output_mode != TGSI_OUTPUT_CHAN_DEPENDENT) {
 270          emit_data.chan = 0;
 271       }
 272       action->emit(action, bld_base, &emit_data);
 273
 274       /* Replicate the output values */
 275       if (info->output_mode == TGSI_OUTPUT_REPLICATE && bld_base->soa) {
 276          val = emit_data.output[0];
 277          memset(emit_data.output, 0, sizeof(emit_data.output));
 278          TGSI_FOR_EACH_DST0_ENABLED_CHANNEL(inst, chan_index) {
 279             emit_data.output[chan_index] = val;
 280          }
 281       }
 282    }
 283
 284    if (info->num_dst > 0) {
 285       bld_base->emit_store(bld_base, inst, info, emit_data.output);
 286    }
 287    return TRUE;
 288 }
 289
 290
 291 LLVMValueRef
 292 lp_build_emit_fetch(
 293    struct lp_build_tgsi_context *bld_base,
 294    const struct tgsi_full_instruction *inst,
 295    unsigned src_op,
 296    const unsigned chan_index)
 297 {
 298    const struct tgsi_full_src_register *reg = &inst->Src[src_op];
 299    unsigned swizzle;
 300    LLVMValueRef res;
 301    enum tgsi_opcode_type stype = tgsi_opcode_infer_src_type(inst->Instruction.Opcode);
 302
 303    if (chan_index == LP_CHAN_ALL) {
 304       swizzle = ~0;
 305    } else {
 306       swizzle = tgsi_util_get_full_src_register_swizzle(reg, chan_index);
 307       if (swizzle > 3) {
 308          assert(0 && "invalid swizzle in emit_fetch()");
 309          return bld_base->base.undef;
 310       }
 311    }
 312
 313    assert(reg->Register.Index <= bld_base->info->file_max[reg->Register.File]);
 314
 315    if (bld_base->emit_fetch_funcs[reg->Register.File]) {
 316       res = bld_base->emit_fetch_funcs[reg->Register.File](bld_base, reg, stype,
 317                                                            swizzle);
 318    } else {
 319       assert(0 && "invalid src register in emit_fetch()");
 320       return bld_base->base.undef;
 321    }
 322
 323    if (reg->Register.Absolute) {
 324       res = lp_build_emit_llvm_unary(bld_base, TGSI_OPCODE_ABS, res);
 325    }
 326
 327    if (reg->Register.Negate) {
 328       res = lp_build_negate( &bld_base->base, res );
 329    }
 330
 331    /*
 332     * Swizzle the argument
 333     */
 334
 335    if (swizzle == ~0) {
 336       res = bld_base->emit_swizzle(bld_base, res,
 337                      reg->Register.SwizzleX,
 338                      reg->Register.SwizzleY,
 339                      reg->Register.SwizzleZ,
 340                      reg->Register.SwizzleW);
 341    }
 342
 343    return res;
 344
 345 }
 346
 347 boolean
 348 lp_build_tgsi_llvm(
 349    struct lp_build_tgsi_context * bld_base,
 350    const struct tgsi_token *tokens)
 351 {
 352    struct tgsi_parse_context parse;
 353
 354    if (bld_base->emit_prologue) {
 355       bld_base->emit_prologue(bld_base);
 356    }
 357
 358    if (!lp_bld_tgsi_list_init(bld_base)) {
 359       return FALSE;
 360    }
 361
 362    tgsi_parse_init( &parse, tokens );
 363
 364    while( !tgsi_parse_end_of_tokens( &parse ) ) {
 365       tgsi_parse_token( &parse );
 366
 367       switch( parse.FullToken.Token.Type ) {
 368       case TGSI_TOKEN_TYPE_DECLARATION:
 369          /* Inputs already interpolated */
 370          bld_base->emit_declaration(bld_base, &parse.FullToken.FullDeclaration);
 371          break;
 372
 373       case TGSI_TOKEN_TYPE_INSTRUCTION:
 374          lp_bld_tgsi_add_instruction(bld_base, &parse.FullToken.FullInstruction);
 375          break;
 376
 377       case TGSI_TOKEN_TYPE_IMMEDIATE:
 378          bld_base->emit_immediate(bld_base, &parse.FullToken.FullImmediate);
 379          break;
 380
 381       case TGSI_TOKEN_TYPE_PROPERTY:
 382          break;
 383
 384       default:
 385          assert( 0 );
 386       }
 387    }
 388
 389    while (bld_base->pc != -1) {
 390       struct tgsi_full_instruction *instr = bld_base->instructions +
 391                                                         bld_base->pc;
 392       const struct tgsi_opcode_info *opcode_info =
 393          tgsi_get_opcode_info(instr->Instruction.Opcode);
 394       if (!lp_build_tgsi_inst_llvm(bld_base, instr)) {
 395          _debug_printf("warning: failed to translate tgsi opcode %s to LLVM\n",
 396                        opcode_info->mnemonic);
 397          return FALSE;
 398       }
 399    }
 400
 401    tgsi_parse_free(&parse);
 402
 403    FREE(bld_base->instructions);
 404
 405    if (bld_base->emit_epilogue) {
 406       bld_base->emit_epilogue(bld_base);
 407    }
 408
 409    return TRUE;
 410 }