src/gallium/drivers/llvmpipe/lp_bld_logic.c

   1 /**************************************************************************
   2  *
   3  * Copyright 2009 VMware, Inc.
   4  * All Rights Reserved.
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a
   7  * copy of this software and associated documentation files (the
   8  * "Software"), to deal in the Software without restriction, including
   9  * without limitation the rights to use, copy, modify, merge, publish,
  10  * distribute, sub license, and/or sell copies of the Software, and to
  11  * permit persons to whom the Software is furnished to do so, subject to
  12  * the following conditions:
  13  *
  14  * The above copyright notice and this permission notice (including the
  15  * next paragraph) shall be included in all copies or substantial portions
  16  * of the Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  19  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  20  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  21  * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
  22  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  23  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  24  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25  *
  26  **************************************************************************/
  27
  28 /**
  29  * @file
  30  * Helper functions for logical operations.
  31  *
  32  * @author Jose Fonseca <jfonseca@vmware.com>
  33  */
  34
  35
  36 #include "pipe/p_defines.h"
  37 #include "lp_bld_type.h"
  38 #include "lp_bld_const.h"
  39 #include "lp_bld_intr.h"
  40 #include "lp_bld_logic.h"
  41
  42
  43 LLVMValueRef
  44 lp_build_cmp(struct lp_build_context *bld,
  45              unsigned func,
  46              LLVMValueRef a,
  47              LLVMValueRef b)
  48 {
  49    const union lp_type type = bld->type;
  50    LLVMTypeRef vec_type = lp_build_vec_type(type);
  51    LLVMTypeRef int_vec_type = lp_build_int_vec_type(type);
  52    LLVMValueRef zeros = LLVMConstNull(int_vec_type);
  53    LLVMValueRef ones = LLVMConstAllOnes(int_vec_type);
  54    LLVMValueRef cond;
  55
  56    if(func == PIPE_FUNC_NEVER)
  57       return zeros;
  58    if(func == PIPE_FUNC_ALWAYS)
  59       return ones;
  60
  61    /* TODO: optimize the constant case */
  62
  63    /* XXX: It is not clear if we should use the ordered or unordered operators */
  64
  65 #if defined(PIPE_ARCH_X86) || defined(PIPE_ARCH_X86_64)
  66    if(type.width * type.length == 128) {
  67       if(type.floating) {
  68          LLVMValueRef args[3];
  69          unsigned cc;
  70          boolean swap;
  71          LLVMValueRef res;
  72
  73          swap = FALSE;
  74          switch(func) {
  75          case PIPE_FUNC_EQUAL:
  76             cc = 0;
  77             break;
  78          case PIPE_FUNC_NOTEQUAL:
  79             cc = 4;
  80             break;
  81          case PIPE_FUNC_LESS:
  82             cc = 1;
  83             break;
  84          case PIPE_FUNC_LEQUAL:
  85             cc = 2;
  86             break;
  87          case PIPE_FUNC_GREATER:
  88             cc = 1;
  89             swap = TRUE;
  90             break;
  91          case PIPE_FUNC_GEQUAL:
  92             cc = 2;
  93             swap = TRUE;
  94             break;
  95          default:
  96             assert(0);
  97             return bld->undef;
  98          }
  99
 100          if(swap) {
 101             args[0] = b;
 102             args[1] = a;
 103          }
 104          else {
 105             args[0] = a;
 106             args[1] = b;
 107          }
 108
 109          args[2] = LLVMConstInt(LLVMInt8Type(), cc, 0);
 110          res = lp_build_intrinsic(bld->builder,
 111                                   "llvm.x86.sse.cmp.ps",
 112                                   vec_type,
 113                                   args, 3);
 114          res = LLVMBuildBitCast(bld->builder, res, int_vec_type, "");
 115          return res;
 116       }
 117       else {
 118          static const struct {
 119             unsigned swap:1;
 120             unsigned eq:1;
 121             unsigned gt:1;
 122             unsigned not:1;
 123          } table[] = {
 124             {0, 0, 0, 1}, /* PIPE_FUNC_NEVER */
 125             {1, 0, 1, 0}, /* PIPE_FUNC_LESS */
 126             {0, 1, 0, 0}, /* PIPE_FUNC_EQUAL */
 127             {0, 0, 1, 1}, /* PIPE_FUNC_LEQUAL */
 128             {0, 0, 1, 0}, /* PIPE_FUNC_GREATER */
 129             {0, 1, 0, 1}, /* PIPE_FUNC_NOTEQUAL */
 130             {1, 0, 1, 1}, /* PIPE_FUNC_GEQUAL */
 131             {0, 0, 0, 0}  /* PIPE_FUNC_ALWAYS */
 132          };
 133          const char *pcmpeq;
 134          const char *pcmpgt;
 135          LLVMValueRef args[2];
 136          LLVMValueRef res;
 137
 138          switch (type.width) {
 139          case 8:
 140             pcmpeq = "llvm.x86.sse2.pcmpeq.b";
 141             pcmpgt = "llvm.x86.sse2.pcmpgt.b";
 142             break;
 143          case 16:
 144             pcmpeq = "llvm.x86.sse2.pcmpeq.w";
 145             pcmpgt = "llvm.x86.sse2.pcmpgt.w";
 146             break;
 147          case 32:
 148             pcmpeq = "llvm.x86.sse2.pcmpeq.d";
 149             pcmpgt = "llvm.x86.sse2.pcmpgt.d";
 150             break;
 151          default:
 152             assert(0);
 153             return bld->undef;
 154          }
 155
 156          /* There are no signed byte and unsigned word/dword comparison
 157           * instructions. So flip the sign bit so that the results match.
 158           */
 159          if(table[func].gt &&
 160             ((type.width == 8 && type.sign) ||
 161              (type.width != 8 && !type.sign))) {
 162             LLVMValueRef msb = lp_build_int_const_uni(type, (unsigned long long)1 << (type.width - 1));
 163             a = LLVMBuildXor(bld->builder, a, msb, "");
 164             b = LLVMBuildXor(bld->builder, b, msb, "");
 165          }
 166
 167          if(table[func].swap) {
 168             args[0] = b;
 169             args[1] = a;
 170          }
 171          else {
 172             args[0] = a;
 173             args[1] = b;
 174          }
 175
 176          if(table[func].eq)
 177             res = lp_build_intrinsic(bld->builder, pcmpeq, vec_type, args, 2);
 178          else if (table[func].gt)
 179             res = lp_build_intrinsic(bld->builder, pcmpgt, vec_type, args, 2);
 180          else
 181             res = LLVMConstNull(vec_type);
 182
 183          if(table[func].not)
 184             res = LLVMBuildNot(bld->builder, res, "");
 185
 186          return res;
 187       }
 188    }
 189 #endif
 190
 191    if(type.floating) {
 192       LLVMRealPredicate op;
 193       switch(func) {
 194       case PIPE_FUNC_NEVER:
 195          op = LLVMRealPredicateFalse;
 196          break;
 197       case PIPE_FUNC_ALWAYS:
 198          op = LLVMRealPredicateTrue;
 199          break;
 200       case PIPE_FUNC_EQUAL:
 201          op = LLVMRealUEQ;
 202          break;
 203       case PIPE_FUNC_NOTEQUAL:
 204          op = LLVMRealUNE;
 205          break;
 206       case PIPE_FUNC_LESS:
 207          op = LLVMRealULT;
 208          break;
 209       case PIPE_FUNC_LEQUAL:
 210          op = LLVMRealULE;
 211          break;
 212       case PIPE_FUNC_GREATER:
 213          op = LLVMRealUGT;
 214          break;
 215       case PIPE_FUNC_GEQUAL:
 216          op = LLVMRealUGE;
 217          break;
 218       default:
 219          assert(0);
 220          return bld->undef;
 221       }
 222       cond = LLVMBuildFCmp(bld->builder, op, a, b, "");
 223    }
 224    else {
 225       LLVMIntPredicate op;
 226       switch(func) {
 227       case PIPE_FUNC_EQUAL:
 228          op = LLVMIntEQ;
 229          break;
 230       case PIPE_FUNC_NOTEQUAL:
 231          op = LLVMIntNE;
 232          break;
 233       case PIPE_FUNC_LESS:
 234          op = type.sign ? LLVMIntSLT : LLVMIntULT;
 235          break;
 236       case PIPE_FUNC_LEQUAL:
 237          op = type.sign ? LLVMIntSLE : LLVMIntULE;
 238          break;
 239       case PIPE_FUNC_GREATER:
 240          op = type.sign ? LLVMIntSGT : LLVMIntUGT;
 241          break;
 242       case PIPE_FUNC_GEQUAL:
 243          op = type.sign ? LLVMIntSGE : LLVMIntUGE;
 244          break;
 245       default:
 246          assert(0);
 247          return bld->undef;
 248       }
 249       cond = LLVMBuildICmp(bld->builder, op, a, b, "");
 250    }
 251
 252    return LLVMBuildSelect(bld->builder, cond, ones, zeros, "");
 253 }
 254
 255
 256 LLVMValueRef
 257 lp_build_select(struct lp_build_context *bld,
 258                 LLVMValueRef mask,
 259                 LLVMValueRef a,
 260                 LLVMValueRef b)
 261 {
 262    union lp_type type = bld->type;
 263    LLVMValueRef res;
 264
 265    if(a == b)
 266       return a;
 267
 268    if(type.floating) {
 269       LLVMTypeRef int_vec_type = lp_build_int_vec_type(type);
 270       a = LLVMBuildBitCast(bld->builder, a, int_vec_type, "");
 271       b = LLVMBuildBitCast(bld->builder, b, int_vec_type, "");
 272    }
 273
 274    /* TODO: On SSE4 we could do this with a single instruction -- PBLENDVB */
 275
 276    a = LLVMBuildAnd(bld->builder, a, mask, "");
 277
 278    /* This often gets translated to PANDN, but sometimes the NOT is
 279     * pre-computed and stored in another constant. The best strategy depends
 280     * on available registers, so it is not a big deal -- hopefully LLVM does
 281     * the right decision attending the rest of the program.
 282     */
 283    b = LLVMBuildAnd(bld->builder, b, LLVMBuildNot(bld->builder, mask, ""), "");
 284
 285    res = LLVMBuildOr(bld->builder, a, b, "");
 286
 287    if(type.floating) {
 288       LLVMTypeRef vec_type = lp_build_vec_type(type);
 289       res = LLVMBuildBitCast(bld->builder, res, vec_type, "");
 290    }
 291
 292    return res;
 293 }
 294
 295
 296 LLVMValueRef
 297 lp_build_select_aos(struct lp_build_context *bld,
 298                     LLVMValueRef a,
 299                     LLVMValueRef b,
 300                     boolean cond[4])
 301 {
 302    const union lp_type type = bld->type;
 303    const unsigned n = type.length;
 304    unsigned i, j;
 305
 306    if(a == b)
 307       return a;
 308    if(cond[0] && cond[1] && cond[2] && cond[3])
 309       return a;
 310    if(!cond[0] && !cond[1] && !cond[2] && !cond[3])
 311       return b;
 312    if(a == bld->undef || b == bld->undef)
 313       return bld->undef;
 314
 315    /*
 316     * There are three major ways of accomplishing this:
 317     * - with a shuffle,
 318     * - with a select,
 319     * - or with a bit mask.
 320     *
 321     * Select isn't supported for vector types yet.
 322     * The flip between these is empirical and might need to be.
 323     */
 324    if (n <= 4) {
 325       /*
 326        * Shuffle.
 327        */
 328       LLVMTypeRef elem_type = LLVMInt32Type();
 329       LLVMValueRef shuffles[LP_MAX_VECTOR_LENGTH];
 330
 331       for(j = 0; j < n; j += 4)
 332          for(i = 0; i < 4; ++i)
 333             shuffles[j + i] = LLVMConstInt(elem_type, (cond[i] ? 0 : n) + j + i, 0);
 334
 335       return LLVMBuildShuffleVector(bld->builder, a, b, LLVMConstVector(shuffles, n), "");
 336    }
 337 #if 0
 338    else if(0) {
 339       /* FIXME: Unfortunately select of vectors do not work */
 340       /* Use a select */
 341       LLVMTypeRef elem_type = LLVMInt1Type();
 342       LLVMValueRef cond[LP_MAX_VECTOR_LENGTH];
 343
 344       for(j = 0; j < n; j += 4)
 345          for(i = 0; i < 4; ++i)
 346             cond[j + i] = LLVMConstInt(elem_type, cond[i] ? 1 : 0, 0);
 347
 348       return LLVMBuildSelect(bld->builder, LLVMConstVector(cond, n), a, b, "");
 349    }
 350 #endif
 351    else {
 352       LLVMValueRef mask = lp_build_const_mask_aos(type, cond);
 353       return lp_build_select(bld, mask, a, b);
 354    }
 355 }