swr: [rasterizer jitter] vpermps support
[mesa.git] / src / gallium / drivers / swr / rasterizer / jitter / builder_misc.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 Constant *C(bool i);
33 Constant *C(char i);
34 Constant *C(uint8_t i);
35 Constant *C(int i);
36 Constant *C(int64_t i);
37 Constant *C(uint16_t i);
38 Constant *C(uint32_t i);
39 Constant *C(float i);
40
41 template<typename Ty>
42 Constant *C(const std::initializer_list<Ty> &constList)
43 {
44 std::vector<Constant*> vConsts;
45 for(auto i : constList) {
46
47 vConsts.push_back(C((Ty)i));
48 }
49 return ConstantVector::get(vConsts);
50 }
51
52 Constant *PRED(bool pred);
53 Value *VIMMED1(int i);
54 Value *VIMMED1(uint32_t i);
55 Value *VIMMED1(float i);
56 Value *VIMMED1(bool i);
57 Value *VUNDEF(Type* t);
58 Value *VUNDEF_F();
59 Value *VUNDEF_I();
60 Value *VUNDEF(Type* ty, uint32_t size);
61 Value *VUNDEF_IPTR();
62 #if LLVM_VERSION_MAJOR == 3 && LLVM_VERSION_MINOR == 6
63 Value *VINSERT(Value *vec, Value *val, uint64_t index);
64 #endif
65 Value *VBROADCAST(Value *src);
66 Value *VRCP(Value *va);
67 Value *VPLANEPS(Value* vA, Value* vB, Value* vC, Value* &vX, Value* &vY);
68
69 uint32_t IMMED(Value* i);
70
71 Value *GEP(Value* ptr, const std::initializer_list<Value*> &indexList);
72 Value *GEP(Value* ptr, const std::initializer_list<uint32_t> &indexList);
73 CallInst *CALL(Value *Callee, const std::initializer_list<Value*> &args);
74
75 LoadInst *LOAD(Value *BasePtr, const std::initializer_list<uint32_t> &offset, const llvm::Twine& name = "");
76 LoadInst *LOADV(Value *BasePtr, const std::initializer_list<Value*> &offset, const llvm::Twine& name = "");
77 StoreInst *STORE(Value *Val, Value *BasePtr, const std::initializer_list<uint32_t> &offset);
78 StoreInst *STOREV(Value *Val, Value *BasePtr, const std::initializer_list<Value*> &offset);
79
80 Value *VCMPPS_EQ(Value* a, Value* b) { return VCMPPS(a, b, C((uint8_t)_CMP_EQ_OQ)); }
81 Value *VCMPPS_LT(Value* a, Value* b) { return VCMPPS(a, b, C((uint8_t)_CMP_LT_OQ)); }
82 Value *VCMPPS_LE(Value* a, Value* b) { return VCMPPS(a, b, C((uint8_t)_CMP_LE_OQ)); }
83 Value *VCMPPS_ISNAN(Value* a, Value* b) { return VCMPPS(a, b, C((uint8_t)_CMP_UNORD_Q)); }
84 Value *VCMPPS_NEQ(Value* a, Value* b) { return VCMPPS(a, b, C((uint8_t)_CMP_NEQ_OQ)); }
85 Value *VCMPPS_GE(Value* a, Value* b) { return VCMPPS(a, b, C((uint8_t)_CMP_GE_OQ)); }
86 Value *VCMPPS_GT(Value* a, Value* b) { return VCMPPS(a, b, C((uint8_t)_CMP_GT_OQ)); }
87 Value *VCMPPS_NOTNAN(Value* a, Value* b){ return VCMPPS(a, b, C((uint8_t)_CMP_ORD_Q)); }
88
89 Value *MASK(Value* vmask);
90 Value *VMASK(Value* mask);
91
92 //////////////////////////////////////////////////////////////////////////
93 /// @brief functions that build IR to call x86 intrinsics directly, or
94 /// emulate them with other instructions if not available on the host
95 //////////////////////////////////////////////////////////////////////////
96 Value *MASKLOADD(Value* src, Value* mask);
97
98 void Gather4(const SWR_FORMAT format, Value* pSrcBase, Value* byteOffsets,
99 Value* mask, Value* vGatherComponents[], bool bPackedOutput);
100
101 Value *GATHERPS(Value* src, Value* pBase, Value* indices, Value* mask, Value* scale);
102 void GATHER4PS(const SWR_FORMAT_INFO &info, Value* pSrcBase, Value* byteOffsets,
103 Value* mask, Value* vGatherComponents[], bool bPackedOutput);
104
105 Value *GATHERDD(Value* src, Value* pBase, Value* indices, Value* mask, Value* scale);
106 void GATHER4DD(const SWR_FORMAT_INFO &info, Value* pSrcBase, Value* byteOffsets,
107 Value* mask, Value* vGatherComponents[], bool bPackedOutput);
108
109 void SCATTERPS(Value* pDst, Value* vSrc, Value* vOffsets, Value* vMask);
110
111 void Shuffle8bpcGather4(const SWR_FORMAT_INFO &info, Value* vGatherInput, Value* vGatherOutput[], bool bPackedOutput);
112 void Shuffle16bpcGather4(const SWR_FORMAT_INFO &info, Value* vGatherInput[], Value* vGatherOutput[], bool bPackedOutput);
113
114 Value *PSHUFB(Value* a, Value* b);
115 Value *PMOVSXBD(Value* a);
116 Value *PMOVSXWD(Value* a);
117 Value *PERMD(Value* a, Value* idx);
118 Value *PERMPS(Value* a, Value* idx);
119 Value *CVTPH2PS(Value* a);
120 Value *CVTPS2PH(Value* a, Value* rounding);
121 Value *PMAXSD(Value* a, Value* b);
122 Value *PMINSD(Value* a, Value* b);
123 Value *VABSPS(Value* a);
124 Value *FMADDPS(Value* a, Value* b, Value* c);
125
126 // LLVM removed VPCMPGTD x86 intrinsic. This emulates that behavior
127 Value *VPCMPGTD(Value* a, Value* b)
128 {
129 Value* vIndexMask = ICMP_UGT(a,b);
130
131 // need to set the high bit for x86 intrinsic masks
132 return S_EXT(vIndexMask,VectorType::get(mInt32Ty,JM()->mVWidth));
133 }
134
135 Value *ICLAMP(Value* src, Value* low, Value* high);
136 Value *FCLAMP(Value* src, Value* low, Value* high);
137 Value *FCLAMP(Value* src, float low, float high);
138
139 CallInst *PRINT(const std::string &printStr);
140 CallInst *PRINT(const std::string &printStr,const std::initializer_list<Value*> &printArgs);
141 Value* STACKSAVE();
142 void STACKRESTORE(Value* pSaved);
143
144 Value* POPCNT(Value* a);
145
146 Value* INT3() { return INTERRUPT(C((uint8_t)3)); }
147
148
149 Value *VEXTRACTI128(Value* a, Constant* imm8);
150 Value *VINSERTI128(Value* a, Value* b, Constant* imm8);
151
152 // rdtsc buckets macros
153 void RDTSC_START(Value* pBucketMgr, Value* pId);
154 void RDTSC_STOP(Value* pBucketMgr, Value* pId);