|
10 | 10 | #include "slang-glsl-extension-tracker.h" |
11 | 11 | #include "slang-ir-lower-buffer-element-type.h" |
12 | 12 | #include "slang-ir-layout.h" |
| 13 | +#include "slang-ir-util.h" |
13 | 14 |
|
14 | 15 | namespace Slang |
15 | 16 | { |
@@ -52,6 +53,36 @@ struct SPIRVLegalizationContext : public SourceEmitterBase |
52 | 53 | { |
53 | 54 | } |
54 | 55 |
|
| 56 | + // Wraps the element type of a constant buffer or parameter block in a struct if it is not already a struct, |
| 57 | + // returns the newly created struct type. |
| 58 | + IRType* wrapConstantBufferElement(IRInst* cbParamInst) |
| 59 | + { |
| 60 | + auto innerType = as<IRParameterGroupType>(cbParamInst->getDataType())->getElementType(); |
| 61 | + IRBuilder builder(cbParamInst); |
| 62 | + builder.setInsertBefore(cbParamInst); |
| 63 | + auto structType = builder.createStructType(); |
| 64 | + StringBuilder sb; |
| 65 | + sb << "cbuffer_"; |
| 66 | + getTypeNameHint(sb, innerType); |
| 67 | + sb << "_t"; |
| 68 | + builder.addNameHintDecoration(structType, sb.produceString().getUnownedSlice()); |
| 69 | + auto key = builder.createStructKey(); |
| 70 | + builder.createStructField(structType, key, innerType); |
| 71 | + builder.setInsertBefore(cbParamInst); |
| 72 | + auto newCbType = builder.getType(cbParamInst->getDataType()->getOp(), structType); |
| 73 | + cbParamInst->setFullType(newCbType); |
| 74 | + auto rules = getTypeLayoutRuleForBuffer(m_sharedContext->m_targetRequest, cbParamInst->getDataType()); |
| 75 | + IRSizeAndAlignment sizeAlignment; |
| 76 | + getSizeAndAlignment(rules, structType, &sizeAlignment); |
| 77 | + traverseUses(cbParamInst, [&](IRUse* use) |
| 78 | + { |
| 79 | + builder.setInsertBefore(use->getUser()); |
| 80 | + auto addr = builder.emitFieldAddress(builder.getPtrType(kIROp_PtrType, innerType, SpvStorageClassUniform), cbParamInst, key); |
| 81 | + use->set(addr); |
| 82 | + }); |
| 83 | + return structType; |
| 84 | + } |
| 85 | + |
55 | 86 | void processGlobalParam(IRGlobalParam* inst) |
56 | 87 | { |
57 | 88 | // If the global param is not a pointer type, make it so and insert explicit load insts. |
@@ -86,34 +117,45 @@ struct SPIRVLegalizationContext : public SourceEmitterBase |
86 | 117 | } |
87 | 118 |
|
88 | 119 | // Strip any HLSL wrappers |
| 120 | + IRBuilder builder(m_sharedContext->m_irModule); |
| 121 | + bool needLoad = true; |
89 | 122 | auto innerType = inst->getFullType(); |
90 | | - if(const auto constantBufferType = as<IRConstantBufferType>(innerType)) |
91 | | - { |
92 | | - innerType = constantBufferType->getElementType(); |
93 | | - storageClass = SpvStorageClassUniform; |
94 | | - } |
95 | | - else if (auto paramBlockType = as<IRParameterBlockType>(innerType)) |
| 123 | + if (as<IRConstantBufferType>(innerType) || as<IRParameterBlockType>(innerType)) |
96 | 124 | { |
97 | | - innerType = paramBlockType->getElementType(); |
| 125 | + innerType = as<IRUniformParameterGroupType>(innerType)->getElementType(); |
98 | 126 | storageClass = SpvStorageClassUniform; |
| 127 | + // Constant buffer is already treated like a pointer type, and |
| 128 | + // we are not adding another layer of indirection when replacing it |
| 129 | + // with a pointer type. Therefore we don't need to insert a load at |
| 130 | + // use sites. |
| 131 | + needLoad = false; |
| 132 | + // If inner element type is not a struct type, we need to wrap it with |
| 133 | + // a struct. |
| 134 | + if (!as<IRStructType>(innerType)) |
| 135 | + { |
| 136 | + innerType = wrapConstantBufferElement(inst); |
| 137 | + } |
| 138 | + builder.addDecoration(innerType, kIROp_SPIRVBlockDecoration); |
99 | 139 | } |
100 | 140 |
|
101 | 141 | // Make a pointer type of storageClass. |
102 | | - IRBuilder builder(m_sharedContext->m_irModule); |
103 | 142 | builder.setInsertBefore(inst); |
104 | 143 | ptrType = builder.getPtrType(kIROp_PtrType, innerType, storageClass); |
105 | 144 | inst->setFullType(ptrType); |
106 | | - // Insert an explicit load at each use site. |
107 | | - List<IRUse*> uses; |
108 | | - for (auto use = inst->firstUse; use; use = use->nextUse) |
109 | | - { |
110 | | - uses.add(use); |
111 | | - } |
112 | | - for (auto use : uses) |
| 145 | + if (needLoad) |
113 | 146 | { |
114 | | - builder.setInsertBefore(use->getUser()); |
115 | | - auto loadedValue = builder.emitLoad(inst); |
116 | | - use->set(loadedValue); |
| 147 | + // Insert an explicit load at each use site. |
| 148 | + List<IRUse*> uses; |
| 149 | + for (auto use = inst->firstUse; use; use = use->nextUse) |
| 150 | + { |
| 151 | + uses.add(use); |
| 152 | + } |
| 153 | + for (auto use : uses) |
| 154 | + { |
| 155 | + builder.setInsertBefore(use->getUser()); |
| 156 | + auto loadedValue = builder.emitLoad(inst); |
| 157 | + use->set(loadedValue); |
| 158 | + } |
117 | 159 | } |
118 | 160 | } |
119 | 161 | processGlobalVar(inst); |
@@ -206,22 +248,37 @@ struct SPIRVLegalizationContext : public SourceEmitterBase |
206 | 248 | } |
207 | 249 | } |
208 | 250 |
|
209 | | - // Replace getElement(x, i) with, y = store(x); p = getElementPtr(y, i); load(p) |
210 | | - // SPIR-V has no support for dynamic indexing into values like we do. |
| 251 | + Dictionary<IRInst*, IRInst*> m_mapArrayValueToVar; |
| 252 | + |
| 253 | + // Replace getElement(x, i) with, y = store(x); p = getElementPtr(y, i); load(p), |
| 254 | + // when i is not a constant. SPIR-V has no support for dynamic indexing into values like we do. |
211 | 255 | // It may be advantageous however to do this further up the pipeline |
212 | 256 | void processGetElement(IRGetElement* inst) |
213 | 257 | { |
214 | | - const auto x = inst->getBase(); |
| 258 | + IRInst* x = nullptr; |
215 | 259 | List<IRInst*> indices; |
216 | 260 | IRGetElement* c = inst; |
217 | 261 | do |
218 | 262 | { |
| 263 | + if (as<IRIntLit>(c->getIndex())) |
| 264 | + break; |
| 265 | + x = c->getBase(); |
219 | 266 | indices.add(c->getIndex()); |
220 | 267 | } while(c = as<IRGetElement>(c->getBase()), c); |
| 268 | + |
| 269 | + if (!x) |
| 270 | + return; |
| 271 | + |
221 | 272 | IRBuilder builder(m_sharedContext->m_irModule); |
| 273 | + IRInst* y = nullptr; |
| 274 | + if (!m_mapArrayValueToVar.tryGetValue(x, y)) |
| 275 | + { |
| 276 | + setInsertAfterOrdinaryInst(&builder, x); |
| 277 | + y = builder.emitVar(x->getDataType(), SpvStorageClassFunction); |
| 278 | + builder.emitStore(y, x); |
| 279 | + m_mapArrayValueToVar.set(x, y); |
| 280 | + } |
222 | 281 | builder.setInsertBefore(inst); |
223 | | - IRInst* y = builder.emitVar(x->getDataType(), SpvStorageClassFunction); |
224 | | - builder.emitStore(y, x); |
225 | 282 | for(Index i = indices.getCount() - 1; i >= 0; --i) |
226 | 283 | y = builder.emitElementAddress(y, indices[i]); |
227 | 284 | const auto newInst = builder.emitLoad(y); |
@@ -367,7 +424,7 @@ struct SPIRVLegalizationContext : public SourceEmitterBase |
367 | 424 | break; |
368 | 425 | } |
369 | 426 | builder.addNameHintDecoration(structType, nameSb.getUnownedSlice()); |
370 | | - builder.addDecoration(structType, kIROp_SPIRVBufferBlockDecoration); |
| 427 | + builder.addDecoration(structType, kIROp_SPIRVBlockDecoration); |
371 | 428 | inst->replaceUsesWith(ptrType); |
372 | 429 | inst->removeAndDeallocate(); |
373 | 430 | addUsersToWorkList(ptrType); |
|
0 commit comments