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

   1 /****************************************************************************
   2  * Copyright (C) 2014-2018 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_gfx_mem.h
  24  *
  25  * @brief Definition of the builder to support different translation types for gfx memory access
  26  *
  27  * Notes:
  28  *
  29  ******************************************************************************/
  30 #pragma once
  31
  32 #include "builder.h"
  33
  34 namespace SwrJit
  35 {
  36     using namespace llvm;
  37
  38     class BuilderGfxMem : public Builder
  39     {
  40     public:
  41         BuilderGfxMem(JitManager* pJitMgr);
  42         virtual ~BuilderGfxMem() {}
  43
  44         virtual Value* GEP(Value* Ptr, Value* Idx, Type* Ty = nullptr, const Twine& Name = "");
  45         virtual Value* GEP(Type* Ty, Value* Ptr, Value* Idx, const Twine& Name = "");
  46         virtual Value*
  47         GEP(Value* Ptr, const std::initializer_list<Value*>& indexList, Type* Ty = nullptr);
  48         virtual Value*
  49         GEP(Value* Ptr, const std::initializer_list<uint32_t>& indexList, Type* Ty = nullptr);
  50
  51         virtual LoadInst* LOAD(Value*         Ptr,
  52                                const char*    Name,
  53                                Type*          Ty    = nullptr,
  54                                JIT_MEM_CLIENT usage = JIT_MEM_CLIENT::MEM_CLIENT_INTERNAL);
  55         virtual LoadInst* LOAD(Value*         Ptr,
  56                                const Twine&   Name  = "",
  57                                Type*          Ty    = nullptr,
  58                                JIT_MEM_CLIENT usage = JIT_MEM_CLIENT::MEM_CLIENT_INTERNAL);
  59         virtual LoadInst* LOAD(Value*         Ptr,
  60                                bool           isVolatile,
  61                                const Twine&   Name  = "",
  62                                Type*          Ty    = nullptr,
  63                                JIT_MEM_CLIENT usage = JIT_MEM_CLIENT::MEM_CLIENT_INTERNAL);
  64         virtual LoadInst* LOAD(Value*                                 BasePtr,
  65                                const std::initializer_list<uint32_t>& offset,
  66                                const llvm::Twine&                     Name  = "",
  67                                Type*                                  Ty    = nullptr,
  68                                JIT_MEM_CLIENT                         usage = JIT_MEM_CLIENT::MEM_CLIENT_INTERNAL);
  69
  70
  71         virtual CallInst* MASKED_LOAD(Value*         Ptr,
  72                                       unsigned       Align,
  73                                       Value*         Mask,
  74                                       Value*         PassThru = nullptr,
  75                                       const Twine&   Name     = "",
  76                                       Type*          Ty       = nullptr,
  77                                       JIT_MEM_CLIENT usage    = JIT_MEM_CLIENT::MEM_CLIENT_INTERNAL);
  78
  79         virtual StoreInst* STORE(Value *Val, Value *Ptr, bool isVolatile = false, Type* Ty = nullptr, JIT_MEM_CLIENT usage = JIT_MEM_CLIENT::MEM_CLIENT_INTERNAL);
  80
  81         virtual StoreInst* STORE(Value* Val, Value* BasePtr, const std::initializer_list<uint32_t>& offset, Type* Ty = nullptr, JIT_MEM_CLIENT usage = JIT_MEM_CLIENT::MEM_CLIENT_INTERNAL);
  82
  83         virtual CallInst* MASKED_STORE(Value *Val, Value *Ptr, unsigned Align, Value *Mask, Type* Ty = nullptr, JIT_MEM_CLIENT usage = JIT_MEM_CLIENT::MEM_CLIENT_INTERNAL);
  84
  85         virtual Value* GATHERPS(Value*         src,
  86                                 Value*         pBase,
  87                                 Value*         indices,
  88                                 Value*         mask,
  89                                 uint8_t        scale = 1,
  90                                 JIT_MEM_CLIENT usage = JIT_MEM_CLIENT::MEM_CLIENT_INTERNAL);
  91         virtual Value* GATHERDD(Value*         src,
  92                                 Value*         pBase,
  93                                 Value*         indices,
  94                                 Value*         mask,
  95                                 uint8_t        scale = 1,
  96                                 JIT_MEM_CLIENT usage = JIT_MEM_CLIENT::MEM_CLIENT_INTERNAL);
  97
  98         virtual void SCATTERPS(Value*         pDst,
  99                                Value*         vSrc,
 100                                Value*         vOffsets,
 101                                Value*         vMask,
 102                                JIT_MEM_CLIENT usage = JIT_MEM_CLIENT::MEM_CLIENT_INTERNAL);
 103
 104
 105         Value* TranslateGfxAddressForRead(Value*         xpGfxAddress,
 106                                           Type*          PtrTy = nullptr,
 107                                           const Twine&   Name  = "",
 108                                           JIT_MEM_CLIENT usage = JIT_MEM_CLIENT::MEM_CLIENT_INTERNAL);
 109         Value* TranslateGfxAddressForWrite(Value*         xpGfxAddress,
 110                                            Type*          PtrTy = nullptr,
 111                                            const Twine&   Name  = "",
 112                                            JIT_MEM_CLIENT usage = JIT_MEM_CLIENT::MEM_CLIENT_INTERNAL);
 113
 114
 115     protected:
 116         void AssertGFXMemoryParams(Value* ptr, Builder::JIT_MEM_CLIENT usage);
 117
 118         virtual void NotifyPrivateContextSet();
 119
 120         virtual Value* OFFSET_TO_NEXT_COMPONENT(Value* base, Constant* offset);
 121
 122         Value* TranslationHelper(Value* Ptr, Type* Ty);
 123         void   TrackerHelper(Value* Ptr, Type* Ty, JIT_MEM_CLIENT usage, bool isRead);
 124
 125
 126         FunctionType* GetTranslationFunctionType() { return mpTranslationFuncTy; }
 127         Value*        GetTranslationFunctionForRead() { return mpfnTranslateGfxAddressForRead; }
 128         Value*        GetTranslationFunctionForWrite() { return mpfnTranslateGfxAddressForWrite; }
 129         Value*        GetParamSimDC() { return mpParamSimDC; }
 130
 131
 132         Value*        mpWorkerData;
 133
 134     private:
 135         FunctionType* mpTranslationFuncTy;
 136         Value*        mpfnTranslateGfxAddressForRead;
 137         Value*        mpfnTranslateGfxAddressForWrite;
 138         Value*        mpParamSimDC;
 139         FunctionType* mpTrackMemAccessFuncTy;
 140         Value*        mpfnTrackMemAccess;
 141     };
 142 } // namespace SwrJit