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 18 using namespace llvm; 19 using namespace llvm::dxbc; 20 21 dxbc::PartType dxbc::parsePartType(StringRef S) { 22 #define CONTAINER_PART(PartName) .Case(#PartName, PartType::PartName) 23 return StringSwitch<dxbc::PartType>(S) 24 #include "llvm/BinaryFormat/DXContainerConstants.def" 25 .Default(dxbc::PartType::Unknown); 26 } 27 28 bool ShaderHash::isPopulated() { 29 static uint8_t Zeros[16] = {0}; 30 return Flags > 0 || 0 != memcmp(&Digest, &Zeros, 16); 31 } 32 33 #define COMPONENT_PRECISION(Val, Enum) {#Enum, SigMinPrecision::Enum}, 34 35 static const EnumEntry<SigMinPrecision> SigMinPrecisionNames[] = { 36 #include "llvm/BinaryFormat/DXContainerConstants.def" 37 }; 38 39 ArrayRef<EnumEntry<SigMinPrecision>> dxbc::getSigMinPrecisions() { 40 return ArrayRef(SigMinPrecisionNames); 41 } 42 43 #define D3D_SYSTEM_VALUE(Val, Enum) {#Enum, D3DSystemValue::Enum}, 44 45 static const EnumEntry<D3DSystemValue> D3DSystemValueNames[] = { 46 #include "llvm/BinaryFormat/DXContainerConstants.def" 47 }; 48 49 ArrayRef<EnumEntry<D3DSystemValue>> dxbc::getD3DSystemValues() { 50 return ArrayRef(D3DSystemValueNames); 51 } 52 53 #define COMPONENT_TYPE(Val, Enum) {#Enum, SigComponentType::Enum}, 54 55 static const EnumEntry<SigComponentType> SigComponentTypes[] = { 56 #include "llvm/BinaryFormat/DXContainerConstants.def" 57 }; 58 59 ArrayRef<EnumEntry<SigComponentType>> dxbc::getSigComponentTypes() { 60 return ArrayRef(SigComponentTypes); 61 } 62 63 static const EnumEntry<RootFlags> RootFlagNames[] = { 64 #define ROOT_SIGNATURE_FLAG(Val, Enum) {#Enum, RootFlags::Enum}, 65 #include "llvm/BinaryFormat/DXContainerConstants.def" 66 }; 67 68 ArrayRef<EnumEntry<RootFlags>> dxbc::getRootFlags() { 69 return ArrayRef(RootFlagNames); 70 } 71 72 static const EnumEntry<RootDescriptorFlags> RootDescriptorFlagNames[] = { 73 #define ROOT_DESCRIPTOR_FLAG(Val, Enum, Flag) \ 74 {#Enum, RootDescriptorFlags::Enum}, 75 #include "llvm/BinaryFormat/DXContainerConstants.def" 76 }; 77 78 ArrayRef<EnumEntry<RootDescriptorFlags>> dxbc::getRootDescriptorFlags() { 79 return ArrayRef(RootDescriptorFlagNames); 80 } 81 82 static const EnumEntry<DescriptorRangeFlags> DescriptorRangeFlagNames[] = { 83 #define DESCRIPTOR_RANGE_FLAG(Val, Enum, Flag) \ 84 {#Enum, DescriptorRangeFlags::Enum}, 85 #include "llvm/BinaryFormat/DXContainerConstants.def" 86 }; 87 88 ArrayRef<EnumEntry<DescriptorRangeFlags>> dxbc::getDescriptorRangeFlags() { 89 return ArrayRef(DescriptorRangeFlagNames); 90 } 91 92 #define SHADER_VISIBILITY(Val, Enum) {#Enum, ShaderVisibility::Enum}, 93 94 static const EnumEntry<ShaderVisibility> ShaderVisibilityValues[] = { 95 #include "llvm/BinaryFormat/DXContainerConstants.def" 96 }; 97 98 ArrayRef<EnumEntry<ShaderVisibility>> dxbc::getShaderVisibility() { 99 return ArrayRef(ShaderVisibilityValues); 100 } 101 102 #define FILTER(Val, Enum) {#Enum, SamplerFilter::Enum}, 103 104 static const EnumEntry<SamplerFilter> SamplerFilterNames[] = { 105 #include "llvm/BinaryFormat/DXContainerConstants.def" 106 }; 107 108 ArrayRef<EnumEntry<SamplerFilter>> dxbc::getSamplerFilters() { 109 return ArrayRef(SamplerFilterNames); 110 } 111 112 #define TEXTURE_ADDRESS_MODE(Val, Enum) {#Enum, TextureAddressMode::Enum}, 113 114 static const EnumEntry<TextureAddressMode> TextureAddressModeNames[] = { 115 #include "llvm/BinaryFormat/DXContainerConstants.def" 116 }; 117 118 ArrayRef<EnumEntry<TextureAddressMode>> dxbc::getTextureAddressModes() { 119 return ArrayRef(TextureAddressModeNames); 120 } 121 122 #define COMPARISON_FUNC(Val, Enum) {#Enum, ComparisonFunc::Enum}, 123 124 static const EnumEntry<ComparisonFunc> ComparisonFuncNames[] = { 125 #include "llvm/BinaryFormat/DXContainerConstants.def" 126 }; 127 128 ArrayRef<EnumEntry<ComparisonFunc>> dxbc::getComparisonFuncs() { 129 return ArrayRef(ComparisonFuncNames); 130 } 131 132 #define STATIC_BORDER_COLOR(Val, Enum) {#Enum, StaticBorderColor::Enum}, 133 134 static const EnumEntry<StaticBorderColor> StaticBorderColorValues[] = { 135 #include "llvm/BinaryFormat/DXContainerConstants.def" 136 }; 137 138 ArrayRef<EnumEntry<StaticBorderColor>> dxbc::getStaticBorderColors() { 139 return ArrayRef(StaticBorderColorValues); 140 } 141 142 #define ROOT_PARAMETER(Val, Enum) {#Enum, RootParameterType::Enum}, 143 144 static const EnumEntry<RootParameterType> RootParameterTypes[] = { 145 #include "llvm/BinaryFormat/DXContainerConstants.def" 146 }; 147 148 ArrayRef<EnumEntry<RootParameterType>> dxbc::getRootParameterTypes() { 149 return ArrayRef(RootParameterTypes); 150 } 151 152 #define SEMANTIC_KIND(Val, Enum) {#Enum, PSV::SemanticKind::Enum}, 153 154 static const EnumEntry<PSV::SemanticKind> SemanticKindNames[] = { 155 #include "llvm/BinaryFormat/DXContainerConstants.def" 156 }; 157 158 ArrayRef<EnumEntry<PSV::SemanticKind>> PSV::getSemanticKinds() { 159 return ArrayRef(SemanticKindNames); 160 } 161 162 #define COMPONENT_TYPE(Val, Enum) {#Enum, PSV::ComponentType::Enum}, 163 164 static const EnumEntry<PSV::ComponentType> ComponentTypeNames[] = { 165 #include "llvm/BinaryFormat/DXContainerConstants.def" 166 }; 167 168 ArrayRef<EnumEntry<PSV::ComponentType>> PSV::getComponentTypes() { 169 return ArrayRef(ComponentTypeNames); 170 } 171 172 #define INTERPOLATION_MODE(Val, Enum) {#Enum, PSV::InterpolationMode::Enum}, 173 174 static const EnumEntry<PSV::InterpolationMode> InterpolationModeNames[] = { 175 #include "llvm/BinaryFormat/DXContainerConstants.def" 176 }; 177 178 ArrayRef<EnumEntry<PSV::InterpolationMode>> PSV::getInterpolationModes() { 179 return ArrayRef(InterpolationModeNames); 180 } 181 182 #define RESOURCE_TYPE(Val, Enum) {#Enum, PSV::ResourceType::Enum}, 183 184 static const EnumEntry<PSV::ResourceType> ResourceTypeNames[] = { 185 #include "llvm/BinaryFormat/DXContainerConstants.def" 186 }; 187 188 ArrayRef<EnumEntry<PSV::ResourceType>> PSV::getResourceTypes() { 189 return ArrayRef(ResourceTypeNames); 190 } 191 192 #define RESOURCE_KIND(Val, Enum) {#Enum, PSV::ResourceKind::Enum}, 193 194 static const EnumEntry<PSV::ResourceKind> ResourceKindNames[] = { 195 #include "llvm/BinaryFormat/DXContainerConstants.def" 196 }; 197 198 ArrayRef<EnumEntry<PSV::ResourceKind>> PSV::getResourceKinds() { 199 return ArrayRef(ResourceKindNames); 200 } 201