From e0612d71bab9829822d6cd969684cce630df40cf Mon Sep 17 00:00:00 2001 From: Joao Saffran Date: Fri, 3 Oct 2025 14:11:54 -0700 Subject: [PATCH 1/8] remove error classes --- .../Frontend/HLSL/RootSignatureMetadata.h | 269 ++++++++---------- 1 file changed, 122 insertions(+), 147 deletions(-) diff --git a/llvm/include/llvm/Frontend/HLSL/RootSignatureMetadata.h b/llvm/include/llvm/Frontend/HLSL/RootSignatureMetadata.h index bfcbf728d415c..65b637f2d80cc 100644 --- a/llvm/include/llvm/Frontend/HLSL/RootSignatureMetadata.h +++ b/llvm/include/llvm/Frontend/HLSL/RootSignatureMetadata.h @@ -28,164 +28,139 @@ class Metadata; namespace hlsl { namespace rootsig { -template -class RootSignatureValidationError - : public ErrorInfo> { -public: - static char ID; - StringRef ParamName; - T Value; - - RootSignatureValidationError(StringRef ParamName, T Value) - : ParamName(ParamName), Value(Value) {} - - void log(raw_ostream &OS) const override { - OS << "Invalid value for " << ParamName << ": " << Value; - } - - std::error_code convertToErrorCode() const override { - return llvm::inconvertibleErrorCode(); - } +enum class ErrorKind { + Validation, + AppendAfterUnboundedRange, + ShaderRegisterOverflow, + OffsetOverflow, + SamplerMixin, + GenericMetadata, + InvalidMetadataFormat, + InvalidMetadataValue }; -class OffsetAppendAfterOverflow : public ErrorInfo { -public: - static char ID; - dxil::ResourceClass Type; - uint32_t Register; - uint32_t Space; - - OffsetAppendAfterOverflow(dxil::ResourceClass Type, uint32_t Register, - uint32_t Space) - : Type(Type), Register(Register), Space(Space) {} - - void log(raw_ostream &OS) const override { - OS << "Range " << getResourceClassName(Type) << "(register=" << Register +template +void formatImpl(raw_string_ostream &Buff, + std::integral_constant, + StringRef ParamName, T Value) { + Buff << "Invalid value for: " << ParamName << ":" << Value; +} + +void formatImpl( + raw_string_ostream &Buff, + std::integral_constant, + dxil::ResourceClass Type, uint32_t Register, uint32_t Space) { + Buff << "Range " << getResourceClassName(Type) << "(register=" << Register << ", space=" << Space << ") " << "cannot be appended after an unbounded range "; - } - - std::error_code convertToErrorCode() const override { - return llvm::inconvertibleErrorCode(); - } -}; +} -class ShaderRegisterOverflowError - : public ErrorInfo { -public: - static char ID; - dxil::ResourceClass Type; - uint32_t Register; - uint32_t Space; - - ShaderRegisterOverflowError(dxil::ResourceClass Type, uint32_t Register, - uint32_t Space) - : Type(Type), Register(Register), Space(Space) {} - - void log(raw_ostream &OS) const override { - OS << "Overflow for shader register range: " << getResourceClassName(Type) +void formatImpl( + raw_string_ostream &Buff, + std::integral_constant, + dxil::ResourceClass Type, uint32_t Register, uint32_t Space) { + Buff << "Overflow for shader register range: " << getResourceClassName(Type) << "(register=" << Register << ", space=" << Space << ")."; - } +} - std::error_code convertToErrorCode() const override { - return llvm::inconvertibleErrorCode(); - } -}; - -class OffsetOverflowError : public ErrorInfo { -public: - static char ID; - dxil::ResourceClass Type; - uint32_t Register; - uint32_t Space; - - OffsetOverflowError(dxil::ResourceClass Type, uint32_t Register, - uint32_t Space) - : Type(Type), Register(Register), Space(Space) {} - - void log(raw_ostream &OS) const override { - OS << "Offset overflow for descriptor range: " << getResourceClassName(Type) +void formatImpl(raw_string_ostream &Buff, + std::integral_constant, + dxil::ResourceClass Type, uint32_t Register, uint32_t Space) { + Buff << "Offset overflow for descriptor range: " << getResourceClassName(Type) << "(register=" << Register << ", space=" << Space << ")."; - } - - std::error_code convertToErrorCode() const override { - return llvm::inconvertibleErrorCode(); - } -}; - -class TableSamplerMixinError : public ErrorInfo { -public: - static char ID; - dxil::ResourceClass Type; - uint32_t Location; - - TableSamplerMixinError(dxil::ResourceClass Type, uint32_t Location) - : Type(Type), Location(Location) {} +} - void log(raw_ostream &OS) const override { - OS << "Samplers cannot be mixed with other " +void formatImpl(raw_string_ostream &Buff, + std::integral_constant, + dxil::ResourceClass Type, uint32_t Location) { + Buff << "Samplers cannot be mixed with other " << "resource types in a descriptor table, " << getResourceClassName(Type) << "(location=" << Location << ")"; - } - - std::error_code convertToErrorCode() const override { - return llvm::inconvertibleErrorCode(); - } -}; - -class GenericRSMetadataError : public ErrorInfo { -public: - LLVM_ABI static char ID; - StringRef Message; - MDNode *MD; - - GenericRSMetadataError(StringRef Message, MDNode *MD) - : Message(Message), MD(MD) {} - - void log(raw_ostream &OS) const override { - OS << Message; - if (MD) { - OS << "\n"; - MD->printTree(OS); - } - } - - std::error_code convertToErrorCode() const override { - return llvm::inconvertibleErrorCode(); - } -}; - -class InvalidRSMetadataFormat : public ErrorInfo { -public: - LLVM_ABI static char ID; - StringRef ElementName; - - InvalidRSMetadataFormat(StringRef ElementName) : ElementName(ElementName) {} - - void log(raw_ostream &OS) const override { - OS << "Invalid format for " << ElementName; - } - - std::error_code convertToErrorCode() const override { - return llvm::inconvertibleErrorCode(); - } -}; - -class InvalidRSMetadataValue : public ErrorInfo { -public: - LLVM_ABI static char ID; - StringRef ParamName; - - InvalidRSMetadataValue(StringRef ParamName) : ParamName(ParamName) {} - - void log(raw_ostream &OS) const override { - OS << "Invalid value for " << ParamName; - } - - std::error_code convertToErrorCode() const override { - return llvm::inconvertibleErrorCode(); - } -}; +} + +void formatImpl( + raw_string_ostream &Buff, + std::integral_constant, + StringRef ElementName) { + Buff << "Invalid format for " << ElementName; +} + +void formatImpl( + raw_string_ostream &Buff, + std::integral_constant, + StringRef ParamName) { + Buff << "Invalid value for " << ParamName; +} + +void formatImpl(raw_string_ostream &Buff, + std::integral_constant, + StringRef Message, MDNode *MD) { + Buff << Message; + if (MD) { + Buff << "\n"; + MD->printTree(Buff); + } +} + +template +static void formatErrMsg(raw_string_ostream &Buff, ErrorKind Kind, + ArgsTs... Args) { + switch (Kind) { + case ErrorKind::Validation: + formatImpl(Buff, std::integral_constant{}, + Args...); + break; + case ErrorKind::AppendAfterUnboundedRange: + formatImpl(Buff, + std::integral_constant{}, + Args...); + break; + case ErrorKind::ShaderRegisterOverflow: + formatImpl( + Buff, + std::integral_constant{}, + Args...); + break; + case ErrorKind::OffsetOverflow: + formatImpl(Buff, + std::integral_constant{}, + Args...); + break; + case ErrorKind::SamplerMixin: + formatImpl(Buff, + std::integral_constant{}, + Args...); + break; + case ErrorKind::GenericMetadata: + formatImpl(Buff, + std::integral_constant{}, + Args...); + break; + + case ErrorKind::InvalidMetadataFormat: + formatImpl( + Buff, + std::integral_constant{}, + Args...); + break; + + case ErrorKind::InvalidMetadataValue: + formatImpl( + Buff, + std::integral_constant{}, + Args...); + break; + } +} + +template +static llvm::Error createRSError(ErrorKind Kind, ArgsTs... Args) { + std::string Msg; + raw_string_ostream Buff(Msg); + formatErrMsg(Buff, Kind, Args...); + return createStringError(std::move(Buff.str()), inconvertibleErrorCode()); +} class MetadataBuilder { public: From 7ae75fbd2988b327a530898622126f2e3c18f940 Mon Sep 17 00:00:00 2001 From: Joao Saffran Date: Fri, 3 Oct 2025 15:11:11 -0700 Subject: [PATCH 2/8] finish refactoring --- .../Frontend/HLSL/RootSignatureMetadata.h | 149 ++++----- .../Frontend/HLSL/RootSignatureMetadata.cpp | 314 +++++++++++------- 2 files changed, 264 insertions(+), 199 deletions(-) diff --git a/llvm/include/llvm/Frontend/HLSL/RootSignatureMetadata.h b/llvm/include/llvm/Frontend/HLSL/RootSignatureMetadata.h index 65b637f2d80cc..76d9e93e2470a 100644 --- a/llvm/include/llvm/Frontend/HLSL/RootSignatureMetadata.h +++ b/llvm/include/llvm/Frontend/HLSL/RootSignatureMetadata.h @@ -28,7 +28,7 @@ class Metadata; namespace hlsl { namespace rootsig { -enum class ErrorKind { +enum class RSErrorKind { Validation, AppendAfterUnboundedRange, ShaderRegisterOverflow, @@ -41,124 +41,97 @@ enum class ErrorKind { template void formatImpl(raw_string_ostream &Buff, - std::integral_constant, - StringRef ParamName, T Value) { - Buff << "Invalid value for: " << ParamName << ":" << Value; -} + std::integral_constant, + StringRef ParamName, T Value); void formatImpl( raw_string_ostream &Buff, - std::integral_constant, - dxil::ResourceClass Type, uint32_t Register, uint32_t Space) { - Buff << "Range " << getResourceClassName(Type) << "(register=" << Register - << ", space=" << Space << ") " - << "cannot be appended after an unbounded range "; -} + std::integral_constant, + dxil::ResourceClass Type, uint32_t Register, uint32_t Space); void formatImpl( raw_string_ostream &Buff, - std::integral_constant, - dxil::ResourceClass Type, uint32_t Register, uint32_t Space) { - Buff << "Overflow for shader register range: " << getResourceClassName(Type) - << "(register=" << Register << ", space=" << Space << ")."; -} + std::integral_constant, + dxil::ResourceClass Type, uint32_t Register, uint32_t Space); -void formatImpl(raw_string_ostream &Buff, - std::integral_constant, - dxil::ResourceClass Type, uint32_t Register, uint32_t Space) { - Buff << "Offset overflow for descriptor range: " << getResourceClassName(Type) - << "(register=" << Register << ", space=" << Space << ")."; -} +void formatImpl( + raw_string_ostream &Buff, + std::integral_constant, + dxil::ResourceClass Type, uint32_t Register, uint32_t Space); void formatImpl(raw_string_ostream &Buff, - std::integral_constant, - dxil::ResourceClass Type, uint32_t Location) { - Buff << "Samplers cannot be mixed with other " - << "resource types in a descriptor table, " << getResourceClassName(Type) - << "(location=" << Location << ")"; -} + std::integral_constant, + dxil::ResourceClass Type, uint32_t Location); void formatImpl( raw_string_ostream &Buff, - std::integral_constant, - StringRef ElementName) { - Buff << "Invalid format for " << ElementName; -} + std::integral_constant, + StringRef ElementName); void formatImpl( raw_string_ostream &Buff, - std::integral_constant, - StringRef ParamName) { - Buff << "Invalid value for " << ParamName; -} + std::integral_constant, + StringRef ParamName); -void formatImpl(raw_string_ostream &Buff, - std::integral_constant, - StringRef Message, MDNode *MD) { - Buff << Message; - if (MD) { - Buff << "\n"; - MD->printTree(Buff); - } -} +void formatImpl( + raw_string_ostream &Buff, + std::integral_constant, + StringRef Message, MDNode *MD); template -static void formatErrMsg(raw_string_ostream &Buff, ErrorKind Kind, - ArgsTs... Args) { +inline void formatImpl(raw_string_ostream &Buff, RSErrorKind Kind, + ArgsTs... Args) { switch (Kind) { - case ErrorKind::Validation: - formatImpl(Buff, std::integral_constant{}, - Args...); - break; - case ErrorKind::AppendAfterUnboundedRange: - formatImpl(Buff, - std::integral_constant{}, - Args...); - break; - case ErrorKind::ShaderRegisterOverflow: - formatImpl( + case RSErrorKind::Validation: + return formatImpl( + Buff, std::integral_constant(), + Args...); + case RSErrorKind::AppendAfterUnboundedRange: + return formatImpl( Buff, - std::integral_constant{}, + std::integral_constant(), Args...); - break; - case ErrorKind::OffsetOverflow: - formatImpl(Buff, - std::integral_constant{}, - Args...); - break; - case ErrorKind::SamplerMixin: - formatImpl(Buff, - std::integral_constant{}, - Args...); - break; - case ErrorKind::GenericMetadata: - formatImpl(Buff, - std::integral_constant{}, - Args...); - break; - - case ErrorKind::InvalidMetadataFormat: - formatImpl( + case RSErrorKind::ShaderRegisterOverflow: + return formatImpl( Buff, - std::integral_constant{}, + std::integral_constant(), Args...); - break; - - case ErrorKind::InvalidMetadataValue: - formatImpl( + case RSErrorKind::OffsetOverflow: + return formatImpl( + Buff, + std::integral_constant(), + Args...); + case RSErrorKind::SamplerMixin: + return formatImpl( + Buff, std::integral_constant(), + Args...); + case RSErrorKind::InvalidMetadataFormat: + return formatImpl( + Buff, + std::integral_constant(), + Args...); + case RSErrorKind::InvalidMetadataValue: + return formatImpl( + Buff, + std::integral_constant(), + Args...); + case RSErrorKind::GenericMetadata: + return formatImpl( Buff, - std::integral_constant{}, + std::integral_constant(), Args...); - break; } } template -static llvm::Error createRSError(ErrorKind Kind, ArgsTs... Args) { +static llvm::Error createRSError(RSErrorKind Kind, ArgsTs... Args) { std::string Msg; raw_string_ostream Buff(Msg); - formatErrMsg(Buff, Kind, Args...); + formatImpl(Buff, Kind, Args...); return createStringError(std::move(Buff.str()), inconvertibleErrorCode()); } diff --git a/llvm/lib/Frontend/HLSL/RootSignatureMetadata.cpp b/llvm/lib/Frontend/HLSL/RootSignatureMetadata.cpp index 7a0cf408968de..7ed4ec0dc3457 100644 --- a/llvm/lib/Frontend/HLSL/RootSignatureMetadata.cpp +++ b/llvm/lib/Frontend/HLSL/RootSignatureMetadata.cpp @@ -24,15 +24,75 @@ namespace llvm { namespace hlsl { namespace rootsig { -char GenericRSMetadataError::ID; -char InvalidRSMetadataFormat::ID; -char InvalidRSMetadataValue::ID; -char TableSamplerMixinError::ID; -char ShaderRegisterOverflowError::ID; -char OffsetOverflowError::ID; -char OffsetAppendAfterOverflow::ID; +template +void formatImpl(raw_string_ostream &Buff, + std::integral_constant, + StringRef ParamName, T Value) { + Buff << "Invalid value for: " << ParamName << ":"; + if constexpr (std::is_same_v, std::nullptr_t>) { + Buff << "nullptr"; + } else { + Buff << Value; + } +} -template char RootSignatureValidationError::ID; +void formatImpl( + raw_string_ostream &Buff, + std::integral_constant, + dxil::ResourceClass Type, uint32_t Register, uint32_t Space) { + Buff << "Range " << getResourceClassName(Type) << "(register=" << Register + << ", space=" << Space << ") " + << "cannot be appended after an unbounded range "; +} + +void formatImpl( + raw_string_ostream &Buff, + std::integral_constant, + dxil::ResourceClass Type, uint32_t Register, uint32_t Space) { + Buff << "Overflow for shader register range: " << getResourceClassName(Type) + << "(register=" << Register << ", space=" << Space << ")."; +} + +void formatImpl( + raw_string_ostream &Buff, + std::integral_constant, + dxil::ResourceClass Type, uint32_t Register, uint32_t Space) { + Buff << "Offset overflow for descriptor range: " << getResourceClassName(Type) + << "(register=" << Register << ", space=" << Space << ")."; +} + +void formatImpl(raw_string_ostream &Buff, + std::integral_constant, + dxil::ResourceClass Type, uint32_t Location) { + Buff << "Samplers cannot be mixed with other " + << "resource types in a descriptor table, " << getResourceClassName(Type) + << "(location=" << Location << ")"; +} + +void formatImpl( + raw_string_ostream &Buff, + std::integral_constant, + StringRef ElementName) { + Buff << "Invalid format for " << ElementName; +} + +void formatImpl( + raw_string_ostream &Buff, + std::integral_constant, + StringRef ParamName) { + Buff << "Invalid value for " << ParamName; +} + +void formatImpl( + raw_string_ostream &Buff, + std::integral_constant, + StringRef Message, MDNode *MD) { + Buff << Message; + if (MD) { + Buff << "\n"; + MD->printTree(Buff); + } +} static std::optional extractMdIntValue(MDNode *Node, unsigned int OpId) { @@ -65,10 +125,11 @@ extractEnumValue(MDNode *Node, unsigned int OpId, StringRef ErrText, llvm::function_ref VerifyFn) { if (std::optional Val = extractMdIntValue(Node, OpId)) { if (!VerifyFn(*Val)) - return make_error>(ErrText, *Val); + return createRSError(RSErrorKind::Validation, ErrText, *Val); return static_cast(*Val); } - return make_error("ShaderVisibility"); + return createRSError(RSErrorKind::InvalidMetadataValue, + StringRef("ShaderVisibility")); } namespace { @@ -226,12 +287,14 @@ MDNode *MetadataBuilder::BuildStaticSampler(const StaticSampler &Sampler) { Error MetadataParser::parseRootFlags(mcdxbc::RootSignatureDesc &RSD, MDNode *RootFlagNode) { if (RootFlagNode->getNumOperands() != 2) - return make_error("RootFlag Element"); + return createRSError(RSErrorKind::InvalidMetadataFormat, + StringRef("RootFlags Element")); if (std::optional Val = extractMdIntValue(RootFlagNode, 1)) RSD.Flags = *Val; else - return make_error("RootFlag"); + return createRSError(RSErrorKind::InvalidMetadataValue, + StringRef("RootFlag")); return Error::success(); } @@ -239,7 +302,8 @@ Error MetadataParser::parseRootFlags(mcdxbc::RootSignatureDesc &RSD, Error MetadataParser::parseRootConstants(mcdxbc::RootSignatureDesc &RSD, MDNode *RootConstantNode) { if (RootConstantNode->getNumOperands() != 5) - return make_error("RootConstants Element"); + return createRSError(RSErrorKind::InvalidMetadataFormat, + StringRef("RootConstants Element")); Expected Visibility = extractEnumValue(RootConstantNode, 1, @@ -252,17 +316,20 @@ Error MetadataParser::parseRootConstants(mcdxbc::RootSignatureDesc &RSD, if (std::optional Val = extractMdIntValue(RootConstantNode, 2)) Constants.ShaderRegister = *Val; else - return make_error("ShaderRegister"); + return createRSError(RSErrorKind::InvalidMetadataValue, + StringRef("ShaderRegister")); if (std::optional Val = extractMdIntValue(RootConstantNode, 3)) Constants.RegisterSpace = *Val; else - return make_error("RegisterSpace"); + return createRSError(RSErrorKind::InvalidMetadataValue, + StringRef("RegisterSpace")); if (std::optional Val = extractMdIntValue(RootConstantNode, 4)) Constants.Num32BitValues = *Val; else - return make_error("Num32BitValues"); + return createRSError(RSErrorKind::InvalidMetadataValue, + StringRef("Num32BitValues")); RSD.ParametersContainer.addParameter(dxbc::RootParameterType::Constants32Bit, *Visibility, Constants); @@ -279,7 +346,8 @@ Error MetadataParser::parseRootDescriptors( "parseRootDescriptors should only be called with RootDescriptor " "element kind."); if (RootDescriptorNode->getNumOperands() != 5) - return make_error("Root Descriptor Element"); + return createRSError(RSErrorKind::InvalidMetadataFormat, + StringRef("Root Descriptor Element")); dxbc::RootParameterType Type; switch (ElementKind) { @@ -308,12 +376,14 @@ Error MetadataParser::parseRootDescriptors( if (std::optional Val = extractMdIntValue(RootDescriptorNode, 2)) Descriptor.ShaderRegister = *Val; else - return make_error("ShaderRegister"); + return createRSError(RSErrorKind::InvalidMetadataValue, + StringRef("ShaderRegister")); if (std::optional Val = extractMdIntValue(RootDescriptorNode, 3)) Descriptor.RegisterSpace = *Val; else - return make_error("RegisterSpace"); + return createRSError(RSErrorKind::InvalidMetadataValue, + StringRef("RegisterSpace")); if (RSD.Version == 1) { RSD.ParametersContainer.addParameter(Type, *Visibility, Descriptor); @@ -324,7 +394,8 @@ Error MetadataParser::parseRootDescriptors( if (std::optional Val = extractMdIntValue(RootDescriptorNode, 4)) Descriptor.Flags = *Val; else - return make_error("Root Descriptor Flags"); + return createRSError(RSErrorKind::InvalidMetadataValue, + StringRef("Root Descriptor Flags")); RSD.ParametersContainer.addParameter(Type, *Visibility, Descriptor); return Error::success(); @@ -333,7 +404,8 @@ Error MetadataParser::parseRootDescriptors( Error MetadataParser::parseDescriptorRange(mcdxbc::DescriptorTable &Table, MDNode *RangeDescriptorNode) { if (RangeDescriptorNode->getNumOperands() != 6) - return make_error("Descriptor Range"); + return createRSError(RSErrorKind::InvalidMetadataFormat, + StringRef("Descriptor Range")); mcdxbc::DescriptorRange Range; @@ -341,7 +413,8 @@ Error MetadataParser::parseDescriptorRange(mcdxbc::DescriptorTable &Table, extractMdStringValue(RangeDescriptorNode, 0); if (!ElementText.has_value()) - return make_error("Descriptor Range"); + return createRSError(RSErrorKind::InvalidMetadataFormat, + StringRef("Descriptor Range")); if (*ElementText == "CBV") Range.RangeType = dxil::ResourceClass::CBuffer; @@ -352,35 +425,40 @@ Error MetadataParser::parseDescriptorRange(mcdxbc::DescriptorTable &Table, else if (*ElementText == "Sampler") Range.RangeType = dxil::ResourceClass::Sampler; else - return make_error("Invalid Descriptor Range type.", - RangeDescriptorNode); + return createRSError(RSErrorKind::GenericMetadata, + StringRef("Invalid Descriptor Range type."), + RangeDescriptorNode); if (std::optional Val = extractMdIntValue(RangeDescriptorNode, 1)) Range.NumDescriptors = *Val; else - return make_error("Number of Descriptor in Range", - RangeDescriptorNode); + return createRSError(RSErrorKind::GenericMetadata, + StringRef("Number of Descriptor in Range"), + RangeDescriptorNode); if (std::optional Val = extractMdIntValue(RangeDescriptorNode, 2)) Range.BaseShaderRegister = *Val; else - return make_error("BaseShaderRegister"); + return createRSError(RSErrorKind::InvalidMetadataValue, + StringRef("BaseShaderRegister")); if (std::optional Val = extractMdIntValue(RangeDescriptorNode, 3)) Range.RegisterSpace = *Val; else - return make_error("RegisterSpace"); + return createRSError(RSErrorKind::InvalidMetadataValue, + StringRef("RegisterSpace")); if (std::optional Val = extractMdIntValue(RangeDescriptorNode, 4)) Range.OffsetInDescriptorsFromTableStart = *Val; else - return make_error( - "OffsetInDescriptorsFromTableStart"); + return createRSError(RSErrorKind::InvalidMetadataValue, + StringRef("OffsetInDescriptorsFromTableStart")); if (std::optional Val = extractMdIntValue(RangeDescriptorNode, 5)) Range.Flags = *Val; else - return make_error("Descriptor Range Flags"); + return createRSError(RSErrorKind::InvalidMetadataValue, + StringRef("Descriptor Range Flags")); Table.Ranges.push_back(Range); return Error::success(); @@ -390,7 +468,8 @@ Error MetadataParser::parseDescriptorTable(mcdxbc::RootSignatureDesc &RSD, MDNode *DescriptorTableNode) { const unsigned int NumOperands = DescriptorTableNode->getNumOperands(); if (NumOperands < 2) - return make_error("Descriptor Table"); + return createRSError(RSErrorKind::InvalidMetadataFormat, + StringRef("Descriptor Table")); Expected Visibility = extractEnumValue(DescriptorTableNode, 1, @@ -404,8 +483,9 @@ Error MetadataParser::parseDescriptorTable(mcdxbc::RootSignatureDesc &RSD, for (unsigned int I = 2; I < NumOperands; I++) { MDNode *Element = dyn_cast(DescriptorTableNode->getOperand(I)); if (Element == nullptr) - return make_error( - "Missing Root Element Metadata Node.", DescriptorTableNode); + return createRSError(RSErrorKind::GenericMetadata, + StringRef("Missing Root Element Metadata Node."), + DescriptorTableNode); if (auto Err = parseDescriptorRange(Table, Element)) return Err; @@ -419,7 +499,8 @@ Error MetadataParser::parseDescriptorTable(mcdxbc::RootSignatureDesc &RSD, Error MetadataParser::parseStaticSampler(mcdxbc::RootSignatureDesc &RSD, MDNode *StaticSamplerNode) { if (StaticSamplerNode->getNumOperands() != 15) - return make_error("Static Sampler"); + return createRSError(RSErrorKind::InvalidMetadataFormat, + StringRef("Static Sampler")); mcdxbc::StaticSampler Sampler; @@ -453,12 +534,14 @@ Error MetadataParser::parseStaticSampler(mcdxbc::RootSignatureDesc &RSD, if (std::optional Val = extractMdFloatValue(StaticSamplerNode, 5)) Sampler.MipLODBias = *Val; else - return make_error("MipLODBias"); + return createRSError(RSErrorKind::InvalidMetadataValue, + StringRef("MipLODBias")); if (std::optional Val = extractMdIntValue(StaticSamplerNode, 6)) Sampler.MaxAnisotropy = *Val; else - return make_error("MaxAnisotropy"); + return createRSError(RSErrorKind::InvalidMetadataValue, + StringRef("MaxAnisotropy")); Expected ComparisonFunc = extractEnumValue( @@ -477,22 +560,26 @@ Error MetadataParser::parseStaticSampler(mcdxbc::RootSignatureDesc &RSD, if (std::optional Val = extractMdFloatValue(StaticSamplerNode, 9)) Sampler.MinLOD = *Val; else - return make_error("MinLOD"); + return createRSError(RSErrorKind::InvalidMetadataValue, + StringRef("MinLOD")); if (std::optional Val = extractMdFloatValue(StaticSamplerNode, 10)) Sampler.MaxLOD = *Val; else - return make_error("MaxLOD"); + return createRSError(RSErrorKind::InvalidMetadataValue, + StringRef("MaxLOD")); if (std::optional Val = extractMdIntValue(StaticSamplerNode, 11)) Sampler.ShaderRegister = *Val; else - return make_error("ShaderRegister"); + return createRSError(RSErrorKind::InvalidMetadataValue, + StringRef("ShaderRegister")); if (std::optional Val = extractMdIntValue(StaticSamplerNode, 12)) Sampler.RegisterSpace = *Val; else - return make_error("RegisterSpace"); + return createRSError(RSErrorKind::InvalidMetadataValue, + StringRef("RegisterSpace")); Expected Visibility = extractEnumValue(StaticSamplerNode, 13, @@ -511,7 +598,8 @@ Error MetadataParser::parseStaticSampler(mcdxbc::RootSignatureDesc &RSD, if (std::optional Val = extractMdIntValue(StaticSamplerNode, 14)) Sampler.Flags = *Val; else - return make_error("Static Sampler Flags"); + return createRSError(RSErrorKind::InvalidMetadataValue, + StringRef("Static Sampler Flags")); RSD.StaticSamplers.push_back(Sampler); return Error::success(); @@ -521,7 +609,8 @@ Error MetadataParser::parseRootSignatureElement(mcdxbc::RootSignatureDesc &RSD, MDNode *Element) { std::optional ElementText = extractMdStringValue(Element, 0); if (!ElementText.has_value()) - return make_error("Root Element"); + return createRSError(RSErrorKind::InvalidMetadataFormat, + StringRef("Root Element")); RootSignatureElementKind ElementKind = StringSwitch(*ElementText) @@ -549,8 +638,8 @@ Error MetadataParser::parseRootSignatureElement(mcdxbc::RootSignatureDesc &RSD, case RootSignatureElementKind::StaticSamplers: return parseStaticSampler(RSD, Element); case RootSignatureElementKind::Error: - return make_error("Invalid Root Signature Element", - Element); + return createRSError(RSErrorKind::GenericMetadata, + StringRef("Invalid Root Signature Element"), Element); } llvm_unreachable("Unhandled RootSignatureElementKind enum."); @@ -563,7 +652,7 @@ validateDescriptorTableSamplerMixin(const mcdxbc::DescriptorTable &Table, for (const mcdxbc::DescriptorRange &Range : Table.Ranges) { if (Range.RangeType == dxil::ResourceClass::Sampler && CurrRC != dxil::ResourceClass::Sampler) - return make_error(CurrRC, Location); + return createRSError(RSErrorKind::SamplerMixin, CurrRC, Location); CurrRC = Range.RangeType; } return Error::success(); @@ -583,8 +672,8 @@ validateDescriptorTableRegisterOverflow(const mcdxbc::DescriptorTable &Table, Range.BaseShaderRegister, Range.NumDescriptors); if (!verifyNoOverflowedOffset(RangeBound)) - return make_error( - Range.RangeType, Range.BaseShaderRegister, Range.RegisterSpace); + return createRSError(RSErrorKind::ShaderRegisterOverflow, Range.RangeType, + Range.BaseShaderRegister, Range.RegisterSpace); bool IsAppending = Range.OffsetInDescriptorsFromTableStart == DescriptorTableOffsetAppend; @@ -592,15 +681,16 @@ validateDescriptorTableRegisterOverflow(const mcdxbc::DescriptorTable &Table, Offset = Range.OffsetInDescriptorsFromTableStart; if (IsPrevUnbound && IsAppending) - return make_error( - Range.RangeType, Range.BaseShaderRegister, Range.RegisterSpace); + return createRSError(RSErrorKind::AppendAfterUnboundedRange, + Range.RangeType, Range.BaseShaderRegister, + Range.RegisterSpace); const uint64_t OffsetBound = llvm::hlsl::rootsig::computeRangeBound(Offset, Range.NumDescriptors); if (!verifyNoOverflowedOffset(OffsetBound)) - return make_error( - Range.RangeType, Range.BaseShaderRegister, Range.RegisterSpace); + return createRSError(RSErrorKind::OffsetOverflow, Range.RangeType, + Range.BaseShaderRegister, Range.RegisterSpace); Offset = OffsetBound + 1; IsPrevUnbound = @@ -614,17 +704,15 @@ Error MetadataParser::validateRootSignature( const mcdxbc::RootSignatureDesc &RSD) { Error DeferredErrs = Error::success(); if (!hlsl::rootsig::verifyVersion(RSD.Version)) { - DeferredErrs = - joinErrors(std::move(DeferredErrs), - make_error>( - "Version", RSD.Version)); + DeferredErrs = joinErrors(std::move(DeferredErrs), + createRSError(RSErrorKind::Validation, + StringRef("Version"), RSD.Version)); } if (!hlsl::rootsig::verifyRootFlag(RSD.Flags)) { - DeferredErrs = - joinErrors(std::move(DeferredErrs), - make_error>( - "RootFlags", RSD.Flags)); + DeferredErrs = joinErrors(std::move(DeferredErrs), + createRSError(RSErrorKind::Validation, + StringRef("RootFlags"), RSD.Flags)); } for (const mcdxbc::RootParameterInfo &Info : RSD.ParametersContainer) { @@ -639,24 +727,24 @@ Error MetadataParser::validateRootSignature( const mcdxbc::RootDescriptor &Descriptor = RSD.ParametersContainer.getRootDescriptor(Info.Location); if (!hlsl::rootsig::verifyRegisterValue(Descriptor.ShaderRegister)) - DeferredErrs = - joinErrors(std::move(DeferredErrs), - make_error>( - "ShaderRegister", Descriptor.ShaderRegister)); + DeferredErrs = joinErrors(std::move(DeferredErrs), + createRSError(RSErrorKind::Validation, + StringRef("ShaderRegister"), + Descriptor.ShaderRegister)); if (!hlsl::rootsig::verifyRegisterSpace(Descriptor.RegisterSpace)) - DeferredErrs = - joinErrors(std::move(DeferredErrs), - make_error>( - "RegisterSpace", Descriptor.RegisterSpace)); + DeferredErrs = joinErrors(std::move(DeferredErrs), + createRSError(RSErrorKind::Validation, + StringRef("RegisterSpace"), + Descriptor.RegisterSpace)); if (RSD.Version > 1) { if (!hlsl::rootsig::verifyRootDescriptorFlag(RSD.Version, Descriptor.Flags)) - DeferredErrs = - joinErrors(std::move(DeferredErrs), - make_error>( - "RootDescriptorFlag", Descriptor.Flags)); + DeferredErrs = joinErrors( + std::move(DeferredErrs), + createRSError(RSErrorKind::Validation, + StringRef("RootDescriptorFlag"), Descriptor.Flags)); } break; } @@ -665,24 +753,24 @@ Error MetadataParser::validateRootSignature( RSD.ParametersContainer.getDescriptorTable(Info.Location); for (const mcdxbc::DescriptorRange &Range : Table) { if (!hlsl::rootsig::verifyRegisterSpace(Range.RegisterSpace)) - DeferredErrs = - joinErrors(std::move(DeferredErrs), - make_error>( - "RegisterSpace", Range.RegisterSpace)); + DeferredErrs = joinErrors(std::move(DeferredErrs), + createRSError(RSErrorKind::Validation, + StringRef("RegisterSpace"), + Range.RegisterSpace)); if (!hlsl::rootsig::verifyNumDescriptors(Range.NumDescriptors)) - DeferredErrs = - joinErrors(std::move(DeferredErrs), - make_error>( - "NumDescriptors", Range.NumDescriptors)); + DeferredErrs = joinErrors(std::move(DeferredErrs), + createRSError(RSErrorKind::Validation, + StringRef("NumDescriptors"), + Range.NumDescriptors)); if (!hlsl::rootsig::verifyDescriptorRangeFlag( RSD.Version, Range.RangeType, dxbc::DescriptorRangeFlags(Range.Flags))) - DeferredErrs = - joinErrors(std::move(DeferredErrs), - make_error>( - "DescriptorFlag", Range.Flags)); + DeferredErrs = joinErrors(std::move(DeferredErrs), + createRSError(RSErrorKind::Validation, + StringRef("DescriptorFlag"), + Range.Flags)); if (Error Err = validateDescriptorTableSamplerMixin(Table, Info.Location)) @@ -701,42 +789,45 @@ Error MetadataParser::validateRootSignature( if (!hlsl::rootsig::verifyMipLODBias(Sampler.MipLODBias)) DeferredErrs = joinErrors(std::move(DeferredErrs), - make_error>( - "MipLODBias", Sampler.MipLODBias)); + createRSError(RSErrorKind::Validation, + StringRef("MipLODBias"), + Sampler.MipLODBias)); if (!hlsl::rootsig::verifyMaxAnisotropy(Sampler.MaxAnisotropy)) - DeferredErrs = - joinErrors(std::move(DeferredErrs), - make_error>( - "MaxAnisotropy", Sampler.MaxAnisotropy)); + DeferredErrs = joinErrors(std::move(DeferredErrs), + createRSError(RSErrorKind::Validation, + StringRef("MaxAnisotropy"), + Sampler.MaxAnisotropy)); if (!hlsl::rootsig::verifyLOD(Sampler.MinLOD)) - DeferredErrs = joinErrors(std::move(DeferredErrs), - make_error>( - "MinLOD", Sampler.MinLOD)); + DeferredErrs = + joinErrors(std::move(DeferredErrs), + createRSError(RSErrorKind::Validation, StringRef("MinLOD"), + Sampler.MinLOD)); if (!hlsl::rootsig::verifyLOD(Sampler.MaxLOD)) - DeferredErrs = joinErrors(std::move(DeferredErrs), - make_error>( - "MaxLOD", Sampler.MaxLOD)); - - if (!hlsl::rootsig::verifyRegisterValue(Sampler.ShaderRegister)) DeferredErrs = joinErrors(std::move(DeferredErrs), - make_error>( - "ShaderRegister", Sampler.ShaderRegister)); + createRSError(RSErrorKind::Validation, StringRef("MaxLOD"), + Sampler.MaxLOD)); + + if (!hlsl::rootsig::verifyRegisterValue(Sampler.ShaderRegister)) + DeferredErrs = joinErrors(std::move(DeferredErrs), + createRSError(RSErrorKind::Validation, + StringRef("ShaderRegister"), + Sampler.ShaderRegister)); if (!hlsl::rootsig::verifyRegisterSpace(Sampler.RegisterSpace)) - DeferredErrs = - joinErrors(std::move(DeferredErrs), - make_error>( - "RegisterSpace", Sampler.RegisterSpace)); + DeferredErrs = joinErrors(std::move(DeferredErrs), + createRSError(RSErrorKind::Validation, + StringRef("RegisterSpace"), + Sampler.RegisterSpace)); if (!hlsl::rootsig::verifyStaticSamplerFlags(RSD.Version, Sampler.Flags)) - DeferredErrs = - joinErrors(std::move(DeferredErrs), - make_error>( - "Static Sampler Flag", Sampler.Flags)); + DeferredErrs = joinErrors(std::move(DeferredErrs), + createRSError(RSErrorKind::Validation, + StringRef("Static Sampler Flag"), + Sampler.Flags)); } return DeferredErrs; @@ -750,9 +841,10 @@ MetadataParser::ParseRootSignature(uint32_t Version) { for (const auto &Operand : Root->operands()) { MDNode *Element = dyn_cast(Operand); if (Element == nullptr) - return joinErrors(std::move(DeferredErrs), - make_error( - "Missing Root Element Metadata Node.", nullptr)); + return joinErrors( + std::move(DeferredErrs), + createRSError(RSErrorKind::GenericMetadata, + StringRef("Missing Root Element Metadata Node."))); if (auto Err = parseRootSignatureElement(RSD, Element)) DeferredErrs = joinErrors(std::move(DeferredErrs), std::move(Err)); From 4db9f54e7c59cb5305c18ed95e6c6f30fd1bf09d Mon Sep 17 00:00:00 2001 From: Joao Saffran Date: Mon, 6 Oct 2025 10:40:54 -0700 Subject: [PATCH 3/8] fix test --- llvm/lib/Frontend/HLSL/RootSignatureMetadata.cpp | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/llvm/lib/Frontend/HLSL/RootSignatureMetadata.cpp b/llvm/lib/Frontend/HLSL/RootSignatureMetadata.cpp index 7ed4ec0dc3457..cf4568d49c0f8 100644 --- a/llvm/lib/Frontend/HLSL/RootSignatureMetadata.cpp +++ b/llvm/lib/Frontend/HLSL/RootSignatureMetadata.cpp @@ -28,7 +28,7 @@ template void formatImpl(raw_string_ostream &Buff, std::integral_constant, StringRef ParamName, T Value) { - Buff << "Invalid value for: " << ParamName << ":"; + Buff << "Invalid value for " << ParamName << ": "; if constexpr (std::is_same_v, std::nullptr_t>) { Buff << "nullptr"; } else { @@ -844,7 +844,8 @@ MetadataParser::ParseRootSignature(uint32_t Version) { return joinErrors( std::move(DeferredErrs), createRSError(RSErrorKind::GenericMetadata, - StringRef("Missing Root Element Metadata Node."))); + StringRef("Missing Root Element Metadata Node."), + Element)); if (auto Err = parseRootSignatureElement(RSD, Element)) DeferredErrs = joinErrors(std::move(DeferredErrs), std::move(Err)); From 92e0913032c6ca89fc9699f001d53538ed859a31 Mon Sep 17 00:00:00 2001 From: Joao Saffran Date: Mon, 6 Oct 2025 15:02:19 -0700 Subject: [PATCH 4/8] formating --- llvm/lib/Frontend/HLSL/RootSignatureMetadata.cpp | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/llvm/lib/Frontend/HLSL/RootSignatureMetadata.cpp b/llvm/lib/Frontend/HLSL/RootSignatureMetadata.cpp index 73d91a47cab25..d58a17cd58ede 100644 --- a/llvm/lib/Frontend/HLSL/RootSignatureMetadata.cpp +++ b/llvm/lib/Frontend/HLSL/RootSignatureMetadata.cpp @@ -811,10 +811,10 @@ Error MetadataParser::validateRootSignature( Sampler.MinLOD)); if (!hlsl::rootsig::verifyLOD(Sampler.MaxLOD)) - DeferredErrs = - joinErrors(std::move(DeferredErrs), - createRSError(RSErrorKind::Validation, StringRef("MaxLOD"), - Sampler.MaxLOD)); + DeferredErrs = joinErrors(std::move(DeferredErrs), + createRSError(RSErrorKind::Validation, + StringRef("RegisterSpace"), + Sampler.RegisterSpace)); if (!hlsl::rootsig::verifyRegisterValue(Sampler.ShaderRegister)) DeferredErrs = joinErrors(std::move(DeferredErrs), From 3984b78a4b4ae910e767ebff5e030d73c113ddda Mon Sep 17 00:00:00 2001 From: joaosaffran Date: Tue, 7 Oct 2025 18:52:33 +0000 Subject: [PATCH 5/8] make messages inline --- .../Frontend/HLSL/RootSignatureMetadata.h | 116 +----- .../Frontend/HLSL/RootSignatureMetadata.cpp | 354 +++++++----------- 2 files changed, 156 insertions(+), 314 deletions(-) diff --git a/llvm/include/llvm/Frontend/HLSL/RootSignatureMetadata.h b/llvm/include/llvm/Frontend/HLSL/RootSignatureMetadata.h index 76d9e93e2470a..bac0e35cde9f9 100644 --- a/llvm/include/llvm/Frontend/HLSL/RootSignatureMetadata.h +++ b/llvm/include/llvm/Frontend/HLSL/RootSignatureMetadata.h @@ -19,6 +19,7 @@ #include "llvm/IR/Constants.h" #include "llvm/MC/DXContainerRootSignature.h" #include "llvm/Support/Compiler.h" +#include "llvm/Support/FormatVariadic.h" namespace llvm { class LLVMContext; @@ -27,113 +28,20 @@ class Metadata; namespace hlsl { namespace rootsig { +class RootSignatureValidationError + : public ErrorInfo { +public: + static char ID; + std::string Msg; -enum class RSErrorKind { - Validation, - AppendAfterUnboundedRange, - ShaderRegisterOverflow, - OffsetOverflow, - SamplerMixin, - GenericMetadata, - InvalidMetadataFormat, - InvalidMetadataValue -}; + RootSignatureValidationError(const Twine &Msg) : Msg(Msg.str()) {} -template -void formatImpl(raw_string_ostream &Buff, - std::integral_constant, - StringRef ParamName, T Value); - -void formatImpl( - raw_string_ostream &Buff, - std::integral_constant, - dxil::ResourceClass Type, uint32_t Register, uint32_t Space); - -void formatImpl( - raw_string_ostream &Buff, - std::integral_constant, - dxil::ResourceClass Type, uint32_t Register, uint32_t Space); - -void formatImpl( - raw_string_ostream &Buff, - std::integral_constant, - dxil::ResourceClass Type, uint32_t Register, uint32_t Space); - -void formatImpl(raw_string_ostream &Buff, - std::integral_constant, - dxil::ResourceClass Type, uint32_t Location); - -void formatImpl( - raw_string_ostream &Buff, - std::integral_constant, - StringRef ElementName); - -void formatImpl( - raw_string_ostream &Buff, - std::integral_constant, - StringRef ParamName); - -void formatImpl( - raw_string_ostream &Buff, - std::integral_constant, - StringRef Message, MDNode *MD); - -template -inline void formatImpl(raw_string_ostream &Buff, RSErrorKind Kind, - ArgsTs... Args) { - switch (Kind) { - case RSErrorKind::Validation: - return formatImpl( - Buff, std::integral_constant(), - Args...); - case RSErrorKind::AppendAfterUnboundedRange: - return formatImpl( - Buff, - std::integral_constant(), - Args...); - case RSErrorKind::ShaderRegisterOverflow: - return formatImpl( - Buff, - std::integral_constant(), - Args...); - case RSErrorKind::OffsetOverflow: - return formatImpl( - Buff, - std::integral_constant(), - Args...); - case RSErrorKind::SamplerMixin: - return formatImpl( - Buff, std::integral_constant(), - Args...); - case RSErrorKind::InvalidMetadataFormat: - return formatImpl( - Buff, - std::integral_constant(), - Args...); - case RSErrorKind::InvalidMetadataValue: - return formatImpl( - Buff, - std::integral_constant(), - Args...); - case RSErrorKind::GenericMetadata: - return formatImpl( - Buff, - std::integral_constant(), - Args...); - } -} + void log(raw_ostream &OS) const override { OS << Msg; } -template -static llvm::Error createRSError(RSErrorKind Kind, ArgsTs... Args) { - std::string Msg; - raw_string_ostream Buff(Msg); - formatImpl(Buff, Kind, Args...); - return createStringError(std::move(Buff.str()), inconvertibleErrorCode()); -} + std::error_code convertToErrorCode() const override { + return llvm::inconvertibleErrorCode(); + } +}; class MetadataBuilder { public: diff --git a/llvm/lib/Frontend/HLSL/RootSignatureMetadata.cpp b/llvm/lib/Frontend/HLSL/RootSignatureMetadata.cpp index d58a17cd58ede..e1fd1c39f96e4 100644 --- a/llvm/lib/Frontend/HLSL/RootSignatureMetadata.cpp +++ b/llvm/lib/Frontend/HLSL/RootSignatureMetadata.cpp @@ -16,6 +16,7 @@ #include "llvm/IR/IRBuilder.h" #include "llvm/IR/Metadata.h" #include "llvm/Support/DXILABI.h" +#include "llvm/Support/FormatVariadic.h" #include "llvm/Support/ScopedPrinter.h" using namespace llvm; @@ -24,75 +25,7 @@ namespace llvm { namespace hlsl { namespace rootsig { -template -void formatImpl(raw_string_ostream &Buff, - std::integral_constant, - StringRef ParamName, T Value) { - Buff << "Invalid value for " << ParamName << ": "; - if constexpr (std::is_same_v, std::nullptr_t>) { - Buff << "nullptr"; - } else { - Buff << Value; - } -} - -void formatImpl( - raw_string_ostream &Buff, - std::integral_constant, - dxil::ResourceClass Type, uint32_t Register, uint32_t Space) { - Buff << "Range " << getResourceClassName(Type) << "(register=" << Register - << ", space=" << Space << ") " - << "cannot be appended after an unbounded range "; -} - -void formatImpl( - raw_string_ostream &Buff, - std::integral_constant, - dxil::ResourceClass Type, uint32_t Register, uint32_t Space) { - Buff << "Overflow for shader register range: " << getResourceClassName(Type) - << "(register=" << Register << ", space=" << Space << ")."; -} - -void formatImpl( - raw_string_ostream &Buff, - std::integral_constant, - dxil::ResourceClass Type, uint32_t Register, uint32_t Space) { - Buff << "Offset overflow for descriptor range: " << getResourceClassName(Type) - << "(register=" << Register << ", space=" << Space << ")."; -} - -void formatImpl(raw_string_ostream &Buff, - std::integral_constant, - dxil::ResourceClass Type, uint32_t Location) { - Buff << "Samplers cannot be mixed with other " - << "resource types in a descriptor table, " << getResourceClassName(Type) - << "(location=" << Location << ")"; -} - -void formatImpl( - raw_string_ostream &Buff, - std::integral_constant, - StringRef ElementName) { - Buff << "Invalid format for " << ElementName; -} - -void formatImpl( - raw_string_ostream &Buff, - std::integral_constant, - StringRef ParamName) { - Buff << "Invalid value for " << ParamName; -} - -void formatImpl( - raw_string_ostream &Buff, - std::integral_constant, - StringRef Message, MDNode *MD) { - Buff << Message; - if (MD) { - Buff << "\n"; - MD->printTree(Buff); - } -} +char RootSignatureValidationError::ID; static std::optional extractMdIntValue(MDNode *Node, unsigned int OpId) { @@ -117,21 +50,6 @@ static std::optional extractMdStringValue(MDNode *Node, return NodeText->getString(); } -template && - std::is_same_v, uint32_t>>> -static Expected -extractEnumValue(MDNode *Node, unsigned int OpId, StringRef ErrText, - llvm::function_ref VerifyFn) { - if (std::optional Val = extractMdIntValue(Node, OpId)) { - if (!VerifyFn(*Val)) - return createRSError(RSErrorKind::Validation, ErrText, *Val); - return static_cast(*Val); - } - return createRSError(RSErrorKind::InvalidMetadataValue, - StringRef("ShaderVisibility")); -} - namespace { // We use the OverloadVisit with std::visit to ensure the compiler catches if a @@ -142,8 +60,52 @@ template struct OverloadedVisit : Ts... { }; template OverloadedVisit(Ts...) -> OverloadedVisit; +struct FmtRange { + dxil::ResourceClass Type; + uint32_t Register; + uint32_t Space; + + FmtRange(const mcdxbc::DescriptorRange &Range) + : Type(Range.RangeType), Register(Range.BaseShaderRegister), + Space(Range.RegisterSpace) {} +}; + +raw_ostream &operator<<(llvm::raw_ostream &OS, const FmtRange &Range) { + OS << getResourceClassName(Range.Type) << "(register=" << Range.Register + << ", space=" << Range.Space << ")"; + return OS; +} + +struct FmtMDNode { + const MDNode *Node; + + FmtMDNode(const MDNode *Node) : Node(Node) {} +}; + +raw_ostream &operator<<(llvm::raw_ostream &OS, FmtMDNode Fmt) { + Fmt.Node->printTree(OS); + return OS; +} + +static Error makeRSError(const Twine &Msg) { + return make_error(Msg); +} } // namespace +template && + std::is_same_v, uint32_t>>> +static Expected +extractEnumValue(MDNode *Node, unsigned int OpId, StringRef ErrText, + llvm::function_ref VerifyFn) { + if (std::optional Val = extractMdIntValue(Node, OpId)) { + if (!VerifyFn(*Val)) + return makeRSError(formatv("Invalid value for {0}: {1}", ErrText, Val)); + return static_cast(*Val); + } + return makeRSError(formatv("Invalid value for ShaderVisibility")); +} + MDNode *MetadataBuilder::BuildRootSignature() { const auto Visitor = OverloadedVisit{ [this](const dxbc::RootFlags &Flags) -> MDNode * { @@ -287,14 +249,12 @@ MDNode *MetadataBuilder::BuildStaticSampler(const StaticSampler &Sampler) { Error MetadataParser::parseRootFlags(mcdxbc::RootSignatureDesc &RSD, MDNode *RootFlagNode) { if (RootFlagNode->getNumOperands() != 2) - return createRSError(RSErrorKind::InvalidMetadataFormat, - StringRef("RootFlags Element")); + return makeRSError("Invalid format for RootFlags Element"); if (std::optional Val = extractMdIntValue(RootFlagNode, 1)) RSD.Flags = *Val; else - return createRSError(RSErrorKind::InvalidMetadataValue, - StringRef("RootFlag")); + return makeRSError("Invalid value for RootFlag"); return Error::success(); } @@ -302,8 +262,7 @@ Error MetadataParser::parseRootFlags(mcdxbc::RootSignatureDesc &RSD, Error MetadataParser::parseRootConstants(mcdxbc::RootSignatureDesc &RSD, MDNode *RootConstantNode) { if (RootConstantNode->getNumOperands() != 5) - return createRSError(RSErrorKind::InvalidMetadataFormat, - StringRef("RootConstants Element")); + return makeRSError("Invalid format for RootConstants Element"); Expected Visibility = extractEnumValue(RootConstantNode, 1, @@ -316,20 +275,17 @@ Error MetadataParser::parseRootConstants(mcdxbc::RootSignatureDesc &RSD, if (std::optional Val = extractMdIntValue(RootConstantNode, 2)) Constants.ShaderRegister = *Val; else - return createRSError(RSErrorKind::InvalidMetadataValue, - StringRef("ShaderRegister")); + return makeRSError("Invalid value for ShaderRegister"); if (std::optional Val = extractMdIntValue(RootConstantNode, 3)) Constants.RegisterSpace = *Val; else - return createRSError(RSErrorKind::InvalidMetadataValue, - StringRef("RegisterSpace")); + return makeRSError("Invalid value for RegisterSpace"); if (std::optional Val = extractMdIntValue(RootConstantNode, 4)) Constants.Num32BitValues = *Val; else - return createRSError(RSErrorKind::InvalidMetadataValue, - StringRef("Num32BitValues")); + return makeRSError("Invalid value for Num32BitValues"); RSD.ParametersContainer.addParameter(dxbc::RootParameterType::Constants32Bit, *Visibility, Constants); @@ -346,8 +302,7 @@ Error MetadataParser::parseRootDescriptors( "parseRootDescriptors should only be called with RootDescriptor " "element kind."); if (RootDescriptorNode->getNumOperands() != 5) - return createRSError(RSErrorKind::InvalidMetadataFormat, - StringRef("Root Descriptor Element")); + return makeRSError("Invalid format for Root Descriptor Element"); dxbc::RootParameterType Type; switch (ElementKind) { @@ -376,14 +331,12 @@ Error MetadataParser::parseRootDescriptors( if (std::optional Val = extractMdIntValue(RootDescriptorNode, 2)) Descriptor.ShaderRegister = *Val; else - return createRSError(RSErrorKind::InvalidMetadataValue, - StringRef("ShaderRegister")); + return makeRSError("Invalid value for ShaderRegister"); if (std::optional Val = extractMdIntValue(RootDescriptorNode, 3)) Descriptor.RegisterSpace = *Val; else - return createRSError(RSErrorKind::InvalidMetadataValue, - StringRef("RegisterSpace")); + return makeRSError("Invalid value for RegisterSpace"); if (RSD.Version == 1) { RSD.ParametersContainer.addParameter(Type, *Visibility, Descriptor); @@ -394,8 +347,7 @@ Error MetadataParser::parseRootDescriptors( if (std::optional Val = extractMdIntValue(RootDescriptorNode, 4)) Descriptor.Flags = *Val; else - return createRSError(RSErrorKind::InvalidMetadataValue, - StringRef("Root Descriptor Flags")); + return makeRSError("Invalid value for Root Descriptor Flags"); RSD.ParametersContainer.addParameter(Type, *Visibility, Descriptor); return Error::success(); @@ -404,8 +356,7 @@ Error MetadataParser::parseRootDescriptors( Error MetadataParser::parseDescriptorRange(mcdxbc::DescriptorTable &Table, MDNode *RangeDescriptorNode) { if (RangeDescriptorNode->getNumOperands() != 6) - return createRSError(RSErrorKind::InvalidMetadataFormat, - StringRef("Descriptor Range")); + return makeRSError("Invalid format for Descriptor Range"); mcdxbc::DescriptorRange Range; @@ -413,8 +364,7 @@ Error MetadataParser::parseDescriptorRange(mcdxbc::DescriptorTable &Table, extractMdStringValue(RangeDescriptorNode, 0); if (!ElementText.has_value()) - return createRSError(RSErrorKind::InvalidMetadataFormat, - StringRef("Descriptor Range")); + return makeRSError("Invalid format for Descriptor Range"); if (*ElementText == "CBV") Range.RangeType = dxil::ResourceClass::CBuffer; @@ -425,40 +375,34 @@ Error MetadataParser::parseDescriptorRange(mcdxbc::DescriptorTable &Table, else if (*ElementText == "Sampler") Range.RangeType = dxil::ResourceClass::Sampler; else - return createRSError(RSErrorKind::GenericMetadata, - StringRef("Invalid Descriptor Range type."), - RangeDescriptorNode); + return makeRSError(formatv("Invalid Descriptor Range type. \n {0}", + FmtMDNode{RangeDescriptorNode})); if (std::optional Val = extractMdIntValue(RangeDescriptorNode, 1)) Range.NumDescriptors = *Val; else - return createRSError(RSErrorKind::GenericMetadata, - StringRef("Number of Descriptor in Range"), - RangeDescriptorNode); + return makeRSError(formatv("Invalid number of Descriptor in Range. \n {0}", + FmtMDNode{RangeDescriptorNode})); if (std::optional Val = extractMdIntValue(RangeDescriptorNode, 2)) Range.BaseShaderRegister = *Val; else - return createRSError(RSErrorKind::InvalidMetadataValue, - StringRef("BaseShaderRegister")); + return makeRSError("Invalid value for BaseShaderRegister"); if (std::optional Val = extractMdIntValue(RangeDescriptorNode, 3)) Range.RegisterSpace = *Val; else - return createRSError(RSErrorKind::InvalidMetadataValue, - StringRef("RegisterSpace")); + return makeRSError("Invalid value for RegisterSpace"); if (std::optional Val = extractMdIntValue(RangeDescriptorNode, 4)) Range.OffsetInDescriptorsFromTableStart = *Val; else - return createRSError(RSErrorKind::InvalidMetadataValue, - StringRef("OffsetInDescriptorsFromTableStart")); + return makeRSError("Invalid value for OffsetInDescriptorsFromTableStart"); if (std::optional Val = extractMdIntValue(RangeDescriptorNode, 5)) Range.Flags = *Val; else - return createRSError(RSErrorKind::InvalidMetadataValue, - StringRef("Descriptor Range Flags")); + return makeRSError("Invalid value for Descriptor Range Flags"); Table.Ranges.push_back(Range); return Error::success(); @@ -468,8 +412,7 @@ Error MetadataParser::parseDescriptorTable(mcdxbc::RootSignatureDesc &RSD, MDNode *DescriptorTableNode) { const unsigned int NumOperands = DescriptorTableNode->getNumOperands(); if (NumOperands < 2) - return createRSError(RSErrorKind::InvalidMetadataFormat, - StringRef("Descriptor Table")); + return makeRSError("Invalid format for Descriptor Table"); Expected Visibility = extractEnumValue(DescriptorTableNode, 1, @@ -483,9 +426,8 @@ Error MetadataParser::parseDescriptorTable(mcdxbc::RootSignatureDesc &RSD, for (unsigned int I = 2; I < NumOperands; I++) { MDNode *Element = dyn_cast(DescriptorTableNode->getOperand(I)); if (Element == nullptr) - return createRSError(RSErrorKind::GenericMetadata, - StringRef("Missing Root Element Metadata Node."), - DescriptorTableNode); + return makeRSError(formatv("Missing Root Element Metadata Node.\n {0}", + FmtMDNode{DescriptorTableNode})); if (auto Err = parseDescriptorRange(Table, Element)) return Err; @@ -499,8 +441,7 @@ Error MetadataParser::parseDescriptorTable(mcdxbc::RootSignatureDesc &RSD, Error MetadataParser::parseStaticSampler(mcdxbc::RootSignatureDesc &RSD, MDNode *StaticSamplerNode) { if (StaticSamplerNode->getNumOperands() != 15) - return createRSError(RSErrorKind::InvalidMetadataFormat, - StringRef("Static Sampler")); + return makeRSError("Invalid format for Static Sampler"); mcdxbc::StaticSampler Sampler; @@ -534,14 +475,12 @@ Error MetadataParser::parseStaticSampler(mcdxbc::RootSignatureDesc &RSD, if (std::optional Val = extractMdFloatValue(StaticSamplerNode, 5)) Sampler.MipLODBias = *Val; else - return createRSError(RSErrorKind::InvalidMetadataValue, - StringRef("MipLODBias")); + return makeRSError("Invalid value for MipLODBias"); if (std::optional Val = extractMdIntValue(StaticSamplerNode, 6)) Sampler.MaxAnisotropy = *Val; else - return createRSError(RSErrorKind::InvalidMetadataValue, - StringRef("MaxAnisotropy")); + return makeRSError("Invalid value for MaxAnisotropy"); Expected ComparisonFunc = extractEnumValue( @@ -560,26 +499,22 @@ Error MetadataParser::parseStaticSampler(mcdxbc::RootSignatureDesc &RSD, if (std::optional Val = extractMdFloatValue(StaticSamplerNode, 9)) Sampler.MinLOD = *Val; else - return createRSError(RSErrorKind::InvalidMetadataValue, - StringRef("MinLOD")); + return makeRSError("Invalid value for MinLOD"); if (std::optional Val = extractMdFloatValue(StaticSamplerNode, 10)) Sampler.MaxLOD = *Val; else - return createRSError(RSErrorKind::InvalidMetadataValue, - StringRef("MaxLOD")); + return makeRSError("Invalid value for MaxLOD"); if (std::optional Val = extractMdIntValue(StaticSamplerNode, 11)) Sampler.ShaderRegister = *Val; else - return createRSError(RSErrorKind::InvalidMetadataValue, - StringRef("ShaderRegister")); + return makeRSError("Invalid value for ShaderRegister"); if (std::optional Val = extractMdIntValue(StaticSamplerNode, 12)) Sampler.RegisterSpace = *Val; else - return createRSError(RSErrorKind::InvalidMetadataValue, - StringRef("RegisterSpace")); + return makeRSError("Invalid value for RegisterSpace"); Expected Visibility = extractEnumValue(StaticSamplerNode, 13, @@ -598,8 +533,7 @@ Error MetadataParser::parseStaticSampler(mcdxbc::RootSignatureDesc &RSD, if (std::optional Val = extractMdIntValue(StaticSamplerNode, 14)) Sampler.Flags = *Val; else - return createRSError(RSErrorKind::InvalidMetadataValue, - StringRef("Static Sampler Flags")); + return makeRSError("Invalid value for Static Sampler Flags"); RSD.StaticSamplers.push_back(Sampler); return Error::success(); @@ -609,8 +543,7 @@ Error MetadataParser::parseRootSignatureElement(mcdxbc::RootSignatureDesc &RSD, MDNode *Element) { std::optional ElementText = extractMdStringValue(Element, 0); if (!ElementText.has_value()) - return createRSError(RSErrorKind::InvalidMetadataFormat, - StringRef("Root Element")); + return makeRSError("Invalid format for Root Element"); RootSignatureElementKind ElementKind = StringSwitch(*ElementText) @@ -638,8 +571,8 @@ Error MetadataParser::parseRootSignatureElement(mcdxbc::RootSignatureDesc &RSD, case RootSignatureElementKind::StaticSamplers: return parseStaticSampler(RSD, Element); case RootSignatureElementKind::Error: - return createRSError(RSErrorKind::GenericMetadata, - StringRef("Invalid Root Signature Element"), Element); + return makeRSError( + formatv("Invalid Root Signature Element\n {0}", FmtMDNode{Element})); } llvm_unreachable("Unhandled RootSignatureElementKind enum."); @@ -652,7 +585,10 @@ validateDescriptorTableSamplerMixin(const mcdxbc::DescriptorTable &Table, for (const mcdxbc::DescriptorRange &Range : Table.Ranges) { if (Range.RangeType == dxil::ResourceClass::Sampler && CurrRC != dxil::ResourceClass::Sampler) - return createRSError(RSErrorKind::SamplerMixin, CurrRC, Location); + return makeRSError( + formatv("Samplers cannot be mixed with other resource types in a " + "descriptor table, {0}(location={1})", + getResourceClassName(CurrRC), Location)); CurrRC = Range.RangeType; } return Error::success(); @@ -672,8 +608,8 @@ validateDescriptorTableRegisterOverflow(const mcdxbc::DescriptorTable &Table, Range.BaseShaderRegister, Range.NumDescriptors); if (!verifyNoOverflowedOffset(RangeBound)) - return createRSError(RSErrorKind::ShaderRegisterOverflow, Range.RangeType, - Range.BaseShaderRegister, Range.RegisterSpace); + return makeRSError( + formatv("Overflow for shader register range: {0}", FmtRange{Range})); bool IsAppending = Range.OffsetInDescriptorsFromTableStart == DescriptorTableOffsetAppend; @@ -681,16 +617,16 @@ validateDescriptorTableRegisterOverflow(const mcdxbc::DescriptorTable &Table, Offset = Range.OffsetInDescriptorsFromTableStart; if (IsPrevUnbound && IsAppending) - return createRSError(RSErrorKind::AppendAfterUnboundedRange, - Range.RangeType, Range.BaseShaderRegister, - Range.RegisterSpace); + return makeRSError( + formatv("Range {0} cannot be appended after an unbounded range", + FmtRange{Range})); const uint64_t OffsetBound = llvm::hlsl::rootsig::computeRangeBound(Offset, Range.NumDescriptors); if (!verifyNoOverflowedOffset(OffsetBound)) - return createRSError(RSErrorKind::OffsetOverflow, Range.RangeType, - Range.BaseShaderRegister, Range.RegisterSpace); + return makeRSError(formatv("Offset overflow for descriptor range: {0}.", + FmtRange{Range})); Offset = OffsetBound + 1; IsPrevUnbound = @@ -704,15 +640,15 @@ Error MetadataParser::validateRootSignature( const mcdxbc::RootSignatureDesc &RSD) { Error DeferredErrs = Error::success(); if (!hlsl::rootsig::verifyVersion(RSD.Version)) { - DeferredErrs = joinErrors(std::move(DeferredErrs), - createRSError(RSErrorKind::Validation, - StringRef("Version"), RSD.Version)); + DeferredErrs = joinErrors( + std::move(DeferredErrs), + makeRSError(formatv("Invalid value for Version: {0}", RSD.Version))); } if (!hlsl::rootsig::verifyRootFlag(RSD.Flags)) { - DeferredErrs = joinErrors(std::move(DeferredErrs), - createRSError(RSErrorKind::Validation, - StringRef("RootFlags"), RSD.Flags)); + DeferredErrs = joinErrors( + std::move(DeferredErrs), + makeRSError(formatv("Invalid value for RootFlags: {0}", RSD.Flags))); } for (const mcdxbc::RootParameterInfo &Info : RSD.ParametersContainer) { @@ -727,16 +663,16 @@ Error MetadataParser::validateRootSignature( const mcdxbc::RootDescriptor &Descriptor = RSD.ParametersContainer.getRootDescriptor(Info.Location); if (!hlsl::rootsig::verifyRegisterValue(Descriptor.ShaderRegister)) - DeferredErrs = joinErrors(std::move(DeferredErrs), - createRSError(RSErrorKind::Validation, - StringRef("ShaderRegister"), - Descriptor.ShaderRegister)); + DeferredErrs = joinErrors( + std::move(DeferredErrs), + makeRSError(formatv("Invalid value for ShaderRegister: {0}", + Descriptor.ShaderRegister))); if (!hlsl::rootsig::verifyRegisterSpace(Descriptor.RegisterSpace)) - DeferredErrs = joinErrors(std::move(DeferredErrs), - createRSError(RSErrorKind::Validation, - StringRef("RegisterSpace"), - Descriptor.RegisterSpace)); + DeferredErrs = joinErrors( + std::move(DeferredErrs), + makeRSError(formatv("Invalid value for RegisterSpace: {0}", + Descriptor.RegisterSpace))); if (RSD.Version > 1) { bool IsValidFlag = @@ -746,8 +682,8 @@ Error MetadataParser::validateRootSignature( if (!IsValidFlag) DeferredErrs = joinErrors( std::move(DeferredErrs), - createRSError(RSErrorKind::Validation, - StringRef("RootDescriptorFlag"), Descriptor.Flags)); + makeRSError(formatv("Invalid value for RootDescriptorFlag: {0}", + Descriptor.Flags))); } break; } @@ -756,26 +692,26 @@ Error MetadataParser::validateRootSignature( RSD.ParametersContainer.getDescriptorTable(Info.Location); for (const mcdxbc::DescriptorRange &Range : Table) { if (!hlsl::rootsig::verifyRegisterSpace(Range.RegisterSpace)) - DeferredErrs = joinErrors(std::move(DeferredErrs), - createRSError(RSErrorKind::Validation, - StringRef("RegisterSpace"), - Range.RegisterSpace)); + DeferredErrs = joinErrors( + std::move(DeferredErrs), + makeRSError(formatv("Invalid value for RegisterSpace: {0}", + Range.RegisterSpace))); if (!hlsl::rootsig::verifyNumDescriptors(Range.NumDescriptors)) - DeferredErrs = joinErrors(std::move(DeferredErrs), - createRSError(RSErrorKind::Validation, - StringRef("NumDescriptors"), - Range.NumDescriptors)); + DeferredErrs = joinErrors( + std::move(DeferredErrs), + makeRSError(formatv("Invalid value for NumDescriptors: {0}", + Range.NumDescriptors))); bool IsValidFlag = dxbc::isValidDescriptorRangeFlags(Range.Flags) && hlsl::rootsig::verifyDescriptorRangeFlag( RSD.Version, Range.RangeType, dxbc::DescriptorRangeFlags(Range.Flags)); if (!IsValidFlag) - DeferredErrs = joinErrors(std::move(DeferredErrs), - createRSError(RSErrorKind::Validation, - StringRef("DescriptorFlag"), - Range.Flags)); + DeferredErrs = joinErrors( + std::move(DeferredErrs), + makeRSError(formatv("Invalid value for DescriptorFlag: {0}", + Range.Flags))); if (Error Err = validateDescriptorTableSamplerMixin(Table, Info.Location)) @@ -793,49 +729,49 @@ Error MetadataParser::validateRootSignature( for (const mcdxbc::StaticSampler &Sampler : RSD.StaticSamplers) { if (!hlsl::rootsig::verifyMipLODBias(Sampler.MipLODBias)) - DeferredErrs = joinErrors(std::move(DeferredErrs), - createRSError(RSErrorKind::Validation, - StringRef("MipLODBias"), - Sampler.MipLODBias)); + DeferredErrs = + joinErrors(std::move(DeferredErrs), + makeRSError(formatv("Invalid value for MipLODBias: {0:e}", + Sampler.MipLODBias))); if (!hlsl::rootsig::verifyMaxAnisotropy(Sampler.MaxAnisotropy)) - DeferredErrs = joinErrors(std::move(DeferredErrs), - createRSError(RSErrorKind::Validation, - StringRef("MaxAnisotropy"), - Sampler.MaxAnisotropy)); + DeferredErrs = + joinErrors(std::move(DeferredErrs), + makeRSError(formatv("Invalid value for MaxAnisotropy: {0}", + Sampler.MaxAnisotropy))); if (!hlsl::rootsig::verifyLOD(Sampler.MinLOD)) DeferredErrs = joinErrors(std::move(DeferredErrs), - createRSError(RSErrorKind::Validation, StringRef("MinLOD"), - Sampler.MinLOD)); + makeRSError(formatv("Invalid value for MinLOD: {0}", + Sampler.MinLOD))); if (!hlsl::rootsig::verifyLOD(Sampler.MaxLOD)) - DeferredErrs = joinErrors(std::move(DeferredErrs), - createRSError(RSErrorKind::Validation, - StringRef("RegisterSpace"), - Sampler.RegisterSpace)); + DeferredErrs = + joinErrors(std::move(DeferredErrs), + makeRSError(formatv("Invalid value for MaxLOD: {0}", + Sampler.MaxLOD))); if (!hlsl::rootsig::verifyRegisterValue(Sampler.ShaderRegister)) - DeferredErrs = joinErrors(std::move(DeferredErrs), - createRSError(RSErrorKind::Validation, - StringRef("ShaderRegister"), - Sampler.ShaderRegister)); + DeferredErrs = joinErrors( + std::move(DeferredErrs), + makeRSError(formatv("Invalid value for ShaderRegister: {0}", + Sampler.ShaderRegister))); if (!hlsl::rootsig::verifyRegisterSpace(Sampler.RegisterSpace)) DeferredErrs = joinErrors(std::move(DeferredErrs), - createRSError(RSErrorKind::Validation, StringRef( - "RegisterSpace"), Sampler.RegisterSpace)); + makeRSError(formatv("Invalid value for RegisterSpace: {0}", + Sampler.RegisterSpace))); bool IsValidFlag = dxbc::isValidStaticSamplerFlags(Sampler.Flags) && hlsl::rootsig::verifyStaticSamplerFlags( RSD.Version, dxbc::StaticSamplerFlags(Sampler.Flags)); if (!IsValidFlag) - DeferredErrs = joinErrors(std::move(DeferredErrs), - createRSError(RSErrorKind::Validation, - StringRef("Static Sampler Flag"), - Sampler.Flags)); + DeferredErrs = joinErrors( + std::move(DeferredErrs), + makeRSError(formatv("Invalid value for Static Sampler Flag: {0}", + Sampler.Flags))); } return DeferredErrs; @@ -851,9 +787,7 @@ MetadataParser::ParseRootSignature(uint32_t Version) { if (Element == nullptr) return joinErrors( std::move(DeferredErrs), - createRSError(RSErrorKind::GenericMetadata, - StringRef("Missing Root Element Metadata Node."), - Element)); + makeRSError(formatv("Missing Root Element Metadata Node."))); if (auto Err = parseRootSignatureElement(RSD, Element)) DeferredErrs = joinErrors(std::move(DeferredErrs), std::move(Err)); From d1d40af740b84a05c107d081fc4df357120b28e8 Mon Sep 17 00:00:00 2001 From: joaosaffran Date: Tue, 7 Oct 2025 18:59:29 +0000 Subject: [PATCH 6/8] clean up --- llvm/include/llvm/Frontend/HLSL/RootSignatureMetadata.h | 1 - llvm/lib/Frontend/HLSL/RootSignatureMetadata.cpp | 1 - 2 files changed, 2 deletions(-) diff --git a/llvm/include/llvm/Frontend/HLSL/RootSignatureMetadata.h b/llvm/include/llvm/Frontend/HLSL/RootSignatureMetadata.h index bac0e35cde9f9..7ef6667a5437d 100644 --- a/llvm/include/llvm/Frontend/HLSL/RootSignatureMetadata.h +++ b/llvm/include/llvm/Frontend/HLSL/RootSignatureMetadata.h @@ -19,7 +19,6 @@ #include "llvm/IR/Constants.h" #include "llvm/MC/DXContainerRootSignature.h" #include "llvm/Support/Compiler.h" -#include "llvm/Support/FormatVariadic.h" namespace llvm { class LLVMContext; diff --git a/llvm/lib/Frontend/HLSL/RootSignatureMetadata.cpp b/llvm/lib/Frontend/HLSL/RootSignatureMetadata.cpp index e1fd1c39f96e4..37128a63ce330 100644 --- a/llvm/lib/Frontend/HLSL/RootSignatureMetadata.cpp +++ b/llvm/lib/Frontend/HLSL/RootSignatureMetadata.cpp @@ -16,7 +16,6 @@ #include "llvm/IR/IRBuilder.h" #include "llvm/IR/Metadata.h" #include "llvm/Support/DXILABI.h" -#include "llvm/Support/FormatVariadic.h" #include "llvm/Support/ScopedPrinter.h" using namespace llvm; From 9ec499f4c17b1396a4035dcd4c62b3f7d4d1f9a5 Mon Sep 17 00:00:00 2001 From: joaosaffran Date: Tue, 7 Oct 2025 23:09:16 +0000 Subject: [PATCH 7/8] fix typos --- llvm/.clang-format | 1 - llvm/lib/Frontend/HLSL/RootSignatureMetadata.cpp | 10 +++++----- 2 files changed, 5 insertions(+), 6 deletions(-) diff --git a/llvm/.clang-format b/llvm/.clang-format index ecb44bfabd9aa..9b3aa8b7213b2 100644 --- a/llvm/.clang-format +++ b/llvm/.clang-format @@ -1,2 +1 @@ BasedOnStyle: LLVM -LineEnding: LF diff --git a/llvm/lib/Frontend/HLSL/RootSignatureMetadata.cpp b/llvm/lib/Frontend/HLSL/RootSignatureMetadata.cpp index 37128a63ce330..63189f458d12c 100644 --- a/llvm/lib/Frontend/HLSL/RootSignatureMetadata.cpp +++ b/llvm/lib/Frontend/HLSL/RootSignatureMetadata.cpp @@ -102,7 +102,7 @@ extractEnumValue(MDNode *Node, unsigned int OpId, StringRef ErrText, return makeRSError(formatv("Invalid value for {0}: {1}", ErrText, Val)); return static_cast(*Val); } - return makeRSError(formatv("Invalid value for ShaderVisibility")); + return makeRSError(formatv("Invalid value for {0}:", ErrText)); } MDNode *MetadataBuilder::BuildRootSignature() { @@ -374,13 +374,13 @@ Error MetadataParser::parseDescriptorRange(mcdxbc::DescriptorTable &Table, else if (*ElementText == "Sampler") Range.RangeType = dxil::ResourceClass::Sampler; else - return makeRSError(formatv("Invalid Descriptor Range type. \n {0}", + return makeRSError(formatv("Invalid Descriptor Range type.\n{0}", FmtMDNode{RangeDescriptorNode})); if (std::optional Val = extractMdIntValue(RangeDescriptorNode, 1)) Range.NumDescriptors = *Val; else - return makeRSError(formatv("Invalid number of Descriptor in Range. \n {0}", + return makeRSError(formatv("Invalid number of Descriptor in Range.\n{0}", FmtMDNode{RangeDescriptorNode})); if (std::optional Val = extractMdIntValue(RangeDescriptorNode, 2)) @@ -425,7 +425,7 @@ Error MetadataParser::parseDescriptorTable(mcdxbc::RootSignatureDesc &RSD, for (unsigned int I = 2; I < NumOperands; I++) { MDNode *Element = dyn_cast(DescriptorTableNode->getOperand(I)); if (Element == nullptr) - return makeRSError(formatv("Missing Root Element Metadata Node.\n {0}", + return makeRSError(formatv("Missing Root Element Metadata Node.\n{0}", FmtMDNode{DescriptorTableNode})); if (auto Err = parseDescriptorRange(Table, Element)) @@ -571,7 +571,7 @@ Error MetadataParser::parseRootSignatureElement(mcdxbc::RootSignatureDesc &RSD, return parseStaticSampler(RSD, Element); case RootSignatureElementKind::Error: return makeRSError( - formatv("Invalid Root Signature Element\n {0}", FmtMDNode{Element})); + formatv("Invalid Root Signature Element\n{0}", FmtMDNode{Element})); } llvm_unreachable("Unhandled RootSignatureElementKind enum."); From 5b60e9df4949e8afea79538ce2d4cc17fb7c7856 Mon Sep 17 00:00:00 2001 From: joaosaffran Date: Tue, 7 Oct 2025 23:14:04 +0000 Subject: [PATCH 8/8] fix oopsy --- llvm/.clang-format | 1 + 1 file changed, 1 insertion(+) diff --git a/llvm/.clang-format b/llvm/.clang-format index 9b3aa8b7213b2..ecb44bfabd9aa 100644 --- a/llvm/.clang-format +++ b/llvm/.clang-format @@ -1 +1,2 @@ BasedOnStyle: LLVM +LineEnding: LF