src/gallium/drivers/swr/rasterizer/jitter/builder_mem.h

   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 builder_misc.h
  24  *
  25  * @brief miscellaneous builder functions
  26  *
  27  * Notes:
  28  *
  29  ******************************************************************************/
  30 #pragma once
  31
  32 public:
  33 enum class MEM_CLIENT
  34 {
  35     MEM_CLIENT_INTERNAL,
  36     GFX_MEM_CLIENT_FETCH,
  37     GFX_MEM_CLIENT_SAMPLER,
  38     GFX_MEM_CLIENT_SHADER,
  39     GFX_MEM_CLIENT_STREAMOUT
  40 };
  41
  42 protected:
  43 virtual Value* OFFSET_TO_NEXT_COMPONENT(Value* base, Constant* offset);
  44 void           AssertMemoryUsageParams(Value* ptr, MEM_CLIENT usage);
  45
  46 public:
  47 virtual Value* GEP(Value* Ptr, Value* Idx, Type* Ty = nullptr, const Twine& Name = "");
  48 virtual Value* GEP(Type* Ty, Value* Ptr, Value* Idx, const Twine& Name = "");
  49 virtual Value* GEP(Value* ptr, const std::initializer_list<Value*>& indexList, Type* Ty = nullptr);
  50 virtual Value*
  51 GEP(Value* ptr, const std::initializer_list<uint32_t>& indexList, Type* Ty = nullptr);
  52
  53 Value* GEPA(Value* Ptr, ArrayRef<Value*> IdxList, const Twine& Name = "");
  54 Value* GEPA(Type* Ty, Value* Ptr, ArrayRef<Value*> IdxList, const Twine& Name = "");
  55
  56 Value* IN_BOUNDS_GEP(Value* ptr, const std::initializer_list<Value*>& indexList);
  57 Value* IN_BOUNDS_GEP(Value* ptr, const std::initializer_list<uint32_t>& indexList);
  58
  59 virtual LoadInst*
  60                   LOAD(Value* Ptr, const char* Name, Type* Ty = nullptr, MEM_CLIENT usage = MEM_CLIENT::MEM_CLIENT_INTERNAL);
  61 virtual LoadInst* LOAD(Value*         Ptr,
  62                        const Twine&   Name  = "",
  63                        Type*          Ty    = nullptr,
  64                        MEM_CLIENT usage = MEM_CLIENT::MEM_CLIENT_INTERNAL);
  65 virtual LoadInst*
  66                   LOAD(Type* Ty, Value* Ptr, const Twine& Name = "", MEM_CLIENT usage = MEM_CLIENT::MEM_CLIENT_INTERNAL);
  67 virtual LoadInst* LOAD(Value*         Ptr,
  68                        bool           isVolatile,
  69                        const Twine&   Name  = "",
  70                        Type*          Ty    = nullptr,
  71                        MEM_CLIENT     usage = MEM_CLIENT::MEM_CLIENT_INTERNAL);
  72 virtual LoadInst* LOAD(Value*                                 BasePtr,
  73                        const std::initializer_list<uint32_t>& offset,
  74                        const llvm::Twine&                     Name  = "",
  75                        Type*                                  Ty    = nullptr,
  76                        MEM_CLIENT                             usage = MEM_CLIENT::MEM_CLIENT_INTERNAL);
  77
  78 virtual CallInst* MASKED_LOAD(Value*         Ptr,
  79                               unsigned       Align,
  80                               Value*         Mask,
  81                               Value*         PassThru = nullptr,
  82                               const Twine&   Name     = "",
  83                               Type*          Ty       = nullptr,
  84                               MEM_CLIENT usage    = MEM_CLIENT::MEM_CLIENT_INTERNAL)
  85 {
  86     return IRB()->CreateMaskedLoad(Ptr, Align, Mask, PassThru, Name);
  87 }
  88
  89 virtual StoreInst* STORE(Value *Val, Value *Ptr, bool isVolatile = false, Type* Ty = nullptr, MEM_CLIENT usage = MEM_CLIENT::MEM_CLIENT_INTERNAL)
  90 {
  91     return IRB()->CreateStore(Val, Ptr, isVolatile);
  92 }
  93
  94 virtual StoreInst* STORE(Value* Val, Value* BasePtr, const std::initializer_list<uint32_t>& offset, Type* Ty = nullptr, MEM_CLIENT usage = MEM_CLIENT::MEM_CLIENT_INTERNAL);
  95
  96 virtual CallInst* MASKED_STORE(Value *Val, Value *Ptr, unsigned Align, Value *Mask, Type* Ty = nullptr, MEM_CLIENT usage = MEM_CLIENT::MEM_CLIENT_INTERNAL)
  97 {
  98     return IRB()->CreateMaskedStore(Val, Ptr, Align, Mask);
  99 }
 100
 101 LoadInst*  LOADV(Value* BasePtr, const std::initializer_list<Value*>& offset, const llvm::Twine& name = "");
 102 StoreInst* STOREV(Value* Val, Value* BasePtr, const std::initializer_list<Value*>& offset);
 103
 104 Value* MEM_ADD(Value*                                 i32Incr,
 105                Value*                                 basePtr,
 106                const std::initializer_list<uint32_t>& indices,
 107                const llvm::Twine&                     name = "");
 108
 109 void Gather4(const SWR_FORMAT format,
 110              Value*           pSrcBase,
 111              Value*           byteOffsets,
 112              Value*           mask,
 113              Value*           vGatherComponents[],
 114              bool             bPackedOutput,
 115              MEM_CLIENT       usage = MEM_CLIENT::MEM_CLIENT_INTERNAL);
 116
 117 virtual Value* GATHERPS(Value*         src,
 118                         Value*         pBase,
 119                         Value*         indices,
 120                         Value*         mask,
 121                         uint8_t        scale = 1,
 122                         MEM_CLIENT     usage = MEM_CLIENT::MEM_CLIENT_INTERNAL);
 123
 124 void GATHER4PS(const SWR_FORMAT_INFO& info,
 125                Value*                 pSrcBase,
 126                Value*                 byteOffsets,
 127                Value*                 mask,
 128                Value*                 vGatherComponents[],
 129                bool                   bPackedOutput,
 130                MEM_CLIENT             usage = MEM_CLIENT::MEM_CLIENT_INTERNAL);
 131
 132 virtual Value* GATHERDD(Value*         src,
 133                         Value*         pBase,
 134                         Value*         indices,
 135                         Value*         mask,
 136                         uint8_t        scale = 1,
 137                         MEM_CLIENT     usage = MEM_CLIENT::MEM_CLIENT_INTERNAL);
 138
 139 void GATHER4DD(const SWR_FORMAT_INFO& info,
 140                Value*                 pSrcBase,
 141                Value*                 byteOffsets,
 142                Value*                 mask,
 143                Value*                 vGatherComponents[],
 144                bool                   bPackedOutput,
 145                MEM_CLIENT             usage = MEM_CLIENT::MEM_CLIENT_INTERNAL);
 146
 147 Value* GATHERPD(Value* src, Value* pBase, Value* indices, Value* mask, uint8_t scale = 1);
 148
 149 Value* GATHER_PTR(Value* pVecSrcPtr, Value* pVecMask, Value* pVecPassthru);
 150
 151 virtual void SCATTERPS(Value*         pDst,
 152                        Value*         vSrc,
 153                        Value*         vOffsets,
 154                        Value*         vMask,
 155                        MEM_CLIENT     usage = MEM_CLIENT::MEM_CLIENT_INTERNAL);
 156
 157 void Shuffle8bpcGather4(const SWR_FORMAT_INFO& info,
 158                         Value*                 vGatherInput,
 159                         Value*                 vGatherOutput[],
 160                         bool                   bPackedOutput);
 161 void Shuffle16bpcGather4(const SWR_FORMAT_INFO& info,
 162                          Value*                 vGatherInput[],
 163                          Value*                 vGatherOutput[],
 164                          bool                   bPackedOutput);
 165
 166 // Static stack allocations for scatter operations
 167 Value* pScatterStackSrc{nullptr};
 168 Value* pScatterStackOffsets{nullptr};