LLVM 22.0.0git
DXILResource.h
Go to the documentation of this file.
1//===- DXILResource.h - Representations of DXIL resources -------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9#ifndef LLVM_ANALYSIS_DXILRESOURCE_H
10#define LLVM_ANALYSIS_DXILRESOURCE_H
11
12#include "llvm/ADT/MapVector.h"
14#include "llvm/ADT/StringRef.h"
18#include "llvm/IR/PassManager.h"
19#include "llvm/Pass.h"
23#include <cstdint>
24
25namespace llvm {
26class CallInst;
27class DataLayout;
28class LLVMContext;
29class MDTuple;
30class Value;
31
33
34namespace dxil {
35
36// Returns the resource name from dx_resource_handlefrombinding or
37// dx_resource_handlefromimplicitbinding call
38LLVM_ABI StringRef getResourceNameFromBindingCall(CallInst *CI);
39
40/// The dx.RawBuffer target extension type
41///
42/// `target("dx.RawBuffer", Type, IsWriteable, IsROV)`
43class RawBufferExtType : public TargetExtType {
44public:
45 RawBufferExtType() = delete;
48
49 bool isStructured() const {
50 // TODO: We need to be more prescriptive here, but since there's some debate
51 // over whether byte address buffer should have a void type or an i8 type,
52 // accept either for now.
53 Type *Ty = getTypeParameter(0);
54 return !Ty->isVoidTy() && !Ty->isIntegerTy(8);
55 }
56
58 return isStructured() ? getTypeParameter(0) : nullptr;
59 }
60 bool isWriteable() const { return getIntParameter(0); }
61 bool isROV() const { return getIntParameter(1); }
62
63 static bool classof(const TargetExtType *T) {
64 return T->getName() == "dx.RawBuffer";
65 }
66 static bool classof(const Type *T) {
68 }
69};
70
71/// The dx.TypedBuffer target extension type
72///
73/// `target("dx.TypedBuffer", Type, IsWriteable, IsROV, IsSigned)`
74class TypedBufferExtType : public TargetExtType {
75public:
79
80 Type *getResourceType() const { return getTypeParameter(0); }
81 bool isWriteable() const { return getIntParameter(0); }
82 bool isROV() const { return getIntParameter(1); }
83 bool isSigned() const { return getIntParameter(2); }
84
85 static bool classof(const TargetExtType *T) {
86 return T->getName() == "dx.TypedBuffer";
87 }
88 static bool classof(const Type *T) {
90 }
91};
92
93/// The dx.Texture target extension type
94///
95/// `target("dx.Texture", Type, IsWriteable, IsROV, IsSigned, Dimension)`
96class TextureExtType : public TargetExtType {
97public:
98 TextureExtType() = delete;
99 TextureExtType(const TextureExtType &) = delete;
101
102 Type *getResourceType() const { return getTypeParameter(0); }
103 bool isWriteable() const { return getIntParameter(0); }
104 bool isROV() const { return getIntParameter(1); }
105 bool isSigned() const { return getIntParameter(2); }
107 return static_cast<dxil::ResourceKind>(getIntParameter(3));
108 }
109
110 static bool classof(const TargetExtType *T) {
111 return T->getName() == "dx.Texture";
112 }
113 static bool classof(const Type *T) {
115 }
116};
117
118/// The dx.MSTexture target extension type
119///
120/// `target("dx.MSTexture", Type, IsWriteable, Samples, IsSigned, Dimension)`
121class MSTextureExtType : public TargetExtType {
122public:
126
127 Type *getResourceType() const { return getTypeParameter(0); }
128 bool isWriteable() const { return getIntParameter(0); }
130 bool isSigned() const { return getIntParameter(2); }
132 return static_cast<dxil::ResourceKind>(getIntParameter(3));
133 }
134
135 static bool classof(const TargetExtType *T) {
136 return T->getName() == "dx.MSTexture";
137 }
138 static bool classof(const Type *T) {
140 }
141};
142
143/// The dx.FeedbackTexture target extension type
144///
145/// `target("dx.FeedbackTexture", FeedbackType, Dimension)`
146class FeedbackTextureExtType : public TargetExtType {
147public:
151
156 return static_cast<dxil::ResourceKind>(getIntParameter(1));
157 }
158
159 static bool classof(const TargetExtType *T) {
160 return T->getName() == "dx.FeedbackTexture";
161 }
162 static bool classof(const Type *T) {
164 }
165};
166
167/// The dx.CBuffer target extension type
168///
169/// `target("dx.CBuffer", <Type>, ...)`
170class CBufferExtType : public TargetExtType {
171public:
172 CBufferExtType() = delete;
175
176 Type *getResourceType() const { return getTypeParameter(0); }
177
178 static bool classof(const TargetExtType *T) {
179 return T->getName() == "dx.CBuffer";
180 }
181 static bool classof(const Type *T) {
183 }
184};
185
186/// The dx.Sampler target extension type
187///
188/// `target("dx.Sampler", SamplerType)`
189class SamplerExtType : public TargetExtType {
190public:
191 SamplerExtType() = delete;
194
196 return static_cast<dxil::SamplerType>(getIntParameter(0));
197 }
198
199 static bool classof(const TargetExtType *T) {
200 return T->getName() == "dx.Sampler";
201 }
202 static bool classof(const Type *T) {
204 }
205};
206
207class AnyResourceExtType : public TargetExtType {
208public:
212
219
220 static bool classof(const Type *T) {
222 }
223};
224
225/// The dx.Layout target extension type
226///
227/// `target("dx.Layout", <Type>, <size>, [offsets...])`
228class LayoutExtType : public TargetExtType {
229public:
230 LayoutExtType() = delete;
231 LayoutExtType(const LayoutExtType &) = delete;
233
234 Type *getWrappedType() const { return getTypeParameter(0); }
235 uint32_t getSize() const { return getIntParameter(0); }
236 uint32_t getOffsetOfElement(int I) const { return getIntParameter(I + 1); }
237
238 static bool classof(const TargetExtType *T) {
239 return T->getName() == "dx.Layout";
240 }
241 static bool classof(const Type *T) {
243 }
244};
245
246/// The dx.Padding target extension type
247///
248/// `target("dx.Padding", NumBytes)`
249class PaddingExtType : public TargetExtType {
250public:
251 PaddingExtType() = delete;
254
255 unsigned getNumBytes() const { return getIntParameter(0); }
256
257 static bool classof(const TargetExtType *T) {
258 return T->getName() == "dx.Padding";
259 }
260 static bool classof(const Type *T) {
262 }
263};
264
265//===----------------------------------------------------------------------===//
266
268public:
269 struct UAVInfo {
270 bool IsROV;
271
272 bool operator==(const UAVInfo &RHS) const { return IsROV == RHS.IsROV; }
273 bool operator!=(const UAVInfo &RHS) const { return !(*this == RHS); }
274 bool operator<(const UAVInfo &RHS) const { return IsROV < RHS.IsROV; }
275 };
276
277 struct StructInfo {
279 // Note: we store an integer here rather than using `MaybeAlign` because in
280 // GCC 7 MaybeAlign isn't trivial so having one in this union would delete
281 // our move constructor.
282 // See https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p0602r4.html
284
285 bool operator==(const StructInfo &RHS) const {
286 return std::tie(Stride, AlignLog2) == std::tie(RHS.Stride, RHS.AlignLog2);
287 }
288 bool operator!=(const StructInfo &RHS) const { return !(*this == RHS); }
289 bool operator<(const StructInfo &RHS) const {
290 return std::tie(Stride, AlignLog2) < std::tie(RHS.Stride, RHS.AlignLog2);
291 }
292 };
293
294 struct TypedInfo {
297
298 bool operator==(const TypedInfo &RHS) const {
299 return std::tie(ElementTy, ElementCount) ==
300 std::tie(RHS.ElementTy, RHS.ElementCount);
301 }
302 bool operator!=(const TypedInfo &RHS) const { return !(*this == RHS); }
303 bool operator<(const TypedInfo &RHS) const {
304 return std::tie(ElementTy, ElementCount) <
305 std::tie(RHS.ElementTy, RHS.ElementCount);
306 }
307 };
308
309private:
310 TargetExtType *HandleTy;
311
314
315public:
317 const dxil::ResourceClass RC,
318 const dxil::ResourceKind Kind);
321
322 TargetExtType *getHandleTy() const { return HandleTy; }
324
325 // Conditions to check before accessing specific views.
326 LLVM_ABI bool isUAV() const;
327 LLVM_ABI bool isCBuffer() const;
328 LLVM_ABI bool isSampler() const;
329 LLVM_ABI bool isStruct() const;
330 LLVM_ABI bool isTyped() const;
331 LLVM_ABI bool isFeedback() const;
332 LLVM_ABI bool isMultiSample() const;
333
334 // Views into the type.
335 LLVM_ABI UAVInfo getUAV() const;
338 LLVM_ABI StructInfo getStruct(const DataLayout &DL) const;
339 LLVM_ABI TypedInfo getTyped() const;
342
344 dxil::ResourceKind getResourceKind() const { return Kind; }
345
346 LLVM_ABI bool operator==(const ResourceTypeInfo &RHS) const;
347 bool operator!=(const ResourceTypeInfo &RHS) const { return !(*this == RHS); }
348 LLVM_ABI bool operator<(const ResourceTypeInfo &RHS) const;
349
350 LLVM_ABI void print(raw_ostream &OS, const DataLayout &DL) const;
351};
352
353//===----------------------------------------------------------------------===//
354
361
363public:
369
370 bool operator==(const ResourceBinding &RHS) const {
371 return std::tie(RecordID, Space, LowerBound, Size) ==
372 std::tie(RHS.RecordID, RHS.Space, RHS.LowerBound, RHS.Size);
373 }
374 bool operator!=(const ResourceBinding &RHS) const {
375 return !(*this == RHS);
376 }
377 bool operator<(const ResourceBinding &RHS) const {
378 return std::tie(RecordID, Space, LowerBound, Size) <
379 std::tie(RHS.RecordID, RHS.Space, RHS.LowerBound, RHS.Size);
380 }
381 bool overlapsWith(const ResourceBinding &RHS) const {
382 if (Space != RHS.Space)
383 return false;
384 if (Size == UINT32_MAX)
385 return LowerBound < RHS.LowerBound;
386 return LowerBound + Size - 1 >= RHS.LowerBound;
387 }
388 };
389
390private:
391 ResourceBinding Binding;
392 TargetExtType *HandleTy;
393 StringRef Name;
394 GlobalVariable *Symbol = nullptr;
395
396public:
397 bool GloballyCoherent = false;
399
400 ResourceInfo(uint32_t RecordID, uint32_t Space, uint32_t LowerBound,
401 uint32_t Size, TargetExtType *HandleTy, StringRef Name = "",
402 GlobalVariable *Symbol = nullptr)
403 : Binding{RecordID, Space, LowerBound, Size}, HandleTy(HandleTy),
404 Name(Name), Symbol(Symbol) {}
405
406 void setBindingID(unsigned ID) { Binding.RecordID = ID; }
407
411
412 const ResourceBinding &getBinding() const { return Binding; }
413 TargetExtType *getHandleTy() const { return HandleTy; }
414 StringRef getName() const { return Name; }
415
416 bool hasSymbol() const { return Symbol; }
419
420 LLVM_ABI std::pair<uint32_t, uint32_t>
422
423 bool operator==(const ResourceInfo &RHS) const {
424 return std::tie(Binding, HandleTy, Symbol, Name) ==
425 std::tie(RHS.Binding, RHS.HandleTy, RHS.Symbol, RHS.Name);
426 }
427 bool operator!=(const ResourceInfo &RHS) const { return !(*this == RHS); }
428 bool operator<(const ResourceInfo &RHS) const {
429 return Binding < RHS.Binding;
430 }
431
433 const DataLayout &DL) const;
434};
435
436} // namespace dxil
437
438//===----------------------------------------------------------------------===//
439
442
443public:
444 LLVM_ABI bool invalidate(Module &M, const PreservedAnalyses &PA,
445 ModuleAnalysisManager::Invalidator &Inv);
446
448 auto It = Infos.find(Ty);
449 if (It != Infos.end())
450 return It->second;
451 auto [NewIt, Inserted] = Infos.try_emplace(Ty, Ty);
452 return NewIt->second;
453 }
454};
455
457 : public AnalysisInfoMixin<DXILResourceTypeAnalysis> {
459
460 LLVM_ABI static AnalysisKey Key;
461
462public:
464
466 // Running the pass just generates an empty map, which will be filled when
467 // users of the pass query the results.
468 return Result();
469 }
470};
471
474
475 virtual void anchor();
476
477public:
478 static char ID;
480
482 const DXILResourceTypeMap &getResourceTypeMap() const { return DRTM; }
483};
484
486
487//===----------------------------------------------------------------------===//
488
490 using CallMapTy = DenseMap<CallInst *, unsigned>;
491
493 CallMapTy CallMap;
494 unsigned FirstUAV = 0;
495 unsigned FirstCBuffer = 0;
496 unsigned FirstSampler = 0;
497 bool HasInvalidDirection = false;
498
499 /// Populate all the resource instance data.
500 void populate(Module &M, DXILResourceTypeMap &DRTM);
501 /// Populate the map given the resource binding calls in the given module.
502 void populateResourceInfos(Module &M, DXILResourceTypeMap &DRTM);
503 /// Analyze and populate the directions of the resource counters.
504 void populateCounterDirections(Module &M);
505
506 /// Resolves a resource handle into a vector of ResourceInfos that
507 /// represent the possible unique creations of the handle. Certain cases are
508 /// ambiguous so multiple creation instructions may be returned. The resulting
509 /// ResourceInfo can be used to depuplicate unique handles that
510 /// reference the same resource
512
513public:
516
517 iterator begin() { return Infos.begin(); }
518 const_iterator begin() const { return Infos.begin(); }
519 iterator end() { return Infos.end(); }
520 const_iterator end() const { return Infos.end(); }
521
522 bool empty() const { return Infos.empty(); }
523
525 auto Pos = CallMap.find(Key);
526 return Pos == CallMap.end() ? Infos.end() : (Infos.begin() + Pos->second);
527 }
528
530 auto Pos = CallMap.find(Key);
531 return Pos == CallMap.end() ? Infos.end() : (Infos.begin() + Pos->second);
532 }
533
534 iterator srv_begin() { return begin(); }
535 const_iterator srv_begin() const { return begin(); }
536 iterator srv_end() { return begin() + FirstUAV; }
537 const_iterator srv_end() const { return begin() + FirstUAV; }
542
543 iterator uav_begin() { return begin() + FirstUAV; }
544 const_iterator uav_begin() const { return begin() + FirstUAV; }
545 iterator uav_end() { return begin() + FirstCBuffer; }
546 const_iterator uav_end() const { return begin() + FirstCBuffer; }
551
552 iterator cbuffer_begin() { return begin() + FirstCBuffer; }
553 const_iterator cbuffer_begin() const { return begin() + FirstCBuffer; }
554 iterator cbuffer_end() { return begin() + FirstSampler; }
555 const_iterator cbuffer_end() const { return begin() + FirstSampler; }
562
563 iterator sampler_begin() { return begin() + FirstSampler; }
564 const_iterator sampler_begin() const { return begin() + FirstSampler; }
565 iterator sampler_end() { return end(); }
566 const_iterator sampler_end() const { return end(); }
573
575 : iterator_adaptor_base<call_iterator, CallMapTy::iterator> {
576 call_iterator() = default;
579
580 CallInst *operator*() const { return I->first; }
581 };
582
583 call_iterator call_begin() { return call_iterator(CallMap.begin()); }
584 call_iterator call_end() { return call_iterator(CallMap.end()); }
588
589 bool hasInvalidCounterDirection() const { return HasInvalidDirection; }
590
592 const DataLayout &DL) const;
593
596};
597
598class DXILResourceAnalysis : public AnalysisInfoMixin<DXILResourceAnalysis> {
600
601 LLVM_ABI static AnalysisKey Key;
602
603public:
605
606 /// Gather resource info for the module \c M.
608};
609
610/// Printer pass for the \c DXILResourceAnalysis results.
611class DXILResourcePrinterPass : public PassInfoMixin<DXILResourcePrinterPass> {
612 raw_ostream &OS;
613
614public:
615 explicit DXILResourcePrinterPass(raw_ostream &OS) : OS(OS) {}
616
618
619 static bool isRequired() { return true; }
620};
621
623 std::unique_ptr<DXILResourceMap> Map;
625
626public:
627 static char ID; // Class identification, replacement for typeinfo
628
631
632 const DXILResourceMap &getResourceMap() const { return *Map; }
633 DXILResourceMap &getResourceMap() { return *Map; }
634
635 void getAnalysisUsage(AnalysisUsage &AU) const override;
636 bool runOnModule(Module &M) override;
637 void releaseMemory() override;
638
639 void print(raw_ostream &OS, const Module *M) const override;
640 void dump() const;
641};
642
644
645//===----------------------------------------------------------------------===//
646
647// DXILResourceBindingInfo stores the results of DXILResourceBindingAnalysis
648// which analyses all llvm.dx.resource.handlefrombinding calls in the module
649// and puts together lists of used virtual register spaces and available
650// virtual register slot ranges for each binding type.
651// It also stores additional information found during the analysis such as
652// whether the module uses implicit bindings or if any of the bindings overlap.
653//
654// This information will be used in DXILResourceImplicitBindings pass to assign
655// register slots to resources with implicit bindings, and in a
656// post-optimization validation pass that will raise diagnostic about
657// overlapping bindings.
659 hlsl::BindingInfo Bindings;
660 bool HasImplicitBinding = false;
661 bool HasOverlappingBinding = false;
662
663 // Populate the resource binding info given explicit resource binding calls
664 // in the module.
665 void populate(Module &M, DXILResourceTypeMap &DRTM);
666
667public:
668 bool hasImplicitBinding() const { return HasImplicitBinding; }
669 void setHasImplicitBinding(bool Value) { HasImplicitBinding = Value; }
670 bool hasOverlappingBinding() const { return HasOverlappingBinding; }
671 void setHasOverlappingBinding(bool Value) { HasOverlappingBinding = Value; }
672
673 std::optional<uint32_t> findAvailableBinding(dxil::ResourceClass RC,
674 uint32_t Space, int32_t Size) {
675 return Bindings.findAvailableBinding(RC, Space, Size);
676 }
677
680};
681
683 : public AnalysisInfoMixin<DXILResourceBindingAnalysis> {
685
686 LLVM_ABI static AnalysisKey Key;
687
688public:
690
692};
693
695 std::unique_ptr<DXILResourceBindingInfo> BindingInfo;
696
697public:
698 static char ID;
699
702
703 DXILResourceBindingInfo &getBindingInfo() { return *BindingInfo; }
704 const DXILResourceBindingInfo &getBindingInfo() const { return *BindingInfo; }
705
706 void getAnalysisUsage(AnalysisUsage &AU) const override;
707 bool runOnModule(Module &M) override;
708 void releaseMemory() override;
709};
710
712
713} // namespace llvm
714
715#endif // LLVM_ANALYSIS_DXILRESOURCE_H
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
static void print(raw_ostream &Out, object::Archive::Kind Kind, T Val)
#define LLVM_ABI
Definition Compiler.h:213
DXIL Resource Implicit Binding
This header defines various interfaces for pass management in LLVM.
#define I(x, y, z)
Definition MD5.cpp:58
This file implements a map that provides insertion order iteration.
#define T
This file defines the SmallVector class.
Value * RHS
Represent the analysis usage information of a pass.
This class represents a function call, abstracting a target machine's calling convention.
LLVM_ABI DXILResourceMap run(Module &M, ModuleAnalysisManager &AM)
Gather resource info for the module M.
DXILResourceBindingInfo Result
LLVM_ABI DXILResourceBindingInfo run(Module &M, ModuleAnalysisManager &AM)
friend class DXILResourceBindingWrapperPass
void setHasImplicitBinding(bool Value)
std::optional< uint32_t > findAvailableBinding(dxil::ResourceClass RC, uint32_t Space, int32_t Size)
friend class DXILResourceBindingAnalysis
void setHasOverlappingBinding(bool Value)
const DXILResourceBindingInfo & getBindingInfo() const
DXILResourceBindingInfo & getBindingInfo()
const_iterator sampler_end() const
iterator find(const CallInst *Key)
bool hasInvalidCounterDirection() const
const_iterator find(const CallInst *Key) const
iterator_range< iterator > samplers()
iterator_range< const_iterator > uavs() const
friend class DXILResourceAnalysis
const_iterator cbuffer_end() const
iterator_range< const_iterator > srvs() const
call_iterator call_begin()
const_iterator uav_begin() const
const_iterator begin() const
iterator_range< const_iterator > samplers() const
LLVM_ABI void print(raw_ostream &OS, DXILResourceTypeMap &DRTM, const DataLayout &DL) const
call_iterator call_end()
const_iterator srv_begin() const
iterator_range< iterator > srvs()
iterator_range< iterator > cbuffers()
iterator_range< iterator > uavs()
iterator_range< call_iterator > calls()
const_iterator uav_end() const
const_iterator sampler_begin() const
SmallVector< dxil::ResourceInfo >::iterator iterator
friend class DXILResourceWrapperPass
const_iterator cbuffer_begin() const
const_iterator srv_end() const
iterator_range< const_iterator > cbuffers() const
SmallVector< dxil::ResourceInfo >::const_iterator const_iterator
const_iterator end() const
DXILResourcePrinterPass(raw_ostream &OS)
LLVM_ABI PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM)
DXILResourceTypeMap run(Module &M, ModuleAnalysisManager &AM)
dxil::ResourceTypeInfo & operator[](TargetExtType *Ty)
LLVM_ABI bool invalidate(Module &M, const PreservedAnalyses &PA, ModuleAnalysisManager::Invalidator &Inv)
DXILResourceTypeMap & getResourceTypeMap()
const DXILResourceTypeMap & getResourceTypeMap() const
DXILResourceMap & getResourceMap()
const DXILResourceMap & getResourceMap() const
A parsed version of the target data layout string in and methods for querying it.
Definition DataLayout.h:63
DenseMapIterator< KeyT, ValueT, KeyInfoT, BucketT > iterator
Definition DenseMap.h:74
ImmutablePass(char &pid)
Definition Pass.h:287
This is an important class for using LLVM in a threaded context.
Definition LLVMContext.h:68
Tuple of metadata.
Definition Metadata.h:1497
ModulePass class - This class is used to implement unstructured interprocedural optimizations and ana...
Definition Pass.h:255
ModulePass(char &pid)
Definition Pass.h:257
A Module instance is used to store all the information related to an LLVM module.
Definition Module.h:67
A set of analyses that are preserved following a run of a transformation pass.
Definition Analysis.h:112
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
StringRef - Represent a constant reference to a string, i.e.
Definition StringRef.h:55
Class to represent struct types.
Class to represent target extensions types, which are generally unintrospectable from target-independ...
Type * getTypeParameter(unsigned i) const
unsigned getIntParameter(unsigned i) const
Type(LLVMContext &C, TypeID tid)
Definition Type.h:93
LLVM Value Representation.
Definition Value.h:75
static bool classof(const Type *T)
AnyResourceExtType & operator=(const AnyResourceExtType &)=delete
static bool classof(const TargetExtType *T)
AnyResourceExtType(const AnyResourceExtType &)=delete
static bool classof(const TargetExtType *T)
CBufferExtType & operator=(const CBufferExtType &)=delete
CBufferExtType(const CBufferExtType &)=delete
static bool classof(const Type *T)
Type * getResourceType() const
dxil::SamplerFeedbackType getFeedbackType() const
FeedbackTextureExtType(const FeedbackTextureExtType &)=delete
dxil::ResourceKind getDimension() const
FeedbackTextureExtType & operator=(const FeedbackTextureExtType &)=delete
static bool classof(const TargetExtType *T)
static bool classof(const Type *T)
static bool classof(const Type *T)
LayoutExtType(const LayoutExtType &)=delete
uint32_t getSize() const
LayoutExtType & operator=(const LayoutExtType &)=delete
static bool classof(const TargetExtType *T)
uint32_t getOffsetOfElement(int I) const
Type * getWrappedType() const
dxil::ResourceKind getDimension() const
MSTextureExtType(const MSTextureExtType &)=delete
static bool classof(const TargetExtType *T)
uint32_t getSampleCount() const
static bool classof(const Type *T)
MSTextureExtType & operator=(const MSTextureExtType &)=delete
static bool classof(const TargetExtType *T)
PaddingExtType & operator=(const PaddingExtType &)=delete
PaddingExtType(const PaddingExtType &)=delete
unsigned getNumBytes() const
static bool classof(const Type *T)
static bool classof(const TargetExtType *T)
RawBufferExtType(const RawBufferExtType &)=delete
static bool classof(const Type *T)
RawBufferExtType & operator=(const RawBufferExtType &)=delete
StringRef getName() const
bool operator<(const ResourceInfo &RHS) const
bool operator!=(const ResourceInfo &RHS) const
TargetExtType * getHandleTy() const
LLVM_ABI std::pair< uint32_t, uint32_t > getAnnotateProps(Module &M, dxil::ResourceTypeInfo &RTI) const
LLVM_ABI void print(raw_ostream &OS, dxil::ResourceTypeInfo &RTI, const DataLayout &DL) const
ResourceInfo(uint32_t RecordID, uint32_t Space, uint32_t LowerBound, uint32_t Size, TargetExtType *HandleTy, StringRef Name="", GlobalVariable *Symbol=nullptr)
void setBindingID(unsigned ID)
bool operator==(const ResourceInfo &RHS) const
const ResourceBinding & getBinding() const
LLVM_ABI GlobalVariable * createSymbol(Module &M, StructType *Ty)
LLVM_ABI MDTuple * getAsMetadata(Module &M, dxil::ResourceTypeInfo &RTI) const
ResourceCounterDirection CounterDirection
dxil::ResourceClass getResourceClass() const
LLVM_ABI uint32_t getMultiSampleCount() const
LLVM_ABI uint32_t getCBufferSize(const DataLayout &DL) const
LLVM_ABI bool operator<(const ResourceTypeInfo &RHS) const
LLVM_ABI bool isUAV() const
LLVM_ABI bool isMultiSample() const
LLVM_ABI bool isSampler() const
LLVM_ABI bool isTyped() const
LLVM_ABI dxil::SamplerType getSamplerType() const
LLVM_ABI ResourceTypeInfo(TargetExtType *HandleTy, const dxil::ResourceClass RC, const dxil::ResourceKind Kind)
LLVM_ABI bool isCBuffer() const
LLVM_ABI TypedInfo getTyped() const
bool operator!=(const ResourceTypeInfo &RHS) const
LLVM_ABI StructType * createElementStruct(StringRef CBufferName="")
TargetExtType * getHandleTy() const
LLVM_ABI bool isFeedback() const
ResourceTypeInfo(TargetExtType *HandleTy)
LLVM_ABI UAVInfo getUAV() const
LLVM_ABI StructInfo getStruct(const DataLayout &DL) const
LLVM_ABI bool isStruct() const
LLVM_ABI dxil::SamplerFeedbackType getFeedbackType() const
LLVM_ABI bool operator==(const ResourceTypeInfo &RHS) const
dxil::ResourceKind getResourceKind() const
LLVM_ABI void print(raw_ostream &OS, const DataLayout &DL) const
SamplerExtType(const SamplerExtType &)=delete
static bool classof(const Type *T)
dxil::SamplerType getSamplerType() const
SamplerExtType & operator=(const SamplerExtType &)=delete
static bool classof(const TargetExtType *T)
static bool classof(const TargetExtType *T)
dxil::ResourceKind getDimension() const
Type * getResourceType() const
TextureExtType & operator=(const TextureExtType &)=delete
TextureExtType(const TextureExtType &)=delete
static bool classof(const Type *T)
TypedBufferExtType & operator=(const TypedBufferExtType &)=delete
static bool classof(const TargetExtType *T)
TypedBufferExtType(const TypedBufferExtType &)=delete
static bool classof(const Type *T)
BindingInfo represents the ranges of bindings and free space for each dxil::ResourceClass.
Definition HLSLBinding.h:46
A range adaptor for a pair of iterators.
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition raw_ostream.h:53
unsigned ID
LLVM IR allows to use arbitrary numbers as calling convention identifiers.
Definition CallingConv.h:24
ResourceKind
The kind of resource for an SRV or UAV resource.
Definition DXILABI.h:36
SamplerFeedbackType
Definition DXILABI.h:96
ElementType
The element type of an SRV or UAV resource.
Definition DXILABI.h:60
LLVM_ABI StringRef getResourceNameFromBindingCall(CallInst *CI)
This is an optimization pass for GlobalISel generic memory operations.
void dump(const SparseBitVector< ElementSize > &LHS, raw_ostream &out)
LLVM_ABI ModulePass * createDXILResourceBindingWrapperPassPass()
iterator_range< T > make_range(T x, T y)
Convenience function for iterating over sub-ranges.
LLVM_ABI ModulePass * createDXILResourceTypeWrapperPassPass()
bool isa(const From &Val)
isa<X> - Return true if the parameter to the template is an instance of one of the template type argu...
Definition Casting.h:547
LLVM_ATTRIBUTE_VISIBILITY_DEFAULT AnalysisKey InnerAnalysisManagerProxy< AnalysisManagerT, IRUnitT, ExtraArgTs... >::Key
OutputIt move(R &&Range, OutputIt Out)
Provide wrappers to std::move which take ranges instead of having to pass begin/end explicitly.
Definition STLExtras.h:1867
decltype(auto) cast(const From &Val)
cast<X> - Return the argument parameter cast to the specified type.
Definition Casting.h:559
LLVM_ABI ModulePass * createDXILResourceWrapperPassPass()
AnalysisManager< Module > ModuleAnalysisManager
Convenience typedef for the Module analysis manager.
Definition MIRParser.h:39
Implement std::hash so that hash_code can be used in STL containers.
Definition BitVector.h:867
A CRTP mix-in that provides informational APIs needed for analysis passes.
Definition PassManager.h:93
A special type used by analysis passes to provide an address that identifies that particular analysis...
Definition Analysis.h:29
call_iterator(CallMapTy::iterator Iter)
A CRTP mix-in to automatically provide informational APIs needed for passes.
Definition PassManager.h:70
bool operator!=(const ResourceBinding &RHS) const
bool operator==(const ResourceBinding &RHS) const
bool overlapsWith(const ResourceBinding &RHS) const
bool operator<(const ResourceBinding &RHS) const
bool operator==(const StructInfo &RHS) const
bool operator!=(const StructInfo &RHS) const
bool operator<(const StructInfo &RHS) const
bool operator<(const TypedInfo &RHS) const
bool operator==(const TypedInfo &RHS) const
bool operator!=(const TypedInfo &RHS) const
bool operator!=(const UAVInfo &RHS) const
bool operator==(const UAVInfo &RHS) const
bool operator<(const UAVInfo &RHS) const