src/gallium/drivers/swr/rasterizer/jitter/blend_jit.cpp

   1 /****************************************************************************
   2 * Copyright (C) 2014-2015 Intel Corporation.   All Rights Reserved.
   3 *
   4 * Permission is hereby granted, free of charge, to any person obtaining a
   5 * copy of this software and associated documentation files (the "Software"),
   6 * to deal in the Software without restriction, including without limitation
   7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8 * and/or sell copies of the Software, and to permit persons to whom the
   9 * Software is furnished to do so, subject to the following conditions:
  10 *
  11 * The above copyright notice and this permission notice (including the next
  12 * paragraph) shall be included in all copies or substantial portions of the
  13 * Software.
  14 *
  15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  21 * IN THE SOFTWARE.
  22 *
  23 * @file blend_jit.cpp
  24 *
  25 * @brief Implementation of the blend jitter
  26 *
  27 * Notes:
  28 *
  29 ******************************************************************************/
  30 #include "jit_api.h"
  31 #include "blend_jit.h"
  32 #include "builder.h"
  33 #include "state_llvm.h"
  34 #include "common/containers.hpp"
  35 #include "llvm/IR/DataLayout.h"
  36
  37 #include <sstream>
  38
  39 // components with bit-widths <= the QUANTIZE_THRESHOLD will be quantized
  40 #define QUANTIZE_THRESHOLD 2
  41
  42 //////////////////////////////////////////////////////////////////////////
  43 /// Interface to Jitting a blend shader
  44 //////////////////////////////////////////////////////////////////////////
  45 struct BlendJit : public Builder
  46 {
  47     BlendJit(JitManager* pJitMgr) : Builder(pJitMgr){};
  48
  49     template<bool Color, bool Alpha>
  50     void GenerateBlendFactor(SWR_BLEND_FACTOR factor, Value* constColor[4], Value* src[4], Value* src1[4], Value* dst[4], Value* result[4])
  51     {
  52         Value* out[4];
  53
  54         switch (factor)
  55         {
  56         case BLENDFACTOR_ONE:
  57             out[0] = out[1] = out[2] = out[3] = VIMMED1(1.0f);
  58             break;
  59         case BLENDFACTOR_SRC_COLOR:
  60             out[0] = src[0];
  61             out[1] = src[1];
  62             out[2] = src[2];
  63             out[3] = src[3];
  64             break;
  65         case BLENDFACTOR_SRC_ALPHA:
  66             out[0] = out[1] = out[2] = out[3] = src[3];
  67             break;
  68         case BLENDFACTOR_DST_ALPHA:
  69             out[0] = out[1] = out[2] = out[3] = dst[3];
  70             break;
  71         case BLENDFACTOR_DST_COLOR:
  72             out[0] = dst[0];
  73             out[1] = dst[1];
  74             out[2] = dst[2];
  75             out[3] = dst[3];
  76             break;
  77         case BLENDFACTOR_SRC_ALPHA_SATURATE:
  78             out[0] = out[1] = out[2] = VMINPS(src[3], FSUB(VIMMED1(1.0f), dst[3]));
  79             out[3] = VIMMED1(1.0f);
  80             break;
  81         case BLENDFACTOR_CONST_COLOR:
  82             out[0] = constColor[0];
  83             out[1] = constColor[1];
  84             out[2] = constColor[2];
  85             out[3] = constColor[3];
  86             break;
  87         case BLENDFACTOR_CONST_ALPHA:
  88             out[0] = out[1] = out[2] = out[3] = constColor[3];
  89             break;
  90         case BLENDFACTOR_SRC1_COLOR:
  91             out[0] = src1[0];
  92             out[1] = src1[1];
  93             out[2] = src1[2];
  94             out[3] = src1[3];
  95             break;
  96         case BLENDFACTOR_SRC1_ALPHA:
  97             out[0] = out[1] = out[2] = out[3] = src1[3];
  98             break;
  99         case BLENDFACTOR_ZERO:
 100             out[0] = out[1] = out[2] = out[3] = VIMMED1(0.0f);
 101             break;
 102         case BLENDFACTOR_INV_SRC_COLOR:
 103             out[0] = FSUB(VIMMED1(1.0f), src[0]);
 104             out[1] = FSUB(VIMMED1(1.0f), src[1]);
 105             out[2] = FSUB(VIMMED1(1.0f), src[2]);
 106             out[3] = FSUB(VIMMED1(1.0f), src[3]);
 107             break;
 108         case BLENDFACTOR_INV_SRC_ALPHA:
 109             out[0] = out[1] = out[2] = out[3] = FSUB(VIMMED1(1.0f), src[3]);
 110             break;
 111         case BLENDFACTOR_INV_DST_ALPHA:
 112             out[0] = out[1] = out[2] = out[3] = FSUB(VIMMED1(1.0f), dst[3]);
 113             break;
 114         case BLENDFACTOR_INV_DST_COLOR:
 115             out[0] = FSUB(VIMMED1(1.0f), dst[0]);
 116             out[1] = FSUB(VIMMED1(1.0f), dst[1]);
 117             out[2] = FSUB(VIMMED1(1.0f), dst[2]);
 118             out[3] = FSUB(VIMMED1(1.0f), dst[3]);
 119             break;
 120         case BLENDFACTOR_INV_CONST_COLOR:
 121             out[0] = FSUB(VIMMED1(1.0f), constColor[0]);
 122             out[1] = FSUB(VIMMED1(1.0f), constColor[1]);
 123             out[2] = FSUB(VIMMED1(1.0f), constColor[2]);
 124             out[3] = FSUB(VIMMED1(1.0f), constColor[3]);
 125             break;
 126         case BLENDFACTOR_INV_CONST_ALPHA:
 127             out[0] = out[1] = out[2] = out[3] = FSUB(VIMMED1(1.0f), constColor[3]);
 128             break;
 129         case BLENDFACTOR_INV_SRC1_COLOR:
 130             out[0] = FSUB(VIMMED1(1.0f), src1[0]);
 131             out[1] = FSUB(VIMMED1(1.0f), src1[1]);
 132             out[2] = FSUB(VIMMED1(1.0f), src1[2]);
 133             out[3] = FSUB(VIMMED1(1.0f), src1[3]);
 134             break;
 135         case BLENDFACTOR_INV_SRC1_ALPHA:
 136             out[0] = out[1] = out[2] = out[3] = FSUB(VIMMED1(1.0f), src1[3]);
 137             break;
 138         default:
 139             SWR_ASSERT(false, "Unsupported blend factor: %d", factor);
 140             out[0] = out[1] = out[2] = out[3] = VIMMED1(0.0f);
 141             break;
 142         }
 143
 144         if (Color)
 145         {
 146             result[0] = out[0];
 147             result[1] = out[1];
 148             result[2] = out[2];
 149         }
 150
 151         if (Alpha)
 152         {
 153             result[3] = out[3];
 154         }
 155     }
 156
 157     void Clamp(SWR_FORMAT format, Value* src[4])
 158     {
 159         const SWR_FORMAT_INFO& info = GetFormatInfo(format);
 160         SWR_TYPE type = info.type[0];
 161
 162         switch (type)
 163         {
 164         case SWR_TYPE_FLOAT:
 165             break;
 166
 167         case SWR_TYPE_UNORM:
 168             src[0] = VMINPS(VMAXPS(src[0], VIMMED1(0.0f)), VIMMED1(1.0f));
 169             src[1] = VMINPS(VMAXPS(src[1], VIMMED1(0.0f)), VIMMED1(1.0f));
 170             src[2] = VMINPS(VMAXPS(src[2], VIMMED1(0.0f)), VIMMED1(1.0f));
 171             src[3] = VMINPS(VMAXPS(src[3], VIMMED1(0.0f)), VIMMED1(1.0f));
 172             break;
 173
 174         case SWR_TYPE_SNORM:
 175             src[0] = VMINPS(VMAXPS(src[0], VIMMED1(-1.0f)), VIMMED1(1.0f));
 176             src[1] = VMINPS(VMAXPS(src[1], VIMMED1(-1.0f)), VIMMED1(1.0f));
 177             src[2] = VMINPS(VMAXPS(src[2], VIMMED1(-1.0f)), VIMMED1(1.0f));
 178             src[3] = VMINPS(VMAXPS(src[3], VIMMED1(-1.0f)), VIMMED1(1.0f));
 179             break;
 180
 181         default: SWR_ASSERT(false, "Unsupport format type: %d", type);
 182         }
 183     }
 184
 185     void ApplyDefaults(SWR_FORMAT format, Value* src[4])
 186     {
 187         const SWR_FORMAT_INFO& info = GetFormatInfo(format);
 188
 189         bool valid[] = { false, false, false, false };
 190         for (uint32_t c = 0; c < info.numComps; ++c)
 191         {
 192             valid[info.swizzle[c]] = true;
 193         }
 194
 195         for (uint32_t c = 0; c < 4; ++c)
 196         {
 197             if (!valid[c])
 198             {
 199                 src[c] = BITCAST(VIMMED1((int)info.defaults[c]), mSimdFP32Ty);
 200             }
 201         }
 202     }
 203
 204     void ApplyUnusedDefaults(SWR_FORMAT format, Value* src[4])
 205     {
 206         const SWR_FORMAT_INFO& info = GetFormatInfo(format);
 207
 208         for (uint32_t c = 0; c < info.numComps; ++c)
 209         {
 210             if (info.type[c] == SWR_TYPE_UNUSED)
 211             {
 212                 src[info.swizzle[c]] = BITCAST(VIMMED1((int)info.defaults[info.swizzle[c]]), mSimdFP32Ty);
 213             }
 214         }
 215     }
 216
 217     void Quantize(SWR_FORMAT format, Value* src[4])
 218     {
 219         const SWR_FORMAT_INFO& info = GetFormatInfo(format);
 220         for (uint32_t c = 0; c < info.numComps; ++c)
 221         {
 222             if (info.bpc[c] <= QUANTIZE_THRESHOLD)
 223             {
 224                 uint32_t swizComp = info.swizzle[c];
 225                 float factor = (float)((1 << info.bpc[c]) - 1);
 226                 switch (info.type[c])
 227                 {
 228                 case SWR_TYPE_UNORM:
 229                     src[swizComp] = FADD(FMUL(src[swizComp], VIMMED1(factor)), VIMMED1(0.5f));
 230                     src[swizComp] = VROUND(src[swizComp], C(_MM_FROUND_TO_ZERO));
 231                     src[swizComp] = FMUL(src[swizComp], VIMMED1(1.0f /factor));
 232                     break;
 233                 default: SWR_ASSERT(false, "Unsupported format type: %d", info.type[c]);
 234                 }
 235             }
 236         }
 237     }
 238
 239     template<bool Color, bool Alpha>
 240     void BlendFunc(SWR_BLEND_OP blendOp, Value* src[4], Value* srcFactor[4], Value* dst[4], Value* dstFactor[4], Value* result[4])
 241     {
 242         Value* out[4];
 243         Value* srcBlend[4];
 244         Value* dstBlend[4];
 245         for (uint32_t i = 0; i < 4; ++i)
 246         {
 247             srcBlend[i] = FMUL(src[i], srcFactor[i]);
 248             dstBlend[i] = FMUL(dst[i], dstFactor[i]);
 249         }
 250
 251         switch (blendOp)
 252         {
 253         case BLENDOP_ADD:
 254             out[0] = FADD(srcBlend[0], dstBlend[0]);
 255             out[1] = FADD(srcBlend[1], dstBlend[1]);
 256             out[2] = FADD(srcBlend[2], dstBlend[2]);
 257             out[3] = FADD(srcBlend[3], dstBlend[3]);
 258             break;
 259
 260         case BLENDOP_SUBTRACT:
 261             out[0] = FSUB(srcBlend[0], dstBlend[0]);
 262             out[1] = FSUB(srcBlend[1], dstBlend[1]);
 263             out[2] = FSUB(srcBlend[2], dstBlend[2]);
 264             out[3] = FSUB(srcBlend[3], dstBlend[3]);
 265             break;
 266
 267         case BLENDOP_REVSUBTRACT:
 268             out[0] = FSUB(dstBlend[0], srcBlend[0]);
 269             out[1] = FSUB(dstBlend[1], srcBlend[1]);
 270             out[2] = FSUB(dstBlend[2], srcBlend[2]);
 271             out[3] = FSUB(dstBlend[3], srcBlend[3]);
 272             break;
 273
 274         case BLENDOP_MIN:
 275             out[0] = VMINPS(src[0], dst[0]);
 276             out[1] = VMINPS(src[1], dst[1]);
 277             out[2] = VMINPS(src[2], dst[2]);
 278             out[3] = VMINPS(src[3], dst[3]);
 279             break;
 280
 281         case BLENDOP_MAX:
 282             out[0] = VMAXPS(src[0], dst[0]);
 283             out[1] = VMAXPS(src[1], dst[1]);
 284             out[2] = VMAXPS(src[2], dst[2]);
 285             out[3] = VMAXPS(src[3], dst[3]);
 286             break;
 287
 288         default:
 289             SWR_ASSERT(false, "Unsupported blend operation: %d", blendOp);
 290             out[0] = out[1] = out[2] = out[3] = VIMMED1(0.0f);
 291             break;
 292         }
 293
 294         if (Color)
 295         {
 296             result[0] = out[0];
 297             result[1] = out[1];
 298             result[2] = out[2];
 299         }
 300
 301         if (Alpha)
 302         {
 303             result[3] = out[3];
 304         }
 305     }
 306
 307     void LogicOpFunc(SWR_LOGIC_OP logicOp, Value* src[4], Value* dst[4], Value* result[4])
 308     {
 309         // Op: (s == PS output, d = RT contents)
 310         switch(logicOp)
 311         {
 312         case LOGICOP_CLEAR:
 313             result[0] = VIMMED1(0);
 314             result[1] = VIMMED1(0);
 315             result[2] = VIMMED1(0);
 316             result[3] = VIMMED1(0);
 317             break;
 318
 319         case LOGICOP_NOR:
 320             // ~(s | d)
 321             result[0] = XOR(OR(src[0], dst[0]), VIMMED1(0xFFFFFFFF));
 322             result[1] = XOR(OR(src[1], dst[1]), VIMMED1(0xFFFFFFFF));
 323             result[2] = XOR(OR(src[2], dst[2]), VIMMED1(0xFFFFFFFF));
 324             result[3] = XOR(OR(src[3], dst[3]), VIMMED1(0xFFFFFFFF));
 325             break;
 326
 327         case LOGICOP_AND_INVERTED:
 328             // ~s & d
 329             // todo: use avx andnot instr when I can find the intrinsic to call
 330             result[0] = AND(XOR(src[0], VIMMED1(0xFFFFFFFF)), dst[0]);
 331             result[1] = AND(XOR(src[1], VIMMED1(0xFFFFFFFF)), dst[1]);
 332             result[2] = AND(XOR(src[2], VIMMED1(0xFFFFFFFF)), dst[2]);
 333             result[3] = AND(XOR(src[3], VIMMED1(0xFFFFFFFF)), dst[3]);
 334             break;
 335
 336         case LOGICOP_COPY_INVERTED:
 337             // ~s
 338             result[0] = XOR(src[0], VIMMED1(0xFFFFFFFF));
 339             result[1] = XOR(src[1], VIMMED1(0xFFFFFFFF));
 340             result[2] = XOR(src[2], VIMMED1(0xFFFFFFFF));
 341             result[3] = XOR(src[3], VIMMED1(0xFFFFFFFF));
 342             break;
 343
 344         case LOGICOP_AND_REVERSE:
 345             // s & ~d
 346             // todo: use avx andnot instr when I can find the intrinsic to call
 347             result[0] = AND(XOR(dst[0], VIMMED1(0xFFFFFFFF)), src[0]);
 348             result[1] = AND(XOR(dst[1], VIMMED1(0xFFFFFFFF)), src[1]);
 349             result[2] = AND(XOR(dst[2], VIMMED1(0xFFFFFFFF)), src[2]);
 350             result[3] = AND(XOR(dst[3], VIMMED1(0xFFFFFFFF)), src[3]);
 351             break;
 352
 353         case LOGICOP_INVERT:
 354             // ~d
 355             result[0] = XOR(dst[0], VIMMED1(0xFFFFFFFF));
 356             result[1] = XOR(dst[1], VIMMED1(0xFFFFFFFF));
 357             result[2] = XOR(dst[2], VIMMED1(0xFFFFFFFF));
 358             result[3] = XOR(dst[3], VIMMED1(0xFFFFFFFF));
 359             break;
 360
 361         case LOGICOP_XOR:
 362             // s ^ d
 363             result[0] = XOR(src[0], dst[0]);
 364             result[1] = XOR(src[1], dst[1]);
 365             result[2] = XOR(src[2], dst[2]);
 366             result[3] = XOR(src[3], dst[3]);
 367             break;
 368
 369         case LOGICOP_NAND:
 370             // ~(s & d)
 371             result[0] = XOR(AND(src[0], dst[0]), VIMMED1(0xFFFFFFFF));
 372             result[1] = XOR(AND(src[1], dst[1]), VIMMED1(0xFFFFFFFF));
 373             result[2] = XOR(AND(src[2], dst[2]), VIMMED1(0xFFFFFFFF));
 374             result[3] = XOR(AND(src[3], dst[3]), VIMMED1(0xFFFFFFFF));
 375             break;
 376
 377         case LOGICOP_AND:
 378             // s & d
 379             result[0] = AND(src[0], dst[0]);
 380             result[1] = AND(src[1], dst[1]);
 381             result[2] = AND(src[2], dst[2]);
 382             result[3] = AND(src[3], dst[3]);
 383             break;
 384
 385         case LOGICOP_EQUIV:
 386             // ~(s ^ d)
 387             result[0] = XOR(XOR(src[0], dst[0]), VIMMED1(0xFFFFFFFF));
 388             result[1] = XOR(XOR(src[1], dst[1]), VIMMED1(0xFFFFFFFF));
 389             result[2] = XOR(XOR(src[2], dst[2]), VIMMED1(0xFFFFFFFF));
 390             result[3] = XOR(XOR(src[3], dst[3]), VIMMED1(0xFFFFFFFF));
 391             break;
 392
 393         case LOGICOP_NOOP:
 394             result[0] = dst[0];
 395             result[1] = dst[1];
 396             result[2] = dst[2];
 397             result[3] = dst[3];
 398             break;
 399
 400         case LOGICOP_OR_INVERTED:
 401             // ~s | d
 402             result[0] = OR(XOR(src[0], VIMMED1(0xFFFFFFFF)), dst[0]);
 403             result[1] = OR(XOR(src[1], VIMMED1(0xFFFFFFFF)), dst[1]);
 404             result[2] = OR(XOR(src[2], VIMMED1(0xFFFFFFFF)), dst[2]);
 405             result[3] = OR(XOR(src[3], VIMMED1(0xFFFFFFFF)), dst[3]);
 406             break;
 407
 408         case LOGICOP_COPY:
 409             result[0] = src[0];
 410             result[1] = src[1];
 411             result[2] = src[2];
 412             result[3] = src[3];
 413             break;
 414
 415         case LOGICOP_OR_REVERSE:
 416             // s | ~d
 417             result[0] = OR(XOR(dst[0], VIMMED1(0xFFFFFFFF)), src[0]);
 418             result[1] = OR(XOR(dst[1], VIMMED1(0xFFFFFFFF)), src[1]);
 419             result[2] = OR(XOR(dst[2], VIMMED1(0xFFFFFFFF)), src[2]);
 420             result[3] = OR(XOR(dst[3], VIMMED1(0xFFFFFFFF)), src[3]);
 421             break;
 422
 423         case LOGICOP_OR:
 424             // s | d
 425             result[0] = OR(src[0], dst[0]);
 426             result[1] = OR(src[1], dst[1]);
 427             result[2] = OR(src[2], dst[2]);
 428             result[3] = OR(src[3], dst[3]);
 429             break;
 430
 431         case LOGICOP_SET:
 432             result[0] = VIMMED1(0xFFFFFFFF);
 433             result[1] = VIMMED1(0xFFFFFFFF);
 434             result[2] = VIMMED1(0xFFFFFFFF);
 435             result[3] = VIMMED1(0xFFFFFFFF);
 436             break;
 437
 438         default:
 439             SWR_ASSERT(false, "Unsupported logic operation: %d", logicOp);
 440             result[0] = result[1] = result[2] = result[3] = VIMMED1(0.0f);
 441             break;
 442         }
 443     }
 444
 445     void AlphaTest(const BLEND_COMPILE_STATE& state, Value* pBlendState, Value* pAlpha, Value* ppMask)
 446     {
 447         // load uint32_t reference
 448         Value* pRef = VBROADCAST(LOAD(pBlendState, { 0, SWR_BLEND_STATE_alphaTestReference }));
 449
 450         Value* pTest = nullptr;
 451         if (state.alphaTestFormat == ALPHA_TEST_UNORM8)
 452         {
 453             // convert float alpha to unorm8
 454             Value* pAlphaU8 = FMUL(pAlpha, VIMMED1(256.0f));
 455             pAlphaU8 = FP_TO_UI(pAlphaU8, mSimdInt32Ty);
 456
 457             // compare
 458             switch (state.alphaTestFunction)
 459             {
 460             case ZFUNC_ALWAYS:  pTest = VIMMED1(true); break;
 461             case ZFUNC_NEVER:   pTest = VIMMED1(false); break;
 462             case ZFUNC_LT:      pTest = ICMP_ULT(pAlphaU8, pRef); break;
 463             case ZFUNC_EQ:      pTest = ICMP_EQ(pAlphaU8, pRef); break;
 464             case ZFUNC_LE:      pTest = ICMP_ULE(pAlphaU8, pRef); break;
 465             case ZFUNC_GT:      pTest = ICMP_UGT(pAlphaU8, pRef); break;
 466             case ZFUNC_NE:      pTest = ICMP_NE(pAlphaU8, pRef); break;
 467             case ZFUNC_GE:      pTest = ICMP_UGE(pAlphaU8, pRef); break;
 468             default:
 469                 SWR_ASSERT(false, "Invalid alpha test function");
 470                 break;
 471             }
 472         }
 473         else
 474         {
 475             // cast ref to float
 476             pRef = BITCAST(pRef, mSimdFP32Ty);
 477
 478             // compare
 479             switch (state.alphaTestFunction)
 480             {
 481             case ZFUNC_ALWAYS:  pTest = VIMMED1(true); break;
 482             case ZFUNC_NEVER:   pTest = VIMMED1(false); break;
 483             case ZFUNC_LT:      pTest = FCMP_OLT(pAlpha, pRef); break;
 484             case ZFUNC_EQ:      pTest = FCMP_OEQ(pAlpha, pRef); break;
 485             case ZFUNC_LE:      pTest = FCMP_OLE(pAlpha, pRef); break;
 486             case ZFUNC_GT:      pTest = FCMP_OGT(pAlpha, pRef); break;
 487             case ZFUNC_NE:      pTest = FCMP_ONE(pAlpha, pRef); break;
 488             case ZFUNC_GE:      pTest = FCMP_OGE(pAlpha, pRef); break;
 489             default:
 490                 SWR_ASSERT(false, "Invalid alpha test function");
 491                 break;
 492             }
 493         }
 494
 495         // load current mask
 496         Value* pMask = LOAD(ppMask);
 497
 498         // convert to int1 mask
 499         pMask = MASK(pMask);
 500
 501         // and with alpha test result
 502         pMask = AND(pMask, pTest);
 503
 504         // convert back to vector mask
 505         pMask = VMASK(pMask);
 506
 507         // store new mask
 508         STORE(pMask, ppMask);
 509     }
 510
 511     Function* Create(const BLEND_COMPILE_STATE& state)
 512     {
 513         static std::size_t jitNum = 0;
 514
 515         std::stringstream fnName("BlendShader", std::ios_base::in | std::ios_base::out | std::ios_base::ate);
 516         fnName << jitNum++;
 517
 518         // blend function signature
 519         //typedef void(*PFN_BLEND_JIT_FUNC)(const SWR_BLEND_STATE*, simdvector&, simdvector&, uint32_t, BYTE*, simdvector&, simdscalari*, simdscalari*);
 520
 521         std::vector<Type*> args{
 522             PointerType::get(Gen_SWR_BLEND_STATE(JM()), 0), // SWR_BLEND_STATE*
 523             PointerType::get(mSimdFP32Ty, 0),               // simdvector& src
 524             PointerType::get(mSimdFP32Ty, 0),               // simdvector& src1
 525             Type::getInt32Ty(JM()->mContext),               // sampleNum
 526             PointerType::get(mSimdFP32Ty, 0),               // uint8_t* pDst
 527             PointerType::get(mSimdFP32Ty, 0),               // simdvector& result
 528             PointerType::get(mSimdInt32Ty, 0),              // simdscalari* oMask
 529             PointerType::get(mSimdInt32Ty, 0),              // simdscalari* pMask
 530         };
 531
 532         FunctionType* fTy = FunctionType::get(IRB()->getVoidTy(), args, false);
 533         Function* blendFunc = Function::Create(fTy, GlobalValue::ExternalLinkage, fnName.str(), JM()->mpCurrentModule);
 534
 535         BasicBlock* entry = BasicBlock::Create(JM()->mContext, "entry", blendFunc);
 536
 537         IRB()->SetInsertPoint(entry);
 538
 539         // arguments
 540         auto argitr = blendFunc->getArgumentList().begin();
 541         Value* pBlendState = &*argitr++;
 542         pBlendState->setName("pBlendState");
 543         Value* pSrc = &*argitr++;
 544         pSrc->setName("src");
 545         Value* pSrc1 = &*argitr++;
 546         pSrc1->setName("src1");
 547         Value* sampleNum = &*argitr++;
 548         sampleNum->setName("sampleNum");
 549         Value* pDst = &*argitr++;
 550         pDst->setName("pDst");
 551         Value* pResult = &*argitr++;
 552         pResult->setName("result");
 553         Value* ppoMask = &*argitr++;
 554         ppoMask->setName("ppoMask");
 555         Value* ppMask = &*argitr++;
 556         ppMask->setName("pMask");
 557
 558         static_assert(KNOB_COLOR_HOT_TILE_FORMAT == R32G32B32A32_FLOAT, "Unsupported hot tile format");
 559         Value* dst[4];
 560         Value* constantColor[4];
 561         Value* src[4];
 562         Value* src1[4];
 563         Value* result[4];
 564         for (uint32_t i = 0; i < 4; ++i)
 565         {
 566             // load hot tile
 567             dst[i] = LOAD(pDst, { i });
 568
 569             // load constant color
 570             constantColor[i] = VBROADCAST(LOAD(pBlendState, { 0, SWR_BLEND_STATE_constantColor, i }));
 571
 572             // load src
 573             src[i] = LOAD(pSrc, { i });
 574
 575             // load src1
 576             src1[i] = LOAD(pSrc1, { i });
 577         }
 578         Value* currentMask = VIMMED1(-1);
 579         if(state.desc.alphaToCoverageEnable)
 580         {
 581             currentMask = FP_TO_SI(FMUL(src[3], VBROADCAST(C((float)state.desc.numSamples))), mSimdInt32Ty);
 582         }
 583
 584         // alpha test
 585         if (state.desc.alphaTestEnable)
 586         {
 587             AlphaTest(state, pBlendState, src[3], ppMask);
 588         }
 589
 590         // color blend
 591         if (state.blendState.blendEnable)
 592         {
 593             // clamp sources
 594             Clamp(state.format, src);
 595             Clamp(state.format, src1);
 596             Clamp(state.format, dst);
 597             Clamp(state.format, constantColor);
 598
 599             // apply defaults to hottile contents to take into account missing components
 600             ApplyDefaults(state.format, dst);
 601
 602             // Force defaults for unused 'X' components
 603             ApplyUnusedDefaults(state.format, dst);
 604
 605             // Quantize low precision components
 606             Quantize(state.format, dst);
 607
 608             // special case clamping for R11G11B10_float which has no sign bit
 609             if (state.format == R11G11B10_FLOAT)
 610             {
 611                 dst[0] = VMAXPS(dst[0], VIMMED1(0.0f));
 612                 dst[1] = VMAXPS(dst[1], VIMMED1(0.0f));
 613                 dst[2] = VMAXPS(dst[2], VIMMED1(0.0f));
 614                 dst[3] = VMAXPS(dst[3], VIMMED1(0.0f));
 615             }
 616
 617             Value* srcFactor[4];
 618             Value* dstFactor[4];
 619             if (state.desc.independentAlphaBlendEnable)
 620             {
 621                 GenerateBlendFactor<true, false>(state.blendState.sourceBlendFactor, constantColor, src, src1, dst, srcFactor);
 622                 GenerateBlendFactor<false, true>(state.blendState.sourceAlphaBlendFactor, constantColor, src, src1, dst, srcFactor);
 623
 624                 GenerateBlendFactor<true, false>(state.blendState.destBlendFactor, constantColor, src, src1, dst, dstFactor);
 625                 GenerateBlendFactor<false, true>(state.blendState.destAlphaBlendFactor, constantColor, src, src1, dst, dstFactor);
 626
 627                 BlendFunc<true, false>(state.blendState.colorBlendFunc, src, srcFactor, dst, dstFactor, result);
 628                 BlendFunc<false, true>(state.blendState.alphaBlendFunc, src, srcFactor, dst, dstFactor, result);
 629             }
 630             else
 631             {
 632                 GenerateBlendFactor<true, true>(state.blendState.sourceBlendFactor, constantColor, src, src1, dst, srcFactor);
 633                 GenerateBlendFactor<true, true>(state.blendState.destBlendFactor, constantColor, src, src1, dst, dstFactor);
 634
 635                 BlendFunc<true, true>(state.blendState.colorBlendFunc, src, srcFactor, dst, dstFactor, result);
 636             }
 637
 638             // store results out
 639             for (uint32_t i = 0; i < 4; ++i)
 640             {
 641                 STORE(result[i], pResult, { i });
 642             }
 643         }
 644
 645         if(state.blendState.logicOpEnable)
 646         {
 647             const SWR_FORMAT_INFO& info = GetFormatInfo(state.format);
 648             SWR_ASSERT(info.type[0] == SWR_TYPE_UINT);
 649             Value* vMask[4];
 650             for(uint32_t i = 0; i < 4; i++)
 651             {
 652                 switch(info.bpc[i])
 653                 {
 654                 case 0: vMask[i] = VIMMED1(0x00000000); break;
 655                 case 2: vMask[i] = VIMMED1(0x00000003); break;
 656                 case 5: vMask[i] = VIMMED1(0x0000001F); break;
 657                 case 6: vMask[i] = VIMMED1(0x0000003F); break;
 658                 case 8: vMask[i] = VIMMED1(0x000000FF); break;
 659                 case 10: vMask[i] = VIMMED1(0x000003FF); break;
 660                 case 11: vMask[i] = VIMMED1(0x000007FF); break;
 661                 case 16: vMask[i] = VIMMED1(0x0000FFFF); break;
 662                 case 24: vMask[i] = VIMMED1(0x00FFFFFF); break;
 663                 case 32: vMask[i] = VIMMED1(0xFFFFFFFF); break;
 664                 default:
 665                     vMask[i] = VIMMED1(0x0);
 666                     SWR_ASSERT(0, "Unsupported bpc for logic op\n");
 667                     break;
 668                 }
 669                 src[i] = BITCAST(src[i], mSimdInt32Ty);//, vMask[i]);
 670                 dst[i] = BITCAST(dst[i], mSimdInt32Ty);
 671             }
 672
 673             LogicOpFunc(state.blendState.logicOpFunc, src, dst, result);
 674
 675             // store results out
 676             for(uint32_t i = 0; i < 4; ++i)
 677             {
 678                 // clear upper bits from PS output not in RT format after doing logic op
 679                 result[i] = AND(result[i], vMask[i]);
 680
 681                 STORE(BITCAST(result[i], mSimdFP32Ty), pResult, {i});
 682             }
 683         }
 684
 685         if(state.desc.oMaskEnable)
 686         {
 687             assert(!(state.desc.alphaToCoverageEnable));
 688             // load current mask
 689             Value* oMask = LOAD(ppoMask);
 690             Value* sampleMasked = VBROADCAST(SHL(C(1), sampleNum));
 691             oMask = AND(oMask, sampleMasked);
 692             currentMask = AND(oMask, currentMask);
 693         }
 694
 695         if(state.desc.sampleMaskEnable)
 696         {
 697             Value* sampleMask = LOAD(pBlendState, { 0, SWR_BLEND_STATE_sampleMask});
 698             Value* sampleMasked = SHL(C(1), sampleNum);
 699             sampleMask = AND(sampleMask, sampleMasked);
 700             sampleMask = VBROADCAST(ICMP_SGT(sampleMask, C(0)));
 701             sampleMask = S_EXT(sampleMask, mSimdInt32Ty);
 702             currentMask = AND(sampleMask, currentMask);
 703         }
 704
 705         if(state.desc.sampleMaskEnable || state.desc.alphaToCoverageEnable ||
 706            state.desc.oMaskEnable)
 707         {
 708             // load current mask
 709             Value* pMask = LOAD(ppMask);
 710             currentMask = S_EXT(ICMP_SGT(currentMask, VBROADCAST(C(0))), mSimdInt32Ty);
 711             Value* outputMask = AND(pMask, currentMask);
 712             // store new mask
 713             STORE(outputMask, GEP(ppMask, C(0)));
 714         }
 715
 716         RET_VOID();
 717
 718         JitManager::DumpToFile(blendFunc, "");
 719
 720         FunctionPassManager passes(JM()->mpCurrentModule);
 721         passes.add(createBreakCriticalEdgesPass());
 722         passes.add(createCFGSimplificationPass());
 723         passes.add(createEarlyCSEPass());
 724         passes.add(createPromoteMemoryToRegisterPass());
 725         passes.add(createCFGSimplificationPass());
 726         passes.add(createEarlyCSEPass());
 727         passes.add(createInstructionCombiningPass());
 728         passes.add(createInstructionSimplifierPass());
 729         passes.add(createConstantPropagationPass());
 730         passes.add(createSCCPPass());
 731         passes.add(createAggressiveDCEPass());
 732
 733         passes.run(*blendFunc);
 734
 735         JitManager::DumpToFile(blendFunc, "optimized");
 736
 737         return blendFunc;
 738     }
 739 };
 740
 741 //////////////////////////////////////////////////////////////////////////
 742 /// @brief JITs from fetch shader IR
 743 /// @param hJitMgr - JitManager handle
 744 /// @param func   - LLVM function IR
 745 /// @return PFN_FETCH_FUNC - pointer to fetch code
 746 PFN_BLEND_JIT_FUNC JitBlendFunc(HANDLE hJitMgr, const HANDLE hFunc)
 747 {
 748     const llvm::Function *func = (const llvm::Function*)hFunc;
 749     JitManager* pJitMgr = reinterpret_cast<JitManager*>(hJitMgr);
 750     PFN_BLEND_JIT_FUNC pfnBlend;
 751     pfnBlend = (PFN_BLEND_JIT_FUNC)(pJitMgr->mpExec->getFunctionAddress(func->getName().str()));
 752     // MCJIT finalizes modules the first time you JIT code from them. After finalized, you cannot add new IR to the module
 753     pJitMgr->mIsModuleFinalized = true;
 754
 755     return pfnBlend;
 756 }
 757
 758 //////////////////////////////////////////////////////////////////////////
 759 /// @brief JIT compiles blend shader
 760 /// @param hJitMgr - JitManager handle
 761 /// @param state   - blend state to build function from
 762 extern "C" PFN_BLEND_JIT_FUNC JITCALL JitCompileBlend(HANDLE hJitMgr, const BLEND_COMPILE_STATE& state)
 763 {
 764     JitManager* pJitMgr = reinterpret_cast<JitManager*>(hJitMgr);
 765
 766     pJitMgr->SetupNewModule();
 767
 768     BlendJit theJit(pJitMgr);
 769     HANDLE hFunc = theJit.Create(state);
 770
 771     return JitBlendFunc(hJitMgr, hFunc);
 772 }