1
2//===-- llvm/BinaryFormat/DXContainer.cpp - DXContainer Utils ----*- C++-*-===//
3//
4// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
5// See https://llvm.org/LICENSE.txt for license information.
6// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7//
8//===----------------------------------------------------------------------===//
9//
10// This file contains utility functions for working with DXContainers.
11//
12//===----------------------------------------------------------------------===//
13
14#include "llvm/BinaryFormat/DXContainer.h"
15#include "llvm/ADT/StringSwitch.h"
16#include "llvm/Support/ScopedPrinter.h"
17
18using namespace llvm;
19using namespace llvm::dxbc;
20
21#define ROOT_PARAMETER(Val, Enum) \
22 case Val: \
23 return true;
24bool llvm::dxbc::isValidParameterType(uint32_t V) {
25 switch (V) {
26#include "llvm/BinaryFormat/DXContainerConstants.def"
27 }
28 return false;
29}
30
31bool llvm::dxbc::isValidRangeType(uint32_t V) {
32 return V <= llvm::to_underlying(E: dxil::ResourceClass::LastEntry);
33}
34
35#define SHADER_VISIBILITY(Val, Enum) \
36 case Val: \
37 return true;
38bool llvm::dxbc::isValidShaderVisibility(uint32_t V) {
39 switch (V) {
40#include "llvm/BinaryFormat/DXContainerConstants.def"
41 }
42 return false;
43}
44
45#define FILTER(Val, Enum) \
46 case Val: \
47 return true;
48bool llvm::dxbc::isValidSamplerFilter(uint32_t V) {
49 switch (V) {
50#include "llvm/BinaryFormat/DXContainerConstants.def"
51 }
52 return false;
53}
54
55#define TEXTURE_ADDRESS_MODE(Val, Enum) \
56 case Val: \
57 return true;
58bool llvm::dxbc::isValidAddress(uint32_t V) {
59 switch (V) {
60#include "llvm/BinaryFormat/DXContainerConstants.def"
61 }
62 return false;
63}
64
65#define COMPARISON_FUNC(Val, Enum) \
66 case Val: \
67 return true;
68bool llvm::dxbc::isValidComparisonFunc(uint32_t V) {
69 switch (V) {
70#include "llvm/BinaryFormat/DXContainerConstants.def"
71 }
72 return false;
73}
74
75#define STATIC_BORDER_COLOR(Val, Enum) \
76 case Val: \
77 return true;
78bool llvm::dxbc::isValidBorderColor(uint32_t V) {
79 switch (V) {
80#include "llvm/BinaryFormat/DXContainerConstants.def"
81 }
82 return false;
83}
84
85bool llvm::dxbc::isValidRootDesciptorFlags(uint32_t V) {
86 using FlagT = dxbc::RootDescriptorFlags;
87 uint32_t LargestValue =
88 llvm::to_underlying(E: FlagT::LLVM_BITMASK_LARGEST_ENUMERATOR);
89 return V < NextPowerOf2(A: LargestValue);
90}
91
92bool llvm::dxbc::isValidDescriptorRangeFlags(uint32_t V) {
93 using FlagT = dxbc::DescriptorRangeFlags;
94 uint32_t LargestValue =
95 llvm::to_underlying(E: FlagT::LLVM_BITMASK_LARGEST_ENUMERATOR);
96 return V < NextPowerOf2(A: LargestValue);
97}
98
99bool llvm::dxbc::isValidStaticSamplerFlags(uint32_t V) {
100 using FlagT = dxbc::StaticSamplerFlags;
101 uint32_t LargestValue =
102 llvm::to_underlying(E: FlagT::LLVM_BITMASK_LARGEST_ENUMERATOR);
103 return V < NextPowerOf2(A: LargestValue);
104}
105
106dxbc::PartType dxbc::parsePartType(StringRef S) {
107#define CONTAINER_PART(PartName) .Case(#PartName, PartType::PartName)
108 return StringSwitch<dxbc::PartType>(S)
109#include "llvm/BinaryFormat/DXContainerConstants.def"
110 .Default(Value: dxbc::PartType::Unknown);
111}
112
113bool ShaderHash::isPopulated() {
114 static uint8_t Zeros[16] = {0};
115 return Flags > 0 || 0 != memcmp(s1: &Digest, s2: &Zeros, n: 16);
116}
117
118#define COMPONENT_PRECISION(Val, Enum) {#Enum, SigMinPrecision::Enum},
119
120static const EnumEntry<SigMinPrecision> SigMinPrecisionNames[] = {
121#include "llvm/BinaryFormat/DXContainerConstants.def"
122};
123
124ArrayRef<EnumEntry<SigMinPrecision>> dxbc::getSigMinPrecisions() {
125 return ArrayRef(SigMinPrecisionNames);
126}
127
128#define D3D_SYSTEM_VALUE(Val, Enum) {#Enum, D3DSystemValue::Enum},
129
130static const EnumEntry<D3DSystemValue> D3DSystemValueNames[] = {
131#include "llvm/BinaryFormat/DXContainerConstants.def"
132};
133
134ArrayRef<EnumEntry<D3DSystemValue>> dxbc::getD3DSystemValues() {
135 return ArrayRef(D3DSystemValueNames);
136}
137
138#define COMPONENT_TYPE(Val, Enum) {#Enum, SigComponentType::Enum},
139
140static const EnumEntry<SigComponentType> SigComponentTypes[] = {
141#include "llvm/BinaryFormat/DXContainerConstants.def"
142};
143
144ArrayRef<EnumEntry<SigComponentType>> dxbc::getSigComponentTypes() {
145 return ArrayRef(SigComponentTypes);
146}
147
148static const EnumEntry<RootFlags> RootFlagNames[] = {
149#define ROOT_SIGNATURE_FLAG(Val, Enum) {#Enum, RootFlags::Enum},
150#include "llvm/BinaryFormat/DXContainerConstants.def"
151};
152
153ArrayRef<EnumEntry<RootFlags>> dxbc::getRootFlags() {
154 return ArrayRef(RootFlagNames);
155}
156
157static const EnumEntry<RootDescriptorFlags> RootDescriptorFlagNames[] = {
158#define ROOT_DESCRIPTOR_FLAG(Val, Enum, Flag) \
159 {#Enum, RootDescriptorFlags::Enum},
160#include "llvm/BinaryFormat/DXContainerConstants.def"
161};
162
163ArrayRef<EnumEntry<RootDescriptorFlags>> dxbc::getRootDescriptorFlags() {
164 return ArrayRef(RootDescriptorFlagNames);
165}
166
167static const EnumEntry<DescriptorRangeFlags> DescriptorRangeFlagNames[] = {
168#define DESCRIPTOR_RANGE_FLAG(Val, Enum, Flag) \
169 {#Enum, DescriptorRangeFlags::Enum},
170#include "llvm/BinaryFormat/DXContainerConstants.def"
171};
172
173ArrayRef<EnumEntry<DescriptorRangeFlags>> dxbc::getDescriptorRangeFlags() {
174 return ArrayRef(DescriptorRangeFlagNames);
175}
176
177static const EnumEntry<StaticSamplerFlags> StaticSamplerFlagNames[] = {
178#define STATIC_SAMPLER_FLAG(Val, Enum, Flag) {#Enum, StaticSamplerFlags::Enum},
179#include "llvm/BinaryFormat/DXContainerConstants.def"
180};
181
182ArrayRef<EnumEntry<StaticSamplerFlags>> dxbc::getStaticSamplerFlags() {
183 return ArrayRef(StaticSamplerFlagNames);
184}
185
186#define SHADER_VISIBILITY(Val, Enum) {#Enum, ShaderVisibility::Enum},
187
188static const EnumEntry<ShaderVisibility> ShaderVisibilityValues[] = {
189#include "llvm/BinaryFormat/DXContainerConstants.def"
190};
191
192ArrayRef<EnumEntry<ShaderVisibility>> dxbc::getShaderVisibility() {
193 return ArrayRef(ShaderVisibilityValues);
194}
195
196#define FILTER(Val, Enum) {#Enum, SamplerFilter::Enum},
197
198static const EnumEntry<SamplerFilter> SamplerFilterNames[] = {
199#include "llvm/BinaryFormat/DXContainerConstants.def"
200};
201
202ArrayRef<EnumEntry<SamplerFilter>> dxbc::getSamplerFilters() {
203 return ArrayRef(SamplerFilterNames);
204}
205
206#define TEXTURE_ADDRESS_MODE(Val, Enum) {#Enum, TextureAddressMode::Enum},
207
208static const EnumEntry<TextureAddressMode> TextureAddressModeNames[] = {
209#include "llvm/BinaryFormat/DXContainerConstants.def"
210};
211
212ArrayRef<EnumEntry<TextureAddressMode>> dxbc::getTextureAddressModes() {
213 return ArrayRef(TextureAddressModeNames);
214}
215
216#define COMPARISON_FUNC(Val, Enum) {#Enum, ComparisonFunc::Enum},
217
218static const EnumEntry<ComparisonFunc> ComparisonFuncNames[] = {
219#include "llvm/BinaryFormat/DXContainerConstants.def"
220};
221
222ArrayRef<EnumEntry<ComparisonFunc>> dxbc::getComparisonFuncs() {
223 return ArrayRef(ComparisonFuncNames);
224}
225
226#define STATIC_BORDER_COLOR(Val, Enum) {#Enum, StaticBorderColor::Enum},
227
228static const EnumEntry<StaticBorderColor> StaticBorderColorValues[] = {
229#include "llvm/BinaryFormat/DXContainerConstants.def"
230};
231
232ArrayRef<EnumEntry<StaticBorderColor>> dxbc::getStaticBorderColors() {
233 return ArrayRef(StaticBorderColorValues);
234}
235
236#define ROOT_PARAMETER(Val, Enum) {#Enum, RootParameterType::Enum},
237
238static const EnumEntry<RootParameterType> RootParameterTypes[] = {
239#include "llvm/BinaryFormat/DXContainerConstants.def"
240};
241
242ArrayRef<EnumEntry<RootParameterType>> dxbc::getRootParameterTypes() {
243 return ArrayRef(RootParameterTypes);
244}
245
246#define SEMANTIC_KIND(Val, Enum) {#Enum, PSV::SemanticKind::Enum},
247
248static const EnumEntry<PSV::SemanticKind> SemanticKindNames[] = {
249#include "llvm/BinaryFormat/DXContainerConstants.def"
250};
251
252ArrayRef<EnumEntry<PSV::SemanticKind>> PSV::getSemanticKinds() {
253 return ArrayRef(SemanticKindNames);
254}
255
256#define COMPONENT_TYPE(Val, Enum) {#Enum, PSV::ComponentType::Enum},
257
258static const EnumEntry<PSV::ComponentType> ComponentTypeNames[] = {
259#include "llvm/BinaryFormat/DXContainerConstants.def"
260};
261
262ArrayRef<EnumEntry<PSV::ComponentType>> PSV::getComponentTypes() {
263 return ArrayRef(ComponentTypeNames);
264}
265
266#define INTERPOLATION_MODE(Val, Enum) {#Enum, PSV::InterpolationMode::Enum},
267
268static const EnumEntry<PSV::InterpolationMode> InterpolationModeNames[] = {
269#include "llvm/BinaryFormat/DXContainerConstants.def"
270};
271
272ArrayRef<EnumEntry<PSV::InterpolationMode>> PSV::getInterpolationModes() {
273 return ArrayRef(InterpolationModeNames);
274}
275
276#define RESOURCE_TYPE(Val, Enum) {#Enum, PSV::ResourceType::Enum},
277
278static const EnumEntry<PSV::ResourceType> ResourceTypeNames[] = {
279#include "llvm/BinaryFormat/DXContainerConstants.def"
280};
281
282ArrayRef<EnumEntry<PSV::ResourceType>> PSV::getResourceTypes() {
283 return ArrayRef(ResourceTypeNames);
284}
285
286#define RESOURCE_KIND(Val, Enum) {#Enum, PSV::ResourceKind::Enum},
287
288static const EnumEntry<PSV::ResourceKind> ResourceKindNames[] = {
289#include "llvm/BinaryFormat/DXContainerConstants.def"
290};
291
292ArrayRef<EnumEntry<PSV::ResourceKind>> PSV::getResourceKinds() {
293 return ArrayRef(ResourceKindNames);
294}
295