diff options
Diffstat (limited to 'source')
203 files changed, 7255 insertions, 3068 deletions
diff --git a/source/compiler-core/slang-artifact-associated-impl.cpp b/source/compiler-core/slang-artifact-associated-impl.cpp index cbecd1360..88ed9f665 100644 --- a/source/compiler-core/slang-artifact-associated-impl.cpp +++ b/source/compiler-core/slang-artifact-associated-impl.cpp @@ -196,10 +196,14 @@ void ArtifactDiagnostics::requireErrorDiagnostic() typedef ArtifactDiagnostic::Severity Severity; switch (severity) { - default: return UnownedStringSlice::fromLiteral("Unknown"); - case Severity::Info: return UnownedStringSlice::fromLiteral("Info"); - case Severity::Warning: return UnownedStringSlice::fromLiteral("Warning"); - case Severity::Error: return UnownedStringSlice::fromLiteral("Error"); + default: + return UnownedStringSlice::fromLiteral("Unknown"); + case Severity::Info: + return UnownedStringSlice::fromLiteral("Info"); + case Severity::Warning: + return UnownedStringSlice::fromLiteral("Warning"); + case Severity::Error: + return UnownedStringSlice::fromLiteral("Error"); } } diff --git a/source/compiler-core/slang-artifact-associated-impl.h b/source/compiler-core/slang-artifact-associated-impl.h index 515cedb2d..ff8f03163 100644 --- a/source/compiler-core/slang-artifact-associated-impl.h +++ b/source/compiler-core/slang-artifact-associated-impl.h @@ -162,8 +162,10 @@ struct ShaderBindingRange case slang::ShaderResource: case slang::UnorderedAccess: case slang::SamplerState: - case slang::DescriptorTableSlot: return true; - default: return false; + case slang::DescriptorTableSlot: + return true; + default: + return false; } } }; diff --git a/source/compiler-core/slang-artifact-container-util.cpp b/source/compiler-core/slang-artifact-container-util.cpp index 935cabe8f..574028c48 100644 --- a/source/compiler-core/slang-artifact-container-util.cpp +++ b/source/compiler-core/slang-artifact-container-util.cpp @@ -677,8 +677,12 @@ SlangResult ArtifactContainerReader::_readContainerDirectory( case IArtifact::ContainedKind::Associated: containerArtifact->addAssociated(artifact); break; - case IArtifact::ContainedKind::Children: containerArtifact->addChild(artifact); break; - default: SLANG_ASSERT(!"Can't add artifact to this kind"); return SLANG_FAIL; + case IArtifact::ContainedKind::Children: + containerArtifact->addChild(artifact); + break; + default: + SLANG_ASSERT(!"Can't add artifact to this kind"); + return SLANG_FAIL; } } } diff --git a/source/compiler-core/slang-artifact-desc-util.cpp b/source/compiler-core/slang-artifact-desc-util.cpp index 078398400..c1575ba16 100644 --- a/source/compiler-core/slang-artifact-desc-util.cpp +++ b/source/compiler-core/slang-artifact-desc-util.cpp @@ -261,25 +261,38 @@ SLANG_HIERARCHICAL_ENUM(ArtifactStyle, SLANG_ARTIFACT_STYLE, SLANG_ARTIFACT_STYL { switch (target) { - case SLANG_TARGET_UNKNOWN: return Desc::make(Kind::Unknown, Payload::None, Style::Unknown, 0); - case SLANG_TARGET_NONE: return Desc::make(Kind::None, Payload::None, Style::Unknown, 0); + case SLANG_TARGET_UNKNOWN: + return Desc::make(Kind::Unknown, Payload::None, Style::Unknown, 0); + case SLANG_TARGET_NONE: + return Desc::make(Kind::None, Payload::None, Style::Unknown, 0); case SLANG_GLSL: { // For the moment we Desc::make all just map to GLSL, but we could use flags // or some other mechanism to distinguish the types return Desc::make(Kind::Source, Payload::GLSL, Style::Kernel, 0); } - case SLANG_HLSL: return Desc::make(Kind::Source, Payload::HLSL, Style::Kernel, 0); - case SLANG_SPIRV: return Desc::make(Kind::ObjectCode, Payload::SPIRV, Style::Kernel, 0); - case SLANG_SPIRV_ASM: return Desc::make(Kind::Assembly, Payload::SPIRV, Style::Kernel, 0); - case SLANG_DXBC: return Desc::make(Kind::ObjectCode, Payload::DXBC, Style::Kernel, 0); - case SLANG_DXBC_ASM: return Desc::make(Kind::Assembly, Payload::DXBC, Style::Kernel, 0); - case SLANG_DXIL: return Desc::make(Kind::ObjectCode, Payload::DXIL, Style::Kernel, 0); - case SLANG_DXIL_ASM: return Desc::make(Kind::Assembly, Payload::DXIL, Style::Kernel, 0); - case SLANG_C_SOURCE: return Desc::make(Kind::Source, Payload::C, Style::Kernel, 0); - case SLANG_CPP_SOURCE: return Desc::make(Kind::Source, Payload::Cpp, Style::Kernel, 0); - case SLANG_HOST_CPP_SOURCE: return Desc::make(Kind::Source, Payload::Cpp, Style::Host, 0); - case SLANG_CPP_PYTORCH_BINDING: return Desc::make(Kind::Source, Payload::Cpp, Style::Host, 0); + case SLANG_HLSL: + return Desc::make(Kind::Source, Payload::HLSL, Style::Kernel, 0); + case SLANG_SPIRV: + return Desc::make(Kind::ObjectCode, Payload::SPIRV, Style::Kernel, 0); + case SLANG_SPIRV_ASM: + return Desc::make(Kind::Assembly, Payload::SPIRV, Style::Kernel, 0); + case SLANG_DXBC: + return Desc::make(Kind::ObjectCode, Payload::DXBC, Style::Kernel, 0); + case SLANG_DXBC_ASM: + return Desc::make(Kind::Assembly, Payload::DXBC, Style::Kernel, 0); + case SLANG_DXIL: + return Desc::make(Kind::ObjectCode, Payload::DXIL, Style::Kernel, 0); + case SLANG_DXIL_ASM: + return Desc::make(Kind::Assembly, Payload::DXIL, Style::Kernel, 0); + case SLANG_C_SOURCE: + return Desc::make(Kind::Source, Payload::C, Style::Kernel, 0); + case SLANG_CPP_SOURCE: + return Desc::make(Kind::Source, Payload::Cpp, Style::Kernel, 0); + case SLANG_HOST_CPP_SOURCE: + return Desc::make(Kind::Source, Payload::Cpp, Style::Host, 0); + case SLANG_CPP_PYTORCH_BINDING: + return Desc::make(Kind::Source, Payload::Cpp, Style::Host, 0); case SLANG_HOST_EXECUTABLE: return Desc::make(Kind::Executable, Payload::HostCPU, Style::Host, 0); case SLANG_HOST_SHARED_LIBRARY: @@ -294,20 +307,26 @@ SLANG_HIERARCHICAL_ENUM(ArtifactStyle, SLANG_ARTIFACT_STYLE, SLANG_ARTIFACT_STYL // Not entirely clear how best to represent PTX here. We could mark as 'Assembly'. // Saying it is 'Executable' implies it is Binary (which PTX isn't). Executable also // implies 'complete for executation', irrespective of it being text. - case SLANG_PTX: return Desc::make(Kind::ObjectCode, Payload::PTX, Style::Kernel, 0); - case SLANG_OBJECT_CODE: return Desc::make(Kind::ObjectCode, Payload::HostCPU, Style::Kernel, 0); + case SLANG_PTX: + return Desc::make(Kind::ObjectCode, Payload::PTX, Style::Kernel, 0); + case SLANG_OBJECT_CODE: + return Desc::make(Kind::ObjectCode, Payload::HostCPU, Style::Kernel, 0); case SLANG_HOST_HOST_CALLABLE: return Desc::make(Kind::HostCallable, Payload::HostCPU, Style::Host, 0); - case SLANG_METAL: return Desc::make(Kind::Source, Payload::Metal, Style::Kernel, 0); - case SLANG_METAL_LIB: return Desc::make(Kind::ObjectCode, Payload::MetalAIR, Style::Kernel, 0); + case SLANG_METAL: + return Desc::make(Kind::Source, Payload::Metal, Style::Kernel, 0); + case SLANG_METAL_LIB: + return Desc::make(Kind::ObjectCode, Payload::MetalAIR, Style::Kernel, 0); case SLANG_METAL_LIB_ASM: return Desc::make(Kind::Assembly, Payload::MetalAIR, Style::Kernel, 0); - case SLANG_WGSL: return Desc::make(Kind::Source, Payload::WGSL, Style::Kernel, 0); + case SLANG_WGSL: + return Desc::make(Kind::Source, Payload::WGSL, Style::Kernel, 0); case SLANG_WGSL_SPIRV_ASM: return Desc::make(Kind::Assembly, Payload::WGSL_SPIRV, Style::Kernel, 0); case SLANG_WGSL_SPIRV: return Desc::make(Kind::ObjectCode, Payload::WGSL_SPIRV, Style::Kernel, 0); - default: break; + default: + break; } SLANG_UNEXPECTED("Unhandled type"); @@ -320,13 +339,20 @@ SLANG_HIERARCHICAL_ENUM(ArtifactStyle, SLANG_ARTIFACT_STYLE, SLANG_ARTIFACT_STYL switch (language) { default: - case SLANG_SOURCE_LANGUAGE_UNKNOWN: return Payload::Unknown; - case SLANG_SOURCE_LANGUAGE_SLANG: return Payload::Slang; - case SLANG_SOURCE_LANGUAGE_HLSL: return Payload::HLSL; - case SLANG_SOURCE_LANGUAGE_GLSL: return Payload::GLSL; - case SLANG_SOURCE_LANGUAGE_C: return Payload::C; - case SLANG_SOURCE_LANGUAGE_CPP: return Payload::Cpp; - case SLANG_SOURCE_LANGUAGE_CUDA: return Payload::CUDA; + case SLANG_SOURCE_LANGUAGE_UNKNOWN: + return Payload::Unknown; + case SLANG_SOURCE_LANGUAGE_SLANG: + return Payload::Slang; + case SLANG_SOURCE_LANGUAGE_HLSL: + return Payload::HLSL; + case SLANG_SOURCE_LANGUAGE_GLSL: + return Payload::GLSL; + case SLANG_SOURCE_LANGUAGE_C: + return Payload::C; + case SLANG_SOURCE_LANGUAGE_CPP: + return Payload::Cpp; + case SLANG_SOURCE_LANGUAGE_CUDA: + return Payload::CUDA; } } @@ -339,20 +365,28 @@ SLANG_HIERARCHICAL_ENUM(ArtifactStyle, SLANG_ARTIFACT_STYLE, SLANG_ARTIFACT_STYL { switch (desc.kind) { - case ArtifactKind::None: return SLANG_TARGET_NONE; + case ArtifactKind::None: + return SLANG_TARGET_NONE; case ArtifactKind::Source: { switch (desc.payload) { - case Payload::HLSL: return SLANG_HLSL; - case Payload::GLSL: return SLANG_GLSL; - case Payload::C: return SLANG_C_SOURCE; + case Payload::HLSL: + return SLANG_HLSL; + case Payload::GLSL: + return SLANG_GLSL; + case Payload::C: + return SLANG_C_SOURCE; case Payload::Cpp: return (desc.style == Style::Host) ? SLANG_HOST_CPP_SOURCE : SLANG_CPP_SOURCE; - case Payload::CUDA: return SLANG_CUDA_SOURCE; - case Payload::Metal: return SLANG_METAL; - case Payload::WGSL: return SLANG_WGSL; - default: break; + case Payload::CUDA: + return SLANG_CUDA_SOURCE; + case Payload::Metal: + return SLANG_METAL; + case Payload::WGSL: + return SLANG_WGSL; + default: + break; } break; } @@ -360,16 +394,24 @@ SLANG_HIERARCHICAL_ENUM(ArtifactStyle, SLANG_ARTIFACT_STYLE, SLANG_ARTIFACT_STYL { switch (desc.payload) { - case Payload::SPIRV: return SLANG_SPIRV_ASM; - case Payload::DXIL: return SLANG_DXIL_ASM; - case Payload::DXBC: return SLANG_DXBC_ASM; - case Payload::PTX: return SLANG_PTX; - case Payload::MetalAIR: return SLANG_METAL_LIB_ASM; - case Payload::WGSL_SPIRV: return SLANG_WGSL_SPIRV_ASM; - default: break; + case Payload::SPIRV: + return SLANG_SPIRV_ASM; + case Payload::DXIL: + return SLANG_DXIL_ASM; + case Payload::DXBC: + return SLANG_DXBC_ASM; + case Payload::PTX: + return SLANG_PTX; + case Payload::MetalAIR: + return SLANG_METAL_LIB_ASM; + case Payload::WGSL_SPIRV: + return SLANG_WGSL_SPIRV_ASM; + default: + break; } } - default: break; + default: + break; } if (isDerivedFrom(desc.kind, ArtifactKind::CompileBinary)) @@ -378,28 +420,38 @@ SLANG_HIERARCHICAL_ENUM(ArtifactStyle, SLANG_ARTIFACT_STYLE, SLANG_ARTIFACT_STYL { switch (desc.kind) { - case Kind::Executable: return SLANG_HOST_EXECUTABLE; + case Kind::Executable: + return SLANG_HOST_EXECUTABLE; case Kind::SharedLibrary: return desc.style == ArtifactStyle::Host ? SLANG_HOST_SHARED_LIBRARY : SLANG_SHADER_SHARED_LIBRARY; case Kind::HostCallable: return desc.style == ArtifactStyle::Host ? SLANG_HOST_HOST_CALLABLE : SLANG_SHADER_HOST_CALLABLE; - case Kind::ObjectCode: return SLANG_OBJECT_CODE; - default: break; + case Kind::ObjectCode: + return SLANG_OBJECT_CODE; + default: + break; } } else { switch (desc.payload) { - case Payload::SPIRV: return SLANG_SPIRV; - case Payload::DXIL: return SLANG_DXIL; - case Payload::DXBC: return SLANG_DXBC; - case Payload::PTX: return SLANG_PTX; - case Payload::MetalAIR: return SLANG_METAL_LIB_ASM; - case Payload::WGSL_SPIRV: return SLANG_WGSL_SPIRV; - default: break; + case Payload::SPIRV: + return SLANG_SPIRV; + case Payload::DXIL: + return SLANG_DXIL; + case Payload::DXBC: + return SLANG_DXBC; + case Payload::PTX: + return SLANG_PTX; + case Payload::MetalAIR: + return SLANG_METAL_LIB_ASM; + case Payload::WGSL_SPIRV: + return SLANG_WGSL_SPIRV; + default: + break; } } } @@ -483,7 +535,8 @@ static const KindExtension g_cpuKindExts[] = { { return true; } - default: break; + default: + break; } return false; } @@ -642,35 +695,52 @@ static UnownedStringSlice _getPayloadExtension(ArtifactPayload payload) switch (payload) { /* Source types */ - case Payload::HLSL: return toSlice("hlsl"); - case Payload::GLSL: return toSlice("glsl"); + case Payload::HLSL: + return toSlice("hlsl"); + case Payload::GLSL: + return toSlice("glsl"); - case Payload::Cpp: return toSlice("cpp"); - case Payload::C: return toSlice("c"); + case Payload::Cpp: + return toSlice("cpp"); + case Payload::C: + return toSlice("c"); - case Payload::Metal: return toSlice("metal"); + case Payload::Metal: + return toSlice("metal"); - case Payload::CUDA: return toSlice("cu"); + case Payload::CUDA: + return toSlice("cu"); - case Payload::Slang: return toSlice("slang"); + case Payload::Slang: + return toSlice("slang"); /* Binary types */ - case Payload::DXIL: return toSlice("dxil"); - case Payload::DXBC: return toSlice("dxbc"); - case Payload::SPIRV: return toSlice("spv"); + case Payload::DXIL: + return toSlice("dxil"); + case Payload::DXBC: + return toSlice("dxbc"); + case Payload::SPIRV: + return toSlice("spv"); - case Payload::PTX: return toSlice("ptx"); + case Payload::PTX: + return toSlice("ptx"); - case Payload::LLVMIR: return toSlice("llvm-ir"); + case Payload::LLVMIR: + return toSlice("llvm-ir"); - case Payload::SlangIR: return toSlice("slang-ir"); + case Payload::SlangIR: + return toSlice("slang-ir"); - case Payload::MetalAIR: return toSlice("metallib"); + case Payload::MetalAIR: + return toSlice("metallib"); - case Payload::PdbDebugInfo: return toSlice("pdb"); - case Payload::SourceMap: return toSlice("map"); + case Payload::PdbDebugInfo: + return toSlice("pdb"); + case Payload::SourceMap: + return toSlice("map"); - default: break; + default: + break; } return UnownedStringSlice(); } @@ -778,7 +848,8 @@ SlangResult ArtifactDescUtil::appendDefaultExtension(const ArtifactDesc& desc, S } break; } - default: break; + default: + break; } if (ArtifactDescUtil::isGpuUsable(desc)) diff --git a/source/compiler-core/slang-artifact-diagnostic-util.cpp b/source/compiler-core/slang-artifact-diagnostic-util.cpp index bf1f0474b..98f8f2245 100644 --- a/source/compiler-core/slang-artifact-diagnostic-util.cpp +++ b/source/compiler-core/slang-artifact-diagnostic-util.cpp @@ -13,10 +13,14 @@ namespace Slang { switch (severity) { - default: return UnownedStringSlice::fromLiteral("Unknown"); - case Severity::Info: return UnownedStringSlice::fromLiteral("Info"); - case Severity::Warning: return UnownedStringSlice::fromLiteral("Warning"); - case Severity::Error: return UnownedStringSlice::fromLiteral("Error"); + default: + return UnownedStringSlice::fromLiteral("Unknown"); + case Severity::Info: + return UnownedStringSlice::fromLiteral("Info"); + case Severity::Warning: + return UnownedStringSlice::fromLiteral("Warning"); + case Severity::Error: + return UnownedStringSlice::fromLiteral("Error"); } } diff --git a/source/compiler-core/slang-artifact-handler-impl.cpp b/source/compiler-core/slang-artifact-handler-impl.cpp index b19a9bd6e..571c45c7b 100644 --- a/source/compiler-core/slang-artifact-handler-impl.cpp +++ b/source/compiler-core/slang-artifact-handler-impl.cpp @@ -256,7 +256,8 @@ SlangResult DefaultArtifactHandler::_createOSFile( } break; } - default: break; + default: + break; } if (path.getLength()) diff --git a/source/compiler-core/slang-artifact-impl.cpp b/source/compiler-core/slang-artifact-impl.cpp index bb7584510..31c01f1de 100644 --- a/source/compiler-core/slang-artifact-impl.cpp +++ b/source/compiler-core/slang-artifact-impl.cpp @@ -138,10 +138,17 @@ void Artifact::clear(IArtifact::ContainedKind kind) { switch (kind) { - case ContainedKind::Associated: m_associated.clear(); break; - case ContainedKind::Representation: m_representations.clear(); break; - case ContainedKind::Children: m_children.clear(); break; - default: break; + case ContainedKind::Associated: + m_associated.clear(); + break; + case ContainedKind::Representation: + m_representations.clear(); + break; + case ContainedKind::Children: + m_children.clear(); + break; + default: + break; } } @@ -149,10 +156,17 @@ void Artifact::removeAt(ContainedKind kind, Index i) { switch (kind) { - case ContainedKind::Associated: m_associated.removeAt(i); break; - case ContainedKind::Representation: m_representations.removeAt(i); break; - case ContainedKind::Children: m_children.removeAt(i); break; - default: break; + case ContainedKind::Associated: + m_associated.removeAt(i); + break; + case ContainedKind::Representation: + m_representations.removeAt(i); + break; + case ContainedKind::Children: + m_children.removeAt(i); + break; + default: + break; } } @@ -217,7 +231,8 @@ void* Artifact::findRepresentation(ContainedKind kind, const Guid& guid) { switch (kind) { - case ContainedKind::Associated: return _findRepresentation(_getRawView(m_associated), guid); + case ContainedKind::Associated: + return _findRepresentation(_getRawView(m_associated), guid); case ContainedKind::Representation: return _findRepresentation(_getRawView(m_representations), guid); case ContainedKind::Children: diff --git a/source/compiler-core/slang-diagnostic-sink.cpp b/source/compiler-core/slang-diagnostic-sink.cpp index 537892f08..f9a7d9c88 100644 --- a/source/compiler-core/slang-diagnostic-sink.cpp +++ b/source/compiler-core/slang-diagnostic-sink.cpp @@ -102,7 +102,9 @@ static void formatDiagnosticMessage( switch (d) { // A double dollar sign `$$` is used to emit a single `$` - case '$': sb.append('$'); break; + case '$': + sb.append('$'); + break; // A single digit means to emit the corresponding argument. // TODO: support more than 10 arguments, and add options @@ -133,7 +135,9 @@ static void formatDiagnosticMessage( } break; - default: SLANG_INVALID_OPERATION("invalid diagnostic message format"); break; + default: + SLANG_INVALID_OPERATION("invalid diagnostic message format"); + break; } spanBegin = spanEnd; @@ -759,9 +763,12 @@ const DiagnosticInfo* DiagnosticsLookup::findDiagnosticByName(const UnownedStrin const auto convention = NameConventionUtil::inferConventionFromText(slice); switch (convention) { - case NameConvention::Invalid: return nullptr; - case NameConvention::LowerCamel: return findDiagnosticByExactName(slice); - default: break; + case NameConvention::Invalid: + return nullptr; + case NameConvention::LowerCamel: + return findDiagnosticByExactName(slice); + default: + break; } StringBuilder buf; diff --git a/source/compiler-core/slang-diagnostic-sink.h b/source/compiler-core/slang-diagnostic-sink.h index 9a4116855..90f1bfccf 100644 --- a/source/compiler-core/slang-diagnostic-sink.h +++ b/source/compiler-core/slang-diagnostic-sink.h @@ -36,13 +36,20 @@ inline const char* getSeverityName(Severity severity) { switch (severity) { - case Severity::Disable: return "ignored"; - case Severity::Note: return "note"; - case Severity::Warning: return "warning"; - case Severity::Error: return "error"; - case Severity::Fatal: return "fatal error"; - case Severity::Internal: return "internal error"; - default: return "unknown error"; + case Severity::Disable: + return "ignored"; + case Severity::Note: + return "note"; + case Severity::Warning: + return "warning"; + case Severity::Error: + return "error"; + case Severity::Fatal: + return "fatal error"; + case Severity::Internal: + return "internal error"; + default: + return "unknown error"; } } diff --git a/source/compiler-core/slang-doc-extractor.cpp b/source/compiler-core/slang-doc-extractor.cpp index d8a27822f..f2f4775fa 100644 --- a/source/compiler-core/slang-doc-extractor.cpp +++ b/source/compiler-core/slang-doc-extractor.cpp @@ -81,7 +81,8 @@ ranges. return comment.startsWith(UnownedStringSlice::fromLiteral("///<")) ? comment.tail(4) : comment; } - default: break; + default: + break; } return comment; } @@ -121,18 +122,28 @@ static Index _findTokenIndex(SourceLoc loc, const Token* toks, Index numToks) switch (type) { default: - case MarkupType::None: return 0; - case MarkupType::BlockBefore: return MarkupFlag::Before | MarkupFlag::IsBlock; - case MarkupType::BlockAfter: return MarkupFlag::After | MarkupFlag::IsBlock; - case MarkupType::OrdinaryBlockBefore: return MarkupFlag::Before | MarkupFlag::IsBlock; - - case MarkupType::LineBangBefore: return MarkupFlag::Before | MarkupFlag::IsMultiToken; - case MarkupType::LineSlashBefore: return MarkupFlag::Before | MarkupFlag::IsMultiToken; - case MarkupType::OrdinaryLineBefore: return MarkupFlag::Before | MarkupFlag::IsMultiToken; - - case MarkupType::LineBangAfter: return MarkupFlag::After | MarkupFlag::IsMultiToken; - case MarkupType::LineSlashAfter: return MarkupFlag::After | MarkupFlag::IsMultiToken; - case MarkupType::OrdinaryLineAfter: return MarkupFlag::After | MarkupFlag::IsMultiToken; + case MarkupType::None: + return 0; + case MarkupType::BlockBefore: + return MarkupFlag::Before | MarkupFlag::IsBlock; + case MarkupType::BlockAfter: + return MarkupFlag::After | MarkupFlag::IsBlock; + case MarkupType::OrdinaryBlockBefore: + return MarkupFlag::Before | MarkupFlag::IsBlock; + + case MarkupType::LineBangBefore: + return MarkupFlag::Before | MarkupFlag::IsMultiToken; + case MarkupType::LineSlashBefore: + return MarkupFlag::Before | MarkupFlag::IsMultiToken; + case MarkupType::OrdinaryLineBefore: + return MarkupFlag::Before | MarkupFlag::IsMultiToken; + + case MarkupType::LineBangAfter: + return MarkupFlag::After | MarkupFlag::IsMultiToken; + case MarkupType::LineSlashAfter: + return MarkupFlag::After | MarkupFlag::IsMultiToken; + case MarkupType::OrdinaryLineAfter: + return MarkupFlag::After | MarkupFlag::IsMultiToken; } } @@ -175,7 +186,8 @@ static Index _findTokenIndex(SourceLoc loc, const Token* toks, Index numToks) : MarkupType::OrdinaryLineAfter; break; } - default: break; + default: + break; } return MarkupType::None; } @@ -346,7 +358,8 @@ SlangResult DocMarkupExtractor::_extractMarkup( break; } - default: return SLANG_FAIL; + default: + return SLANG_FAIL; } return SLANG_OK; @@ -475,7 +488,8 @@ Index DocMarkupExtractor::_findStartIndex(const FindInfo& info, Location locatio } break; } - default: break; + default: + break; } } diff --git a/source/compiler-core/slang-downstream-compiler-util.cpp b/source/compiler-core/slang-downstream-compiler-util.cpp index 1ab35d4fe..68fc241b9 100644 --- a/source/compiler-core/slang-downstream-compiler-util.cpp +++ b/source/compiler-core/slang-downstream-compiler-util.cpp @@ -336,7 +336,8 @@ DownstreamCompilerMatchVersion DownstreamCompilerUtil::getCompiledVersion() compiler = findCompiler(set, MatchType::Newest, desc); break; } - default: break; + default: + break; } set->setDefaultCompiler(sourceLanguage, compiler); diff --git a/source/compiler-core/slang-dxc-compiler.cpp b/source/compiler-core/slang-dxc-compiler.cpp index b694c4cf6..cfc4771e6 100644 --- a/source/compiler-core/slang-dxc-compiler.cpp +++ b/source/compiler-core/slang-dxc-compiler.cpp @@ -488,14 +488,18 @@ SlangResult DXCDownstreamCompiler::compile(const CompileOptions& inOptions, IArt switch (options.matrixLayout) { - default: break; + default: + break; - case SLANG_MATRIX_LAYOUT_ROW_MAJOR: args.add(L"-Zpr"); break; + case SLANG_MATRIX_LAYOUT_ROW_MAJOR: + args.add(L"-Zpr"); + break; } switch (options.floatingPointMode) { - default: break; + default: + break; case FloatingPointMode::Precise: args.add(L"-Gis"); // "force IEEE strictness" @@ -505,19 +509,31 @@ SlangResult DXCDownstreamCompiler::compile(const CompileOptions& inOptions, IArt switch (options.optimizationLevel) { - default: break; + default: + break; - case OptimizationLevel::None: args.add(L"-Od"); break; - case OptimizationLevel::Default: args.add(L"-O1"); break; - case OptimizationLevel::High: args.add(L"-O2"); break; - case OptimizationLevel::Maximal: args.add(L"-O3"); break; + case OptimizationLevel::None: + args.add(L"-Od"); + break; + case OptimizationLevel::Default: + args.add(L"-O1"); + break; + case OptimizationLevel::High: + args.add(L"-O2"); + break; + case OptimizationLevel::Maximal: + args.add(L"-O3"); + break; } switch (options.debugInfoType) { - case DebugInfoType::None: break; + case DebugInfoType::None: + break; - default: args.add(L"-Zi"); break; + default: + args.add(L"-Zi"); + break; } // Slang strives to produce correct code, and by default diff --git a/source/compiler-core/slang-fxc-compiler.cpp b/source/compiler-core/slang-fxc-compiler.cpp index 0c571c10b..c42516399 100644 --- a/source/compiler-core/slang-fxc-compiler.cpp +++ b/source/compiler-core/slang-fxc-compiler.cpp @@ -265,9 +265,12 @@ SlangResult FXCDownstreamCompiler::compile(const CompileOptions& inOptions, IArt switch (options.floatingPointMode) { - default: break; + default: + break; - case FloatingPointMode::Precise: flags |= D3DCOMPILE_IEEE_STRICTNESS; break; + case FloatingPointMode::Precise: + flags |= D3DCOMPILE_IEEE_STRICTNESS; + break; } flags |= D3DCOMPILE_ENABLE_STRICTNESS; @@ -275,19 +278,31 @@ SlangResult FXCDownstreamCompiler::compile(const CompileOptions& inOptions, IArt switch (options.optimizationLevel) { - default: break; - - case OptimizationLevel::None: flags |= D3DCOMPILE_OPTIMIZATION_LEVEL0; break; - case OptimizationLevel::Default: flags |= D3DCOMPILE_OPTIMIZATION_LEVEL1; break; - case OptimizationLevel::High: flags |= D3DCOMPILE_OPTIMIZATION_LEVEL2; break; - case OptimizationLevel::Maximal: flags |= D3DCOMPILE_OPTIMIZATION_LEVEL3; break; + default: + break; + + case OptimizationLevel::None: + flags |= D3DCOMPILE_OPTIMIZATION_LEVEL0; + break; + case OptimizationLevel::Default: + flags |= D3DCOMPILE_OPTIMIZATION_LEVEL1; + break; + case OptimizationLevel::High: + flags |= D3DCOMPILE_OPTIMIZATION_LEVEL2; + break; + case OptimizationLevel::Maximal: + flags |= D3DCOMPILE_OPTIMIZATION_LEVEL3; + break; } switch (options.debugInfoType) { - case DebugInfoType::None: break; + case DebugInfoType::None: + break; - default: flags |= D3DCOMPILE_DEBUG; break; + default: + flags |= D3DCOMPILE_DEBUG; + break; } ComPtr<ISlangBlob> sourceBlob; diff --git a/source/compiler-core/slang-gcc-compiler-util.cpp b/source/compiler-core/slang-gcc-compiler-util.cpp index 67ee6f8b3..f12f44338 100644 --- a/source/compiler-core/slang-gcc-compiler-util.cpp +++ b/source/compiler-core/slang-gcc-compiler-util.cpp @@ -438,7 +438,8 @@ static SlangResult _parseGCCFamilyLine( prevLineResult = lineRes; break; } - default: return SLANG_FAIL; + default: + return SLANG_FAIL; } } @@ -553,7 +554,8 @@ static SlangResult _parseGCCFamilyLine( cmdLine.addArg("-O4"); break; } - default: break; + default: + break; } if (options.debugInfoType != DebugInfoType::None) @@ -568,7 +570,8 @@ static SlangResult _parseGCCFamilyLine( switch (options.floatingPointMode) { - case FloatingPointMode::Default: break; + case FloatingPointMode::Default: + break; case FloatingPointMode::Precise: { // cmdLine.addArg("-fno-unsafe-math-optimizations"); @@ -619,7 +622,8 @@ static SlangResult _parseGCCFamilyLine( cmdLine.addArg("-c"); break; } - default: break; + default: + break; } // Add defines diff --git a/source/compiler-core/slang-glslang-compiler.cpp b/source/compiler-core/slang-glslang-compiler.cpp index fd80c7581..5550ac8ad 100644 --- a/source/compiler-core/slang-glslang-compiler.cpp +++ b/source/compiler-core/slang-glslang-compiler.cpp @@ -208,9 +208,15 @@ SlangResult GlslangDownstreamCompiler::compile( switch (options.sourceLanguage) { - case SLANG_SOURCE_LANGUAGE_GLSL: request.action = GLSLANG_ACTION_COMPILE_GLSL_TO_SPIRV; break; - case SLANG_SOURCE_LANGUAGE_SPIRV: request.action = GLSLANG_ACTION_OPTIMIZE_SPIRV; break; - default: SLANG_ASSERT(!"Can only handle GLSL or SPIR-V as input."); return SLANG_FAIL; + case SLANG_SOURCE_LANGUAGE_GLSL: + request.action = GLSLANG_ACTION_COMPILE_GLSL_TO_SPIRV; + break; + case SLANG_SOURCE_LANGUAGE_SPIRV: + request.action = GLSLANG_ACTION_OPTIMIZE_SPIRV; + break; + default: + SLANG_ASSERT(!"Can only handle GLSL or SPIR-V as input."); + return SLANG_FAIL; } request.sourcePath = sourcePath.getBuffer(); diff --git a/source/compiler-core/slang-json-lexer.cpp b/source/compiler-core/slang-json-lexer.cpp index 84b6b24bc..7f1499a21 100644 --- a/source/compiler-core/slang-json-lexer.cpp +++ b/source/compiler-core/slang-json-lexer.cpp @@ -147,7 +147,8 @@ JSONTokenType JSONLexer::advance() switch (c) { - case 0: return _setToken(JSONTokenType::EndOfFile, cursor - 1); + case 0: + return _setToken(JSONTokenType::EndOfFile, cursor - 1); case '"': { cursor = _lexString(cursor); @@ -190,12 +191,18 @@ JSONTokenType JSONLexer::advance() cursor = _lexWhitespace(cursor); break; } - case ':': return _setToken(JSONTokenType::Colon, cursor); - case ',': return _setToken(JSONTokenType::Comma, cursor); - case '[': return _setToken(JSONTokenType::LBracket, cursor); - case ']': return _setToken(JSONTokenType::RBracket, cursor); - case '{': return _setToken(JSONTokenType::LBrace, cursor); - case '}': return _setToken(JSONTokenType::RBrace, cursor); + case ':': + return _setToken(JSONTokenType::Colon, cursor); + case ',': + return _setToken(JSONTokenType::Comma, cursor); + case '[': + return _setToken(JSONTokenType::LBracket, cursor); + case ']': + return _setToken(JSONTokenType::RBracket, cursor); + case '{': + return _setToken(JSONTokenType::LBrace, cursor); + case '}': + return _setToken(JSONTokenType::RBrace, cursor); case '-': case '0': @@ -398,7 +405,8 @@ const char* JSONLexer::_lexString(const char* cursor) } } // Somewhat surprisingly it appears it's valid to have \r\n inside of quotes. - default: break; + default: + break; } } } @@ -445,7 +453,8 @@ const char* JSONLexer::_lexBlockComment(const char* cursor) } break; } - default: break; + default: + break; } } } @@ -481,21 +490,36 @@ UnownedStringSlice getJSONTokenAsText(JSONTokenType type) { switch (type) { - case JSONTokenType::Invalid: return UnownedStringSlice::fromLiteral("invalid"); - case JSONTokenType::IntegerLiteral: return UnownedStringSlice::fromLiteral("integer literal"); - case JSONTokenType::FloatLiteral: return UnownedStringSlice::fromLiteral("float literal"); - case JSONTokenType::StringLiteral: return UnownedStringSlice::fromLiteral("string literal"); - case JSONTokenType::LBracket: return UnownedStringSlice::fromLiteral("["); - case JSONTokenType::RBracket: return UnownedStringSlice::fromLiteral("]"); - case JSONTokenType::LBrace: return UnownedStringSlice::fromLiteral("{"); - case JSONTokenType::RBrace: return UnownedStringSlice::fromLiteral("}"); - case JSONTokenType::Comma: return UnownedStringSlice::fromLiteral(","); - case JSONTokenType::Colon: return UnownedStringSlice::fromLiteral(":"); - case JSONTokenType::True: return UnownedStringSlice::fromLiteral("true"); - case JSONTokenType::False: return UnownedStringSlice::fromLiteral("false"); - case JSONTokenType::Null: return UnownedStringSlice::fromLiteral("null"); - case JSONTokenType::EndOfFile: return UnownedStringSlice::fromLiteral("end of file"); - default: break; + case JSONTokenType::Invalid: + return UnownedStringSlice::fromLiteral("invalid"); + case JSONTokenType::IntegerLiteral: + return UnownedStringSlice::fromLiteral("integer literal"); + case JSONTokenType::FloatLiteral: + return UnownedStringSlice::fromLiteral("float literal"); + case JSONTokenType::StringLiteral: + return UnownedStringSlice::fromLiteral("string literal"); + case JSONTokenType::LBracket: + return UnownedStringSlice::fromLiteral("["); + case JSONTokenType::RBracket: + return UnownedStringSlice::fromLiteral("]"); + case JSONTokenType::LBrace: + return UnownedStringSlice::fromLiteral("{"); + case JSONTokenType::RBrace: + return UnownedStringSlice::fromLiteral("}"); + case JSONTokenType::Comma: + return UnownedStringSlice::fromLiteral(","); + case JSONTokenType::Colon: + return UnownedStringSlice::fromLiteral(":"); + case JSONTokenType::True: + return UnownedStringSlice::fromLiteral("true"); + case JSONTokenType::False: + return UnownedStringSlice::fromLiteral("false"); + case JSONTokenType::Null: + return UnownedStringSlice::fromLiteral("null"); + case JSONTokenType::EndOfFile: + return UnownedStringSlice::fromLiteral("end of file"); + default: + break; } SLANG_UNEXPECTED("JSONTokenType not known"); } diff --git a/source/compiler-core/slang-json-native.cpp b/source/compiler-core/slang-json-native.cpp index e4b425801..1f9a4dbc6 100644 --- a/source/compiler-core/slang-json-native.cpp +++ b/source/compiler-core/slang-json-native.cpp @@ -285,7 +285,8 @@ SlangResult JSONToNativeConverter::convert(const JSONValue& in, const RttiInfo* } return SLANG_FAIL; } - default: break; + default: + break; } return SLANG_FAIL; } @@ -408,7 +409,8 @@ SlangResult NativeToJSONConverter::convert(const RttiInfo* rttiInfo, const void* switch (rttiInfo->m_kind) { - case RttiInfo::Kind::Invalid: return SLANG_FAIL; + case RttiInfo::Kind::Invalid: + return SLANG_FAIL; case RttiInfo::Kind::Bool: { out = JSONValue::makeBool(RttiUtil::asBool(rttiInfo, in)); @@ -512,7 +514,8 @@ SlangResult NativeToJSONConverter::convert(const RttiInfo* rttiInfo, const void* } break; } - default: break; + default: + break; } return SLANG_E_NOT_IMPLEMENTED; diff --git a/source/compiler-core/slang-json-parser.h b/source/compiler-core/slang-json-parser.h index d226e7fb9..89be90d81 100644 --- a/source/compiler-core/slang-json-parser.h +++ b/source/compiler-core/slang-json-parser.h @@ -155,10 +155,14 @@ protected: { switch (m_kind) { - case Kind::Root: return (m_flags & Flag::HasPrevious) == 0; - case Kind::Array: return true; - case Kind::Object: return (m_flags & Flag::HasKey) != 0; - default: return false; + case Kind::Root: + return (m_flags & Flag::HasPrevious) == 0; + case Kind::Array: + return true; + case Kind::Object: + return (m_flags & Flag::HasKey) != 0; + default: + return false; } } diff --git a/source/compiler-core/slang-json-value.cpp b/source/compiler-core/slang-json-value.cpp index 2738058ee..ae38bd086 100644 --- a/source/compiler-core/slang-json-value.cpp +++ b/source/compiler-core/slang-json-value.cpp @@ -66,15 +66,19 @@ bool JSONValue::asBool() const { switch (type) { - case JSONValue::Type::True: return true; + case JSONValue::Type::True: + return true; case JSONValue::Type::False: case JSONValue::Type::Null: { return false; } - case JSONValue::Type::IntegerValue: return intValue != 0; - case JSONValue::Type::FloatValue: return floatValue != 0; - default: break; + case JSONValue::Type::IntegerValue: + return intValue != 0; + case JSONValue::Type::FloatValue: + return floatValue != 0; + default: + break; } if (isLexeme(type)) @@ -93,14 +97,18 @@ int64_t JSONValue::asInteger() const { switch (type) { - case JSONValue::Type::True: return 1; + case JSONValue::Type::True: + return 1; case JSONValue::Type::False: case JSONValue::Type::Null: { return 0; } - case JSONValue::Type::IntegerValue: return intValue; - case JSONValue::Type::FloatValue: return int64_t(floatValue); break; + case JSONValue::Type::IntegerValue: + return intValue; + case JSONValue::Type::FloatValue: + return int64_t(floatValue); + break; } if (isLexeme(type)) @@ -119,15 +127,19 @@ double JSONValue::asFloat() const { switch (type) { - case JSONValue::Type::True: return 1.0; + case JSONValue::Type::True: + return 1.0; case JSONValue::Type::False: case JSONValue::Type::Null: { return 0.0; } - case JSONValue::Type::IntegerValue: return double(intValue); - case JSONValue::Type::FloatValue: return floatValue; - default: break; + case JSONValue::Type::IntegerValue: + return double(intValue); + case JSONValue::Type::FloatValue: + return floatValue; + default: + break; } if (isLexeme(type)) @@ -261,8 +273,10 @@ bool PersistentJSONValue::operator==(const ThisType& rhs) const // The type is all that needs to be checked return true; } - case Type::IntegerValue: return intValue == rhs.intValue; - case Type::FloatValue: return floatValue == rhs.floatValue; + case Type::IntegerValue: + return intValue == rhs.intValue; + case Type::FloatValue: + return floatValue == rhs.floatValue; case Type::StringRepresentation: { if (stringRep == rhs.stringRep) @@ -273,7 +287,8 @@ bool PersistentJSONValue::operator==(const ThisType& rhs) const auto rhsSlice = StringRepresentation::asSlice(rhs.stringRep); return thisSlice == rhsSlice; } - default: break; + default: + break; } SLANG_ASSERT(!"Not valid Persistent type"); @@ -577,7 +592,8 @@ UnownedStringSlice JSONContainer::getString(const JSONValue& in) { return UnownedStringSlice(); } - default: break; + default: + break; } SLANG_ASSERT(!"Not a string type"); @@ -635,9 +651,12 @@ bool JSONContainer::asBool(const JSONValue& value) { switch (value.type) { - case JSONValue::Type::IntegerLexeme: return asInteger(value) != 0; - case JSONValue::Type::FloatLexeme: return asFloat(value) != 0.0; - default: return value.asBool(); + case JSONValue::Type::IntegerLexeme: + return asInteger(value) != 0; + case JSONValue::Type::FloatLexeme: + return asFloat(value) != 0.0; + default: + return value.asBool(); } } @@ -665,7 +684,8 @@ JSONValue JSONContainer::asValue(const JSONValue& inValue) value.type = JSONValue::Type::FloatValue; break; } - default: break; + default: + break; } return value; @@ -711,7 +731,8 @@ void JSONContainer::clearSourceManagerDependency(JSONValue* ioValues, Index valu } break; } - default: break; + default: + break; } } @@ -734,8 +755,10 @@ int64_t JSONContainer::asInteger(const JSONValue& value) SLANG_ASSERT(!"Couldn't convert int"); return 0; } - case JSONValue::Type::FloatLexeme: return int64_t(asFloat(value)); - default: return value.asInteger(); + case JSONValue::Type::FloatLexeme: + return int64_t(asFloat(value)); + default: + return value.asInteger(); } } @@ -743,7 +766,8 @@ double JSONContainer::asFloat(const JSONValue& value) { switch (value.type) { - case JSONValue::Type::IntegerLexeme: return double(asInteger(value)); + case JSONValue::Type::IntegerLexeme: + return double(asInteger(value)); case JSONValue::Type::FloatLexeme: { UnownedStringSlice slice = getLexeme(value); @@ -755,7 +779,8 @@ double JSONContainer::asFloat(const JSONValue& value) SLANG_ASSERT(!"Couldn't convert double"); return 0.0; } - default: return value.asFloat(); + default: + return value.asFloat(); } } @@ -963,7 +988,8 @@ void JSONContainer::_destroyRange(Index rangeIndex) } break; } - default: break; + default: + break; } range.type = Range::Type::Destroyed; @@ -1148,15 +1174,18 @@ bool JSONContainer::areEqual(const JSONValue& a, const JSONValue& b) { default: // Invalid are never equal - case JSONValue::Type::Invalid: return false; + case JSONValue::Type::Invalid: + return false; case JSONValue::Type::True: case JSONValue::Type::False: case JSONValue::Type::Null: { return true; } - case JSONValue::Type::IntegerLexeme: return asInteger(a) == asInteger(b); - case JSONValue::Type::FloatLexeme: return asFloat(a) == asFloat(b); + case JSONValue::Type::IntegerLexeme: + return asInteger(a) == asInteger(b); + case JSONValue::Type::FloatLexeme: + return asFloat(a) == asFloat(b); case JSONValue::Type::StringLexeme: { // If the lexemes are equal they are equal @@ -1165,9 +1194,12 @@ bool JSONContainer::areEqual(const JSONValue& a, const JSONValue& b) // Else we want to decode the string to be sure if they are equal. return lexemeA == lexemeB || getStringKey(a) == getStringKey(b); } - case JSONValue::Type::IntegerValue: return a.intValue == b.intValue; - case JSONValue::Type::FloatValue: return a.floatValue == b.floatValue; - case JSONValue::Type::StringValue: return a.stringKey == b.stringKey; + case JSONValue::Type::IntegerValue: + return a.intValue == b.intValue; + case JSONValue::Type::FloatValue: + return a.floatValue == b.floatValue; + case JSONValue::Type::StringValue: + return a.stringKey == b.stringKey; case JSONValue::Type::StringRepresentation: { return a.stringRep == b.stringRep || StringRepresentation::asSlice(a.stringRep) == @@ -1208,10 +1240,14 @@ bool JSONContainer::areEqual(const JSONValue& a, const JSONValue& b) { switch (kind) { - case JSONValue::Kind::String: return getStringKey(a) == getStringKey(b); - case JSONValue::Kind::Integer: return asInteger(a) == asInteger(b); - case JSONValue::Kind::Float: return asFloat(a) == asFloat(b); - default: break; + case JSONValue::Kind::String: + return getStringKey(a) == getStringKey(b); + case JSONValue::Kind::Integer: + return asInteger(a) == asInteger(b); + case JSONValue::Kind::Float: + return asFloat(a) == asFloat(b); + default: + break; } } @@ -1224,9 +1260,12 @@ void JSONContainer::traverseRecursively(const JSONValue& value, JSONListener* li switch (value.type) { - case Type::True: return listener->addBoolValue(true, value.loc); - case Type::False: return listener->addBoolValue(false, value.loc); - case Type::Null: return listener->addNullValue(value.loc); + case Type::True: + return listener->addBoolValue(true, value.loc); + case Type::False: + return listener->addBoolValue(false, value.loc); + case Type::Null: + return listener->addNullValue(value.loc); case Type::StringLexeme: return listener->addLexemeValue(JSONTokenType::StringLiteral, getLexeme(value), value.loc); @@ -1235,8 +1274,10 @@ void JSONContainer::traverseRecursively(const JSONValue& value, JSONListener* li case Type::FloatLexeme: return listener->addLexemeValue(JSONTokenType::FloatLiteral, getLexeme(value), value.loc); - case Type::IntegerValue: return listener->addIntegerValue(value.intValue, value.loc); - case Type::FloatValue: return listener->addFloatValue(value.floatValue, value.loc); + case Type::IntegerValue: + return listener->addIntegerValue(value.intValue, value.loc); + case Type::FloatValue: + return listener->addFloatValue(value.floatValue, value.loc); case Type::StringValue: { const auto slice = getStringFromKey(value.stringKey); @@ -1471,9 +1512,12 @@ void JSONBuilder::addLexemeValue(JSONTokenType type, const UnownedStringSlice& v { switch (type) { - case JSONTokenType::True: return _add(JSONValue::makeBool(true, loc)); - case JSONTokenType::False: return _add(JSONValue::makeBool(false, loc)); - case JSONTokenType::Null: return _add(JSONValue::makeNull(loc)); + case JSONTokenType::True: + return _add(JSONValue::makeBool(true, loc)); + case JSONTokenType::False: + return _add(JSONValue::makeBool(false, loc)); + case JSONTokenType::Null: + return _add(JSONValue::makeNull(loc)); case JSONTokenType::IntegerLiteral: { diff --git a/source/compiler-core/slang-lexer.cpp b/source/compiler-core/slang-lexer.cpp index df95f5f1e..bf109e7fb 100644 --- a/source/compiler-core/slang-lexer.cpp +++ b/source/compiler-core/slang-lexer.cpp @@ -206,7 +206,8 @@ static int _peek(Lexer* lexer, int offset = 0) c = e; continue; } - default: break; + default: + break; } // Only continue this while loop in the case where we consumed @@ -261,7 +262,8 @@ static int _advance(Lexer* lexer) // escaped newline. continue; - default: break; + default: + break; } } @@ -291,9 +293,12 @@ static void _lexLineComment(Lexer* lexer) { case '\n': case '\r': - case kEOF: return; + case kEOF: + return; - default: _advance(lexer); continue; + default: + _advance(lexer); + continue; } } } @@ -309,18 +314,25 @@ static void _lexBlockComment(Lexer* lexer) return; case '\n': - case '\r': _handleNewLine(lexer); continue; + case '\r': + _handleNewLine(lexer); + continue; case '*': _advance(lexer); switch (_peek(lexer)) { - case '/': _advance(lexer); return; + case '/': + _advance(lexer); + return; - default: continue; + default: + continue; } - default: _advance(lexer); continue; + default: + _advance(lexer); + continue; } } } @@ -332,9 +344,12 @@ static void _lexHorizontalSpace(Lexer* lexer) switch (_peek(lexer)) { case ' ': - case '\t': _advance(lexer); continue; + case '\t': + _advance(lexer); + continue; - default: return; + default: + return; } } } @@ -382,7 +397,9 @@ static void _lexDigits(Lexer* lexer, int base) case '6': case '7': case '8': - case '9': digitVal = c - '0'; break; + case '9': + digitVal = c - '0'; + break; case 'a': case 'b': @@ -456,7 +473,8 @@ static bool _isNumberExponent(int c, int base) { switch (c) { - default: return false; + default: + return false; case 'e': case 'E': @@ -502,7 +520,9 @@ static bool _maybeLexNumberExponent(Lexer* lexer, int base) switch (_peek(lexer)) { case '+': - case '-': _advance(lexer); break; + case '-': + _advance(lexer); + break; } // TODO(tfoley): it would be an error to not see digits here... @@ -535,7 +555,8 @@ static TokenType _lexNumber(Lexer* lexer, int base) { // 123.xxxx or 123.rrrr case 'x': - case 'r': break; + case 'r': + break; default: tokenType = TokenType::FloatingPointLiteral; @@ -563,10 +584,13 @@ static int _maybeReadDigit(char const** ioCursor, int base) int c = *cursor; switch (c) { - default: return -1; + default: + return -1; // TODO: need to decide on digit separator characters - case '_': cursor++; continue; + case '_': + cursor++; + continue; case '0': case '1': @@ -577,7 +601,9 @@ static int _maybeReadDigit(char const** ioCursor, int base) case '6': case '7': case '8': - case '9': cursor++; return c - '0'; + case '9': + cursor++; + return c - '0'; case 'a': case 'b': @@ -617,10 +643,14 @@ static int _readOptionalBase(char const** ioCursor) switch (*cursor) { case 'x': - case 'X': cursor++; return 16; + case 'X': + cursor++; + return 16; case 'b': - case 'B': cursor++; return 2; + case 'B': + cursor++; + return 2; case '0': case '1': @@ -631,9 +661,11 @@ static int _readOptionalBase(char const** ioCursor) case '6': case '7': case '8': - case '9': return 8; + case '9': + return 8; - default: return 10; + default: + return 10; } } @@ -731,14 +763,17 @@ FloatingPointLiteralValue getFloatingPointLiteralValue( bool exponentIsNegative = false; switch (*cursor) { - default: break; + default: + break; case '-': exponentIsNegative = true; cursor++; break; - case '+': cursor++; break; + case '+': + cursor++; + break; } int exponentRadix = 10; @@ -824,7 +859,9 @@ static void _lexStringLiteralBody(Lexer* lexer, char quote) case 'n': case 'r': case 't': - case 'v': _advance(lexer); break; + case 'v': + _advance(lexer); + break; case '0': case '1': @@ -874,7 +911,9 @@ static void _lexStringLiteralBody(Lexer* lexer, char quote) } break; - default: _advance(lexer); continue; + default: + _advance(lexer); + continue; } } } @@ -921,7 +960,9 @@ static void _lexRawStringLiteralBody(Lexer* lexer) sink->diagnose(_getSourceLoc(lexer), LexerDiagnostics::endOfFileInLiteral); } return; - default: _advance(lexer); continue; + default: + _advance(lexer); + continue; } } } @@ -992,16 +1033,32 @@ String getStringLiteralTokenValue(Token const& token) case '\'': case '\"': case '\\': - case '?': valueBuilder.append(d); continue; + case '?': + valueBuilder.append(d); + continue; // Traditional escape sequences for special characters - case 'a': valueBuilder.append('\a'); continue; - case 'b': valueBuilder.append('\b'); continue; - case 'f': valueBuilder.append('\f'); continue; - case 'n': valueBuilder.append('\n'); continue; - case 'r': valueBuilder.append('\r'); continue; - case 't': valueBuilder.append('\t'); continue; - case 'v': valueBuilder.append('\v'); continue; + case 'a': + valueBuilder.append('\a'); + continue; + case 'b': + valueBuilder.append('\b'); + continue; + case 'f': + valueBuilder.append('\f'); + continue; + case 'n': + valueBuilder.append('\n'); + continue; + case 'r': + valueBuilder.append('\r'); + continue; + case 't': + valueBuilder.append('\t'); + continue; + case 'v': + valueBuilder.append('\v'); + continue; // Octal escape: up to 3 characters case '0': @@ -1093,15 +1150,21 @@ static TokenType _lexTokenImpl(Lexer* lexer) int nextCodePoint = _peek(lexer); switch (nextCodePoint) { - default: break; + default: + break; - case kEOF: return TokenType::EndOfFile; + case kEOF: + return TokenType::EndOfFile; case '\r': - case '\n': _handleNewLine(lexer); return TokenType::NewLine; + case '\n': + _handleNewLine(lexer); + return TokenType::NewLine; case ' ': - case '\t': _lexHorizontalSpace(lexer); return TokenType::WhiteSpace; + case '\t': + _lexHorizontalSpace(lexer); + return TokenType::WhiteSpace; case '.': _advance(lexer); @@ -1116,7 +1179,8 @@ static TokenType _lexTokenImpl(Lexer* lexer) case '6': case '7': case '8': - case '9': return _lexNumberAfterDecimalPoint(lexer, 10); + case '9': + return _lexNumberAfterDecimalPoint(lexer, 10); case '.': // Note: consuming the second `.` here means that @@ -1128,12 +1192,16 @@ static TokenType _lexTokenImpl(Lexer* lexer) _advance(lexer); switch (_peek(lexer)) { - case '.': _advance(lexer); return TokenType::Ellipsis; + case '.': + _advance(lexer); + return TokenType::Ellipsis; - default: return TokenType::DotDot; + default: + return TokenType::DotDot; } - default: return TokenType::Dot; + default: + return TokenType::Dot; } case '1': @@ -1144,7 +1212,8 @@ static TokenType _lexTokenImpl(Lexer* lexer) case '6': case '7': case '8': - case '9': return _lexNumber(lexer, 10); + case '9': + return _lexNumber(lexer, 10); case '0': { @@ -1152,22 +1221,30 @@ static TokenType _lexTokenImpl(Lexer* lexer) _advance(lexer); switch (_peek(lexer)) { - default: return _maybeLexNumberSuffix(lexer, TokenType::IntegerLiteral); + default: + return _maybeLexNumberSuffix(lexer, TokenType::IntegerLiteral); case '.': switch (_peek(lexer, 1)) { // 0.xxxx or 0.rrrr case 'x': - case 'r': return _maybeLexNumberSuffix(lexer, TokenType::IntegerLiteral); - default: _advance(lexer); return _lexNumberAfterDecimalPoint(lexer, 10); + case 'r': + return _maybeLexNumberSuffix(lexer, TokenType::IntegerLiteral); + default: + _advance(lexer); + return _lexNumberAfterDecimalPoint(lexer, 10); } case 'x': - case 'X': _advance(lexer); return _lexNumber(lexer, 16); + case 'X': + _advance(lexer); + return _lexNumber(lexer, 16); case 'b': - case 'B': _advance(lexer); return _lexNumber(lexer, 2); + case 'B': + _advance(lexer); + return _lexNumber(lexer, 2); case '0': case '1': @@ -1238,12 +1315,16 @@ static TokenType _lexTokenImpl(Lexer* lexer) case 'X': case 'Y': case 'Z': - case '_': _lexIdentifier(lexer); return TokenType::Identifier; + case '_': + _lexIdentifier(lexer); + return TokenType::Identifier; case 'R': _advance(lexer); switch (_peek(lexer)) { - default: _lexIdentifier(lexer); return TokenType::Identifier; + default: + _lexIdentifier(lexer); + return TokenType::Identifier; case '\"': _advance(lexer); _lexRawStringLiteralBody(lexer); @@ -1265,34 +1346,51 @@ static TokenType _lexTokenImpl(Lexer* lexer) _advance(lexer); switch (_peek(lexer)) { - case '+': _advance(lexer); return TokenType::OpInc; - case '=': _advance(lexer); return TokenType::OpAddAssign; - default: return TokenType::OpAdd; + case '+': + _advance(lexer); + return TokenType::OpInc; + case '=': + _advance(lexer); + return TokenType::OpAddAssign; + default: + return TokenType::OpAdd; } case '-': _advance(lexer); switch (_peek(lexer)) { - case '-': _advance(lexer); return TokenType::OpDec; - case '=': _advance(lexer); return TokenType::OpSubAssign; - case '>': _advance(lexer); return TokenType::RightArrow; - default: return TokenType::OpSub; + case '-': + _advance(lexer); + return TokenType::OpDec; + case '=': + _advance(lexer); + return TokenType::OpSubAssign; + case '>': + _advance(lexer); + return TokenType::RightArrow; + default: + return TokenType::OpSub; } case '*': _advance(lexer); switch (_peek(lexer)) { - case '=': _advance(lexer); return TokenType::OpMulAssign; - default: return TokenType::OpMul; + case '=': + _advance(lexer); + return TokenType::OpMulAssign; + default: + return TokenType::OpMul; } case '/': _advance(lexer); switch (_peek(lexer)) { - case '=': _advance(lexer); return TokenType::OpDivAssign; + case '=': + _advance(lexer); + return TokenType::OpDivAssign; case '/': _advance(lexer); _lexLineComment(lexer); @@ -1301,41 +1399,58 @@ static TokenType _lexTokenImpl(Lexer* lexer) _advance(lexer); _lexBlockComment(lexer); return TokenType::BlockComment; - default: return TokenType::OpDiv; + default: + return TokenType::OpDiv; } case '%': _advance(lexer); switch (_peek(lexer)) { - case '=': _advance(lexer); return TokenType::OpModAssign; - default: return TokenType::OpMod; + case '=': + _advance(lexer); + return TokenType::OpModAssign; + default: + return TokenType::OpMod; } case '|': _advance(lexer); switch (_peek(lexer)) { - case '|': _advance(lexer); return TokenType::OpOr; - case '=': _advance(lexer); return TokenType::OpOrAssign; - default: return TokenType::OpBitOr; + case '|': + _advance(lexer); + return TokenType::OpOr; + case '=': + _advance(lexer); + return TokenType::OpOrAssign; + default: + return TokenType::OpBitOr; } case '&': _advance(lexer); switch (_peek(lexer)) { - case '&': _advance(lexer); return TokenType::OpAnd; - case '=': _advance(lexer); return TokenType::OpAndAssign; - default: return TokenType::OpBitAnd; + case '&': + _advance(lexer); + return TokenType::OpAnd; + case '=': + _advance(lexer); + return TokenType::OpAndAssign; + default: + return TokenType::OpBitAnd; } case '^': _advance(lexer); switch (_peek(lexer)) { - case '=': _advance(lexer); return TokenType::OpXorAssign; - default: return TokenType::OpBitXor; + case '=': + _advance(lexer); + return TokenType::OpXorAssign; + default: + return TokenType::OpBitXor; } case '>': @@ -1346,11 +1461,17 @@ static TokenType _lexTokenImpl(Lexer* lexer) _advance(lexer); switch (_peek(lexer)) { - case '=': _advance(lexer); return TokenType::OpShrAssign; - default: return TokenType::OpRsh; + case '=': + _advance(lexer); + return TokenType::OpShrAssign; + default: + return TokenType::OpRsh; } - case '=': _advance(lexer); return TokenType::OpGeq; - default: return TokenType::OpGreater; + case '=': + _advance(lexer); + return TokenType::OpGeq; + default: + return TokenType::OpGreater; } case '<': @@ -1361,41 +1482,60 @@ static TokenType _lexTokenImpl(Lexer* lexer) _advance(lexer); switch (_peek(lexer)) { - case '=': _advance(lexer); return TokenType::OpShlAssign; - default: return TokenType::OpLsh; + case '=': + _advance(lexer); + return TokenType::OpShlAssign; + default: + return TokenType::OpLsh; } - case '=': _advance(lexer); return TokenType::OpLeq; - default: return TokenType::OpLess; + case '=': + _advance(lexer); + return TokenType::OpLeq; + default: + return TokenType::OpLess; } case '=': _advance(lexer); switch (_peek(lexer)) { - case '=': _advance(lexer); return TokenType::OpEql; - default: return TokenType::OpAssign; + case '=': + _advance(lexer); + return TokenType::OpEql; + default: + return TokenType::OpAssign; } case '!': _advance(lexer); switch (_peek(lexer)) { - case '=': _advance(lexer); return TokenType::OpNeq; - default: return TokenType::OpNot; + case '=': + _advance(lexer); + return TokenType::OpNeq; + default: + return TokenType::OpNot; } case '#': _advance(lexer); switch (_peek(lexer)) { - case '#': _advance(lexer); return TokenType::PoundPound; + case '#': + _advance(lexer); + return TokenType::PoundPound; - case '?': _advance(lexer); return TokenType::CompletionRequest; + case '?': + _advance(lexer); + return TokenType::CompletionRequest; - default: return TokenType::Pound; + default: + return TokenType::Pound; } - case '~': _advance(lexer); return TokenType::OpBitNot; + case '~': + _advance(lexer); + return TokenType::OpBitNot; case ':': { @@ -1407,18 +1547,38 @@ static TokenType _lexTokenImpl(Lexer* lexer) } return TokenType::Colon; } - case ';': _advance(lexer); return TokenType::Semicolon; - case ',': _advance(lexer); return TokenType::Comma; - - case '{': _advance(lexer); return TokenType::LBrace; - case '}': _advance(lexer); return TokenType::RBrace; - case '[': _advance(lexer); return TokenType::LBracket; - case ']': _advance(lexer); return TokenType::RBracket; - case '(': _advance(lexer); return TokenType::LParent; - case ')': _advance(lexer); return TokenType::RParent; - - case '?': _advance(lexer); return TokenType::QuestionMark; - case '@': _advance(lexer); return TokenType::At; + case ';': + _advance(lexer); + return TokenType::Semicolon; + case ',': + _advance(lexer); + return TokenType::Comma; + + case '{': + _advance(lexer); + return TokenType::LBrace; + case '}': + _advance(lexer); + return TokenType::RBrace; + case '[': + _advance(lexer); + return TokenType::LBracket; + case ']': + _advance(lexer); + return TokenType::RBracket; + case '(': + _advance(lexer); + return TokenType::LParent; + case ')': + _advance(lexer); + return TokenType::RParent; + + case '?': + _advance(lexer); + return TokenType::QuestionMark; + case '@': + _advance(lexer); + return TokenType::At; case '$': { _advance(lexer); @@ -1565,7 +1725,8 @@ Token Lexer::lexToken() } continue; - default: break; + default: + break; } } *dst++ = c; @@ -1603,12 +1764,14 @@ TokenList Lexer::lexAllSemanticTokens() // switch (token.type) { - default: break; + default: + break; case TokenType::WhiteSpace: case TokenType::BlockComment: case TokenType::LineComment: - case TokenType::NewLine: continue; + case TokenType::NewLine: + continue; } tokenList.add(token); @@ -1625,10 +1788,12 @@ TokenList Lexer::lexAllMarkupTokens() Token token = lexToken(); switch (token.type) { - default: break; + default: + break; case TokenType::WhiteSpace: - case TokenType::NewLine: continue; + case TokenType::NewLine: + continue; } tokenList.add(token); diff --git a/source/compiler-core/slang-name-convention-util.cpp b/source/compiler-core/slang-name-convention-util.cpp index cb44aa10e..3c57f8bc4 100644 --- a/source/compiler-core/slang-name-convention-util.cpp +++ b/source/compiler-core/slang-name-convention-util.cpp @@ -34,8 +34,12 @@ namespace Slang { switch (c) { - case '-': flags |= Flag::Dash; break; - case '_': flags |= Flag::Underscore; break; + case '-': + flags |= Flag::Dash; + break; + case '_': + flags |= Flag::Underscore; + break; default: { if (CharUtil::isLower(c)) @@ -63,21 +67,28 @@ namespace Slang switch (flags) { // We'll assume it's lower camel. - case Flag::Lower: return NameConvention::LowerCamel; + case Flag::Lower: + return NameConvention::LowerCamel; // We'll assume it's upper snake. It almost certainly isn't camel, and snake is more usual // than kabab. - case Flag::Upper: return NameConvention::UpperSnake; + case Flag::Upper: + return NameConvention::UpperSnake; case Flag::Upper | Flag::Lower: { // Looks like camel, choose the right case based on first char return CharUtil::isUpper(slice[0]) ? NameConvention::UpperCamel : NameConvention::LowerCamel; } - case Flag::Lower | Flag::Dash: return NameConvention::LowerKabab; - case Flag::Upper | Flag::Dash: return NameConvention::UpperKabab; - case Flag::Lower | Flag::Underscore: return NameConvention::LowerSnake; - case Flag::Upper | Flag::Underscore: return NameConvention::UpperSnake; - default: break; + case Flag::Lower | Flag::Dash: + return NameConvention::LowerKabab; + case Flag::Upper | Flag::Dash: + return NameConvention::UpperKabab; + case Flag::Lower | Flag::Underscore: + return NameConvention::LowerSnake; + case Flag::Upper | Flag::Underscore: + return NameConvention::UpperSnake; + default: + break; } // Don't know what this style is @@ -90,9 +101,12 @@ namespace Slang { switch (c) { - case '-': return NameStyle::Kabab; - case '_': return NameStyle::Snake; - default: break; + case '-': + return NameStyle::Kabab; + case '_': + return NameStyle::Snake; + default: + break; } } return NameStyle::Camel; @@ -249,8 +263,10 @@ void NameConventionUtil::split(const UnownedStringSlice& slice, List<UnownedStri switch (style) { - case NameStyle::Kabab: return join(slices, slicesCount, convention, '-', out); - case NameStyle::Snake: return join(slices, slicesCount, convention, '_', out); + case NameStyle::Kabab: + return join(slices, slicesCount, convention, '-', out); + case NameStyle::Snake: + return join(slices, slicesCount, convention, '_', out); case NameStyle::Camel: { Index totalSize = 0; diff --git a/source/compiler-core/slang-nvrtc-compiler.cpp b/source/compiler-core/slang-nvrtc-compiler.cpp index 2a4597ddc..c5ccc8e23 100644 --- a/source/compiler-core/slang-nvrtc-compiler.cpp +++ b/source/compiler-core/slang-nvrtc-compiler.cpp @@ -91,7 +91,8 @@ static SlangResult _asResult(nvrtcResult res) { return SLANG_E_INTERNAL_FAIL; } - default: return SLANG_FAIL; + default: + return SLANG_FAIL; } } @@ -806,7 +807,8 @@ SlangResult NVRTCDownstreamCompiler::compile( switch (options.floatingPointMode) { - case FloatingPointMode::Default: break; + case FloatingPointMode::Default: + break; case FloatingPointMode::Precise: { break; diff --git a/source/compiler-core/slang-source-embed-util.cpp b/source/compiler-core/slang-source-embed-util.cpp index a4d3bf629..cfb83ed57 100644 --- a/source/compiler-core/slang-source-embed-util.cpp +++ b/source/compiler-core/slang-source-embed-util.cpp @@ -184,7 +184,8 @@ static SlangResult _append( // literalSuffix = toSlice("ULL"); break; } - default: return SLANG_FAIL; + default: + return SLANG_FAIL; } // Output the variable @@ -247,7 +248,9 @@ static SlangResult _append( switch (bytesPerElement) { - case 1: _appendHex<uint8_t>(lineBytes, workView, dstChars, bytesForLine, buf); break; + case 1: + _appendHex<uint8_t>(lineBytes, workView, dstChars, bytesForLine, buf); + break; case 2: _appendHex<uint16_t>((const uint16_t*)lineBytes, workView, dstChars, bytesForLine, buf); break; diff --git a/source/compiler-core/slang-source-loc.cpp b/source/compiler-core/slang-source-loc.cpp index 53eafbeaa..5058a1522 100644 --- a/source/compiler-core/slang-source-loc.cpp +++ b/source/compiler-core/slang-source-loc.cpp @@ -18,13 +18,15 @@ const String PathInfo::getMostUniqueIdentity() const { switch (type) { - case Type::Normal: return uniqueIdentity; + case Type::Normal: + return uniqueIdentity; case Type::FoundPath: case Type::FromString: { return foundPath; } - default: return ""; + default: + return ""; } } @@ -69,7 +71,8 @@ bool PathInfo::operator==(const ThisType& rhs) const // Only have a found path return foundPath == rhs.foundPath; } - default: break; + default: + break; } return false; @@ -79,10 +82,18 @@ void PathInfo::appendDisplayName(StringBuilder& out) const { switch (type) { - case Type::TokenPaste: out << "[Token Paste]"; break; - case Type::TypeParse: out << "[Type Parse]"; break; - case Type::Unknown: out << "[Unknown]"; break; - case Type::CommandLine: out << "[Command Line]"; break; + case Type::TokenPaste: + out << "[Token Paste]"; + break; + case Type::TypeParse: + out << "[Type Parse]"; + break; + case Type::Unknown: + out << "[Unknown]"; + break; + case Type::CommandLine: + out << "[Command Line]"; + break; case Type::Normal: case Type::FromString: case Type::FoundPath: @@ -93,7 +104,8 @@ void PathInfo::appendDisplayName(StringBuilder& out) const out); break; } - default: break; + default: + break; } } diff --git a/source/compiler-core/slang-token.cpp b/source/compiler-core/slang-token.cpp index 5dd64b96a..8b9ec3582 100644 --- a/source/compiler-core/slang-token.cpp +++ b/source/compiler-core/slang-token.cpp @@ -10,10 +10,13 @@ char const* TokenTypeToString(TokenType type) { switch (type) { - default: SLANG_ASSERT(!"unexpected"); return "<uknown>"; + default: + SLANG_ASSERT(!"unexpected"); + return "<uknown>"; #define TOKEN(NAME, DESC) \ - case TokenType::NAME: return DESC; + case TokenType::NAME: \ + return DESC; #include "slang-token-defs.h" } } diff --git a/source/compiler-core/slang-visual-studio-compiler-util.cpp b/source/compiler-core/slang-visual-studio-compiler-util.cpp index 449b0f973..d831abbd4 100644 --- a/source/compiler-core/slang-visual-studio-compiler-util.cpp +++ b/source/compiler-core/slang-visual-studio-compiler-util.cpp @@ -202,12 +202,14 @@ static void _addFile( cmdLine.addArg("/Ox"); break; } - default: break; + default: + break; } switch (options.floatingPointMode) { - case FloatingPointMode::Default: break; + case FloatingPointMode::Default: + break; case FloatingPointMode::Precise: { // precise is default behavior, VS also has 'strict' @@ -253,7 +255,8 @@ static void _addFile( cmdLine.addPrefixPathArg("/Fe", modulePath, ".exe"); break; } - default: break; + default: + break; } // Object file specify it's location - needed if we are out diff --git a/source/compiler-core/windows/slang-win-visual-studio-util.cpp b/source/compiler-core/windows/slang-win-visual-studio-util.cpp index 8496bb3fd..ed09448b5 100644 --- a/source/compiler-core/windows/slang-win-visual-studio-util.cpp +++ b/source/compiler-core/windows/slang-win-visual-studio-util.cpp @@ -155,12 +155,18 @@ static SlangResult _parseVersion(UnownedStringSlice versionString, SemanticVersi switch (version) { - case 1400: return _makeVersion(8); - case 1500: return _makeVersion(9); - case 1600: return _makeVersion(10); - case 1700: return _makeVersion(11); - case 1800: return _makeVersion(12); - default: break; + case 1400: + return _makeVersion(8); + case 1500: + return _makeVersion(9); + case 1600: + return _makeVersion(10); + case 1700: + return _makeVersion(11); + case 1800: + return _makeVersion(12); + default: + break; } // Seems like versions go in runs of 10 at this point @@ -174,41 +180,64 @@ static SlangResult _parseVersion(UnownedStringSlice versionString, SemanticVersi { switch (version) { - case 1910: return _makeVersion(15, 0); - case 1911: return _makeVersion(15, 3); - case 1912: return _makeVersion(15, 5); - case 1913: return _makeVersion(15, 6); - case 1914: return _makeVersion(15, 7); - case 1915: return _makeVersion(15, 8); - case 1916: return _makeVersion(15, 9); - default: return _makeVersion(15); + case 1910: + return _makeVersion(15, 0); + case 1911: + return _makeVersion(15, 3); + case 1912: + return _makeVersion(15, 5); + case 1913: + return _makeVersion(15, 6); + case 1914: + return _makeVersion(15, 7); + case 1915: + return _makeVersion(15, 8); + case 1916: + return _makeVersion(15, 9); + default: + return _makeVersion(15); } } else if (version >= 1920 && version < 1930) { switch (version) { - case 1920: return _makeVersion(16, 0); - case 1921: return _makeVersion(16, 1); - case 1922: return _makeVersion(16, 2); - case 1923: return _makeVersion(16, 3); - case 1924: return _makeVersion(16, 4); - case 1925: return _makeVersion(16, 5); - case 1926: return _makeVersion(16, 6); - case 1927: return _makeVersion(16, 7); - case 1928: return _makeVersion(16, 9); - case 1929: return _makeVersion(16, 11); - default: return _makeVersion(16); + case 1920: + return _makeVersion(16, 0); + case 1921: + return _makeVersion(16, 1); + case 1922: + return _makeVersion(16, 2); + case 1923: + return _makeVersion(16, 3); + case 1924: + return _makeVersion(16, 4); + case 1925: + return _makeVersion(16, 5); + case 1926: + return _makeVersion(16, 6); + case 1927: + return _makeVersion(16, 7); + case 1928: + return _makeVersion(16, 9); + case 1929: + return _makeVersion(16, 11); + default: + return _makeVersion(16); } } else if (version >= 1930 && version < 1940) { switch (version) { - case 1930: return _makeVersion(17, 0); - case 1931: return _makeVersion(17, 1); - case 1932: return _makeVersion(17, 2); - default: return _makeVersion(17); + case 1930: + return _makeVersion(17, 0); + case 1931: + return _makeVersion(17, 1); + case 1932: + return _makeVersion(17, 2); + default: + return _makeVersion(17); } } else if (version >= 1940) diff --git a/source/core/slang-byte-encode-util.cpp b/source/core/slang-byte-encode-util.cpp index acafdf2b4..f3f375c60 100644 --- a/source/core/slang-byte-encode-util.cpp +++ b/source/core/slang-byte-encode-util.cpp @@ -210,20 +210,31 @@ SLANG_FORCE_INLINE static uint32_t _decodeLiteCut2UInt32(const uint8_t* in, int #if SLANG_BYTE_ENCODE_USE_UNALIGNED_ACCESS switch (numBytesRemaining) { - case 2: value = *(const uint16_t*)in; break; - case 3: value = (uint32_t(in[2]) << 16) | (uint32_t(in[1]) << 8) | uint32_t(in[0]); break; - case 4: value = *(const uint32_t*)in; break; - default: break; + case 2: + value = *(const uint16_t*)in; + break; + case 3: + value = (uint32_t(in[2]) << 16) | (uint32_t(in[1]) << 8) | uint32_t(in[0]); + break; + case 4: + value = *(const uint32_t*)in; + break; + default: + break; } #else // This works on all cpus although slower value = in[0]; switch (numBytesRemaining) { - case 4: value |= uint32_t(in[3]) << 24; /* fall thru */ - case 3: value |= uint32_t(in[2]) << 16; /* fall thru */ - case 2: value |= uint32_t(in[1]) << 8; /* fall thru */ - case 1: break; + case 4: + value |= uint32_t(in[3]) << 24; /* fall thru */ + case 3: + value |= uint32_t(in[2]) << 16; /* fall thru */ + case 2: + value |= uint32_t(in[1]) << 8; /* fall thru */ + case 1: + break; } #endif return value; diff --git a/source/core/slang-command-options-writer.cpp b/source/core/slang-command-options-writer.cpp index f46bcc56c..9135998af 100644 --- a/source/core/slang-command-options-writer.cpp +++ b/source/core/slang-command-options-writer.cpp @@ -109,7 +109,8 @@ static bool _needsMarkdownEscape(const UnownedStringSlice& text) { return true; } - default: break; + default: + break; } } @@ -125,12 +126,23 @@ void _appendEscapedMarkdown(const UnownedStringSlice& text, StringBuilder& ioBuf { switch (c) { - case '<': ioBuf << "<"; break; - case '>': ioBuf << ">"; break; - case '&': ioBuf << "&"; break; - case '[': ioBuf << "\\["; break; - case ']': ioBuf << "\\]"; break; - default: ioBuf << c; + case '<': + ioBuf << "<"; + break; + case '>': + ioBuf << ">"; + break; + case '&': + ioBuf << "&"; + break; + case '[': + ioBuf << "\\["; + break; + case ']': + ioBuf << "\\]"; + break; + default: + ioBuf << c; } } } diff --git a/source/core/slang-file-system.cpp b/source/core/slang-file-system.cpp index 3e129f7bf..309b8c128 100644 --- a/source/core/slang-file-system.cpp +++ b/source/core/slang-file-system.cpp @@ -225,9 +225,14 @@ SlangResult OSFileSystem::enumeratePathContents( SlangPathType pathType; switch (type) { - case Path::Type::File: pathType = SLANG_PATH_TYPE_FILE; break; - case Path::Type::Directory: pathType = SLANG_PATH_TYPE_DIRECTORY; break; - default: return; + case Path::Type::File: + pathType = SLANG_PATH_TYPE_FILE; + break; + case Path::Type::Directory: + pathType = SLANG_PATH_TYPE_DIRECTORY; + break; + default: + return; } m_callback(pathType, m_buffer.getBuffer(), m_userData); @@ -298,9 +303,12 @@ SlangResult OSFileSystem::createDirectory(const char* path) } switch (res) { - case SLANG_E_CANNOT_OPEN: return CompressedResult::CannotOpen; - case SLANG_E_NOT_FOUND: return CompressedResult::NotFound; - default: return CompressedResult::Fail; + case SLANG_E_CANNOT_OPEN: + return CompressedResult::CannotOpen; + case SLANG_E_NOT_FOUND: + return CompressedResult::NotFound; + default: + return CompressedResult::Fail; } } @@ -377,7 +385,8 @@ void CacheFileSystem::setInnerFileSystem( : UniqueIdentityMode::SimplifyPathAndHash; break; } - default: break; + default: + break; } if (pathStyle == PathStyle::Default) @@ -779,9 +788,12 @@ SlangResult CacheFileSystem::getPath(PathKind kind, const char* path, ISlangBlob { switch (kind) { - case PathKind::Simplified: return _getSimplifiedPath(path, outPath); - case PathKind::Canonical: return _getCanonicalPath(path, outPath); - default: break; + case PathKind::Simplified: + return _getSimplifiedPath(path, outPath); + case PathKind::Canonical: + return _getCanonicalPath(path, outPath); + default: + break; } if (m_fileSystemExt) @@ -813,7 +825,8 @@ SlangResult CacheFileSystem::_getSimplifiedPath(const char* path, ISlangBlob** o *outSimplifiedPath = StringUtil::createStringBlob(simplifiedPath).detach(); return SLANG_OK; } - default: return SLANG_E_NOT_IMPLEMENTED; + default: + return SLANG_E_NOT_IMPLEMENTED; } } diff --git a/source/core/slang-http.cpp b/source/core/slang-http.cpp index fa7ca952b..ec1ccc0a2 100644 --- a/source/core/slang-http.cpp +++ b/source/core/slang-http.cpp @@ -247,9 +247,12 @@ SlangResult HTTPPacketConnection::update() { switch (m_readState) { - case ReadState::Closed: return SLANG_OK; - case ReadState::Error: return m_readResult; - default: break; + case ReadState::Closed: + return SLANG_OK; + case ReadState::Error: + return m_readResult; + default: + break; } SLANG_RETURN_ON_FAIL(_updateReadResult(m_readStream->update())); @@ -287,7 +290,8 @@ SlangResult HTTPPacketConnection::update() _handleContent(); break; } - default: break; + default: + break; } return m_readResult; diff --git a/source/core/slang-io.cpp b/source/core/slang-io.cpp index 25c4c9389..7bfde7bd7 100644 --- a/source/core/slang-io.cpp +++ b/source/core/slang-io.cpp @@ -381,7 +381,8 @@ String Path::combine(const String& path1, const String& path2, const String& pat return element[1] == ':' && ((firstChar >= 'a' && firstChar <= 'z') || (firstChar >= 'A' && firstChar <= 'Z')); } - default: return false; + default: + return false; } } @@ -783,7 +784,8 @@ SlangResult Path::remove(const String& path) } break; } - default: break; + default: + break; } return SLANG_FAIL; @@ -1025,13 +1027,15 @@ static SlangResult _calcExectuablePath(char* outPath, size_t* ioSize) uint32_t size = uint32_t(*ioSize); switch (_NSGetExecutablePath(outPath, &size)) { - case 0: return SLANG_OK; + case 0: + return SLANG_OK; case -1: { *ioSize = size; return SLANG_E_BUFFER_TOO_SMALL; } - default: break; + default: + break; } return SLANG_FAIL; #else diff --git a/source/core/slang-memory-file-system.cpp b/source/core/slang-memory-file-system.cpp index 2bca497e2..534f226d0 100644 --- a/source/core/slang-memory-file-system.cpp +++ b/source/core/slang-memory-file-system.cpp @@ -156,7 +156,8 @@ SlangResult MemoryFileSystem::getPath(PathKind kind, const char* path, ISlangBlo *outPath = StringBlob::moveCreate(buffer).detach(); return SLANG_OK; } - default: break; + default: + break; } return SLANG_E_NOT_AVAILABLE; } diff --git a/source/core/slang-platform.cpp b/source/core/slang-platform.cpp index ea8a2f4a5..79b883e39 100644 --- a/source/core/slang-platform.cpp +++ b/source/core/slang-platform.cpp @@ -138,7 +138,8 @@ SLANG_COMPILE_TIME_ASSERT(E_OUTOFMEMORY == SLANG_E_OUT_OF_MEMORY); { return SLANG_E_CANNOT_OPEN; } - default: break; + default: + break; } // Turn to Result, if not one of the well known errors return HRESULT_FROM_WIN32(lastError); diff --git a/source/core/slang-render-api-util.cpp b/source/core/slang-render-api-util.cpp index 476188abd..1e77c2ac6 100644 --- a/source/core/slang-render-api-util.cpp +++ b/source/core/slang-render-api-util.cpp @@ -183,7 +183,8 @@ static Token nextToken(Slang::UnownedStringSlice& textInOut, Slang::UnownedStrin SLANG_RETURN_ON_FAIL(findApiFlagsByName(lexeme, &apiFlags)); break; } - default: return SLANG_FAIL; + default: + return SLANG_FAIL; } while (true) @@ -196,8 +197,10 @@ static Token nextToken(Slang::UnownedStringSlice& textInOut, Slang::UnownedStrin *apiFlagsOut = apiFlags; return SLANG_OK; } - case Token::eOp: break; - default: return SLANG_FAIL; + case Token::eOp: + break; + default: + return SLANG_FAIL; } const char op = lexeme[0]; @@ -276,10 +279,13 @@ static bool _canLoadSharedLibrary(const char* libName) return _canLoadSharedLibrary("webgpu_dawn") && _canLoadSharedLibrary("dxcompiler") && _canLoadSharedLibrary("dxil"); #elif SLANG_APPLE_FAMILY - case RenderApiType::Vulkan: return true; - case RenderApiType::Metal: return true; + case RenderApiType::Vulkan: + return true; + case RenderApiType::Metal: + return true; #elif SLANG_UNIX_FAMILY - case RenderApiType::Vulkan: return true; + case RenderApiType::Vulkan: + return true; #endif #if SLANG_ENABLE_DIRECTX @@ -289,10 +295,13 @@ static bool _canLoadSharedLibrary(const char* libName) return _canLoadSharedLibrary(SLANG_ENABLE_VKD3D ? "vkd3d-proton-d3d12" : "d3d12"); #endif - case RenderApiType::CPU: return true; + case RenderApiType::CPU: + return true; // We'll assume CUDA is available, and if not, trying to create it will detect it - case RenderApiType::CUDA: return true; - default: break; + case RenderApiType::CUDA: + return true; + default: + break; } return false; } diff --git a/source/core/slang-riff-file-system.cpp b/source/core/slang-riff-file-system.cpp index b290ee5e5..7da076974 100644 --- a/source/core/slang-riff-file-system.cpp +++ b/source/core/slang-riff-file-system.cpp @@ -155,7 +155,8 @@ SlangResult RiffFileSystem::loadArchive(const void* archive, size_t archiveSizeI m_compressionSystem = LZ4CompressionSystem::getSingleton(); break; } - default: return SLANG_FAIL; + default: + return SLANG_FAIL; } // Read all of the contained data @@ -209,8 +210,10 @@ SlangResult RiffFileSystem::loadArchive(const void* archive, size_t archiveSizeI dstEntry.m_contents = RawBlob::create(srcData, srcEntry->compressedSize); break; } - case SLANG_PATH_TYPE_DIRECTORY: break; - default: return SLANG_FAIL; + case SLANG_PATH_TYPE_DIRECTORY: + break; + default: + return SLANG_FAIL; } // If it's the root entry we can ignore (as already added) diff --git a/source/core/slang-riff.cpp b/source/core/slang-riff.cpp index 94cd2038e..0eb0381e1 100644 --- a/source/core/slang-riff.cpp +++ b/source/core/slang-riff.cpp @@ -279,7 +279,8 @@ struct DumpVisitor : public RiffContainer::Visitor SLANG_RETURN_ON_FAIL(stream->write(trailing, remainingSize)); } } - default: break; + default: + break; } // Next @@ -411,7 +412,8 @@ SlangResult RiffContainer::Chunk::visit(Visitor* visitor) SLANG_RETURN_ON_FAIL(visitor->leaveList(list)); return SLANG_OK; } - default: return SLANG_FAIL; + default: + return SLANG_FAIL; } } @@ -438,7 +440,8 @@ SlangResult RiffContainer::Chunk::visitPreOrder(VisitorCallback callback, void* } return SLANG_OK; } - default: return SLANG_FAIL; + default: + return SLANG_FAIL; } } @@ -465,7 +468,8 @@ SlangResult RiffContainer::Chunk::visitPostOrder(VisitorCallback callback, void* SLANG_RETURN_ON_FAIL(callback(this, data)); return SLANG_OK; } - default: return SLANG_FAIL; + default: + return SLANG_FAIL; } } @@ -473,9 +477,12 @@ size_t RiffContainer::Chunk::calcPayloadSize() { switch (m_kind) { - case Kind::Data: return static_cast<DataChunk*>(this)->calcPayloadSize(); - case Kind::List: return static_cast<ListChunk*>(this)->calcPayloadSize(); - default: return 0; + case Kind::Data: + return static_cast<DataChunk*>(this)->calcPayloadSize(); + case Kind::List: + return static_cast<ListChunk*>(this)->calcPayloadSize(); + default: + return 0; } } diff --git a/source/core/slang-rtti-info.cpp b/source/core/slang-rtti-info.cpp index 9ca1c19b6..070b9c204 100644 --- a/source/core/slang-rtti-info.cpp +++ b/source/core/slang-rtti-info.cpp @@ -109,15 +109,33 @@ static void _appendFixedArray(const FixedArrayRttiInfo* inFixedArray, StringBuil { switch (info->m_kind) { - case RttiInfo::Kind::I32: out << "int32_t"; break; - case RttiInfo::Kind::U32: out << "uint32_t"; break; - case RttiInfo::Kind::I64: out << "int64_t"; break; - case RttiInfo::Kind::U64: out << "uint64_t"; break; - case RttiInfo::Kind::F32: out << "float"; break; - case RttiInfo::Kind::F64: out << "double"; break; - case RttiInfo::Kind::Bool: out << "bool"; break; - case RttiInfo::Kind::String: out << "String"; break; - case RttiInfo::Kind::UnownedStringSlice: out << "UnownedStringSlice"; break; + case RttiInfo::Kind::I32: + out << "int32_t"; + break; + case RttiInfo::Kind::U32: + out << "uint32_t"; + break; + case RttiInfo::Kind::I64: + out << "int64_t"; + break; + case RttiInfo::Kind::U64: + out << "uint64_t"; + break; + case RttiInfo::Kind::F32: + out << "float"; + break; + case RttiInfo::Kind::F64: + out << "double"; + break; + case RttiInfo::Kind::Bool: + out << "bool"; + break; + case RttiInfo::Kind::String: + out << "String"; + break; + case RttiInfo::Kind::UnownedStringSlice: + out << "UnownedStringSlice"; + break; case RttiInfo::Kind::Ptr: { const PtrRttiInfo* ptrRttiInfo = static_cast<const PtrRttiInfo*>(info); diff --git a/source/core/slang-rtti-util.cpp b/source/core/slang-rtti-util.cpp index 701c90e2f..92f45a3bf 100644 --- a/source/core/slang-rtti-util.cpp +++ b/source/core/slang-rtti-util.cpp @@ -315,22 +315,30 @@ RttiTypeFuncs RttiUtil::getDefaultTypeFuncs(const RttiInfo* rttiInfo) { switch (rttiInfo->m_size) { - case 1: return GetRttiTypeFuncsForZeroPod<uint8_t>::getFuncs(); - case 2: return GetRttiTypeFuncsForZeroPod<uint16_t>::getFuncs(); - case 4: return GetRttiTypeFuncsForZeroPod<uint32_t>::getFuncs(); - case 8: return GetRttiTypeFuncsForZeroPod<uint64_t>::getFuncs(); + case 1: + return GetRttiTypeFuncsForZeroPod<uint8_t>::getFuncs(); + case 2: + return GetRttiTypeFuncsForZeroPod<uint16_t>::getFuncs(); + case 4: + return GetRttiTypeFuncsForZeroPod<uint32_t>::getFuncs(); + case 8: + return GetRttiTypeFuncsForZeroPod<uint64_t>::getFuncs(); } return RttiTypeFuncs::makeEmpty(); } switch (rttiInfo->m_kind) { - case RttiInfo::Kind::String: return GetRttiTypeFuncs<String>::getFuncs(); + case RttiInfo::Kind::String: + return GetRttiTypeFuncs<String>::getFuncs(); case RttiInfo::Kind::UnownedStringSlice: return GetRttiTypeFuncs<UnownedStringSlice>::getFuncs(); - case RttiInfo::Kind::List: return ListFuncs::getFuncs(); - case RttiInfo::Kind::Struct: return StructArrayFuncs::getFuncs(); - default: break; + case RttiInfo::Kind::List: + return ListFuncs::getFuncs(); + case RttiInfo::Kind::Struct: + return StructArrayFuncs::getFuncs(); + default: + break; } return RttiTypeFuncs::makeEmpty(); @@ -344,11 +352,20 @@ RttiTypeFuncs RttiUtil::getDefaultTypeFuncs(const RttiInfo* rttiInfo) // Passing in rttiInfo allows for other more complex types to be econverted switch (rttiInfo->m_kind) { - case RttiInfo::Kind::I32: *(int32_t*)dst = int32_t(value); break; - case RttiInfo::Kind::U32: *(uint32_t*)dst = uint32_t(value); break; - case RttiInfo::Kind::I64: *(int64_t*)dst = int64_t(value); break; - case RttiInfo::Kind::U64: *(uint64_t*)dst = uint64_t(value); break; - default: return SLANG_FAIL; + case RttiInfo::Kind::I32: + *(int32_t*)dst = int32_t(value); + break; + case RttiInfo::Kind::U32: + *(uint32_t*)dst = uint32_t(value); + break; + case RttiInfo::Kind::I64: + *(int64_t*)dst = int64_t(value); + break; + case RttiInfo::Kind::U64: + *(uint64_t*)dst = uint64_t(value); + break; + default: + return SLANG_FAIL; } return SLANG_OK; } @@ -359,11 +376,16 @@ RttiTypeFuncs RttiUtil::getDefaultTypeFuncs(const RttiInfo* rttiInfo) switch (rttiInfo->m_kind) { - case RttiInfo::Kind::I32: return *(const int32_t*)src; - case RttiInfo::Kind::U32: return *(const uint32_t*)src; - case RttiInfo::Kind::I64: return *(const int64_t*)src; - case RttiInfo::Kind::U64: return *(const uint64_t*)src; - default: break; + case RttiInfo::Kind::I32: + return *(const int32_t*)src; + case RttiInfo::Kind::U32: + return *(const uint32_t*)src; + case RttiInfo::Kind::I64: + return *(const int64_t*)src; + case RttiInfo::Kind::U64: + return *(const uint64_t*)src; + default: + break; } SLANG_ASSERT(!"Not integral!"); @@ -380,9 +402,12 @@ RttiTypeFuncs RttiUtil::getDefaultTypeFuncs(const RttiInfo* rttiInfo) { switch (rttiInfo->m_kind) { - case RttiInfo::Kind::F32: return *(const float*)src; - case RttiInfo::Kind::F64: return *(const double*)src; - default: break; + case RttiInfo::Kind::F32: + return *(const float*)src; + case RttiInfo::Kind::F64: + return *(const double*)src; + default: + break; } } @@ -400,9 +425,14 @@ RttiTypeFuncs RttiUtil::getDefaultTypeFuncs(const RttiInfo* rttiInfo) { switch (rttiInfo->m_kind) { - case RttiInfo::Kind::F32: *(float*)dst = float(v); return SLANG_OK; - case RttiInfo::Kind::F64: *(double*)dst = v; return SLANG_OK; - default: break; + case RttiInfo::Kind::F32: + *(float*)dst = float(v); + return SLANG_OK; + case RttiInfo::Kind::F64: + *(double*)dst = v; + return SLANG_OK; + default: + break; } } @@ -434,9 +464,12 @@ static int64_t _getIntDefaultValue(RttiDefaultValue value) switch (value) { default: - case RttiDefaultValue::Normal: return 0; - case RttiDefaultValue::One: return 1; - case RttiDefaultValue::MinusOne: return -1; + case RttiDefaultValue::Normal: + return 0; + case RttiDefaultValue::One: + return 1; + case RttiDefaultValue::MinusOne: + return -1; } } @@ -487,8 +520,10 @@ static bool _isStructDefault(const StructRttiInfo* type, const void* src) switch (rttiInfo->m_kind) { - case RttiInfo::Kind::Invalid: return true; - case RttiInfo::Kind::Bool: return *(const bool*)src == (_getIntDefaultValue(defaultValue) != 0); + case RttiInfo::Kind::Invalid: + return true; + case RttiInfo::Kind::Bool: + return *(const bool*)src == (_getIntDefaultValue(defaultValue) != 0); case RttiInfo::Kind::String: { return ((const String*)src)->getLength() == 0; diff --git a/source/core/slang-semantic-version.cpp b/source/core/slang-semantic-version.cpp index ab7b5007b..b05eb503f 100644 --- a/source/core/slang-semantic-version.cpp +++ b/source/core/slang-semantic-version.cpp @@ -152,7 +152,8 @@ void SemanticVersion::append(StringBuilder& buf) const matchVersion.m_version.m_patch + 1); break; } - default: break; + default: + break; } List<SemanticVersion> sortedVersions; @@ -198,9 +199,15 @@ void MatchSemanticVersion::append(StringBuilder& buf) const switch (m_kind) { default: - case Kind::Unknown: buf << "unknown"; break; - case Kind::Past: buf << "past"; break; - case Kind::Future: buf << "future"; break; + case Kind::Unknown: + buf << "unknown"; + break; + case Kind::Past: + buf << "past"; + break; + case Kind::Future: + buf << "future"; + break; case Kind::Major: { buf << m_version.m_major; diff --git a/source/core/slang-signal.cpp b/source/core/slang-signal.cpp index 1600183e7..4ae75eb0e 100644 --- a/source/core/slang-signal.cpp +++ b/source/core/slang-signal.cpp @@ -10,13 +10,20 @@ static const char* _getSignalTypeAsText(SignalType type) { switch (type) { - case SignalType::AssertFailure: return "assert failure"; - case SignalType::Unimplemented: return "unimplemented"; - case SignalType::Unreachable: return "hit unreachable code"; - case SignalType::Unexpected: return "unexpected"; - case SignalType::InvalidOperation: return "invalid operation"; - case SignalType::AbortCompilation: return "abort compilation"; - default: return "unhandled"; + case SignalType::AssertFailure: + return "assert failure"; + case SignalType::Unimplemented: + return "unimplemented"; + case SignalType::Unreachable: + return "hit unreachable code"; + case SignalType::Unexpected: + return "unexpected"; + case SignalType::InvalidOperation: + return "invalid operation"; + case SignalType::AbortCompilation: + return "abort compilation"; + default: + return "unhandled"; } } @@ -50,9 +57,12 @@ String _getMessage(SignalType type, char const* message) #if SLANG_HAS_EXCEPTIONS switch (type) { - case SignalType::InvalidOperation: throw InvalidOperationException(_getMessage(type, message)); - case SignalType::AbortCompilation: throw AbortCompilationException(_getMessage(type, message)); - default: throw InternalError(_getMessage(type, message)); + case SignalType::InvalidOperation: + throw InvalidOperationException(_getMessage(type, message)); + case SignalType::AbortCompilation: + throw AbortCompilationException(_getMessage(type, message)); + default: + throw InternalError(_getMessage(type, message)); } #else // Attempt to drop out into the debugger. If a debugger isn't attached this will likely crash - diff --git a/source/core/slang-stream.cpp b/source/core/slang-stream.cpp index ca7528f61..6af3f959e 100644 --- a/source/core/slang-stream.cpp +++ b/source/core/slang-stream.cpp @@ -123,7 +123,8 @@ SlangResult FileStream::_init( mode = "ab"; } break; - default: break; + default: + break; } #ifdef _WIN32 @@ -144,11 +145,21 @@ SlangResult FileStream::_init( int shFlag = _SH_DENYRW; switch (share) { - case FileShare::None: shFlag = _SH_DENYRW; break; - case FileShare::ReadOnly: shFlag = _SH_DENYWR; break; - case FileShare::WriteOnly: shFlag = _SH_DENYRD; break; - case FileShare::ReadWrite: shFlag = _SH_DENYNO; break; - default: SLANG_ASSERT(!"Invalid file share mode."); return SLANG_FAIL; + case FileShare::None: + shFlag = _SH_DENYRW; + break; + case FileShare::ReadOnly: + shFlag = _SH_DENYWR; + break; + case FileShare::WriteOnly: + shFlag = _SH_DENYRD; + break; + case FileShare::ReadWrite: + shFlag = _SH_DENYNO; + break; + default: + SLANG_ASSERT(!"Invalid file share mode."); + return SLANG_FAIL; } if (share == FileShare::None) #pragma warning(suppress : 4996) @@ -193,10 +204,18 @@ SlangResult FileStream::seek(SeekOrigin seekOrigin, Int64 offset) int fseekOrigin; switch (seekOrigin) { - case SeekOrigin::Start: fseekOrigin = SEEK_SET; break; - case SeekOrigin::End: fseekOrigin = SEEK_END; break; - case SeekOrigin::Current: fseekOrigin = SEEK_CUR; break; - default: SLANG_ASSERT(!"Unsupported seek origin."); return SLANG_FAIL; + case SeekOrigin::Start: + fseekOrigin = SEEK_SET; + break; + case SeekOrigin::End: + fseekOrigin = SEEK_END; + break; + case SeekOrigin::Current: + fseekOrigin = SEEK_CUR; + break; + default: + SLANG_ASSERT(!"Unsupported seek origin."); + return SLANG_FAIL; } // If endReached is intended to be like feof - then doing a seek will reset it @@ -285,10 +304,18 @@ SlangResult MemoryStreamBase::seek(SeekOrigin origin, Int64 offset) Int64 pos = 0; switch (origin) { - case SeekOrigin::Start: pos = offset; break; - case SeekOrigin::End: pos = Int64(m_contentsSize) + offset; break; - case SeekOrigin::Current: pos = Int64(m_position) + offset; break; - default: SLANG_ASSERT(!"Unsupported seek origin."); return SLANG_E_NOT_IMPLEMENTED; + case SeekOrigin::Start: + pos = offset; + break; + case SeekOrigin::End: + pos = Int64(m_contentsSize) + offset; + break; + case SeekOrigin::Current: + pos = Int64(m_position) + offset; + break; + default: + SLANG_ASSERT(!"Unsupported seek origin."); + return SLANG_E_NOT_IMPLEMENTED; } m_atEnd = false; @@ -682,10 +709,14 @@ static FILE* _getFileFromStdStreamType(StdStreamType stdStream) { switch (stdStream) { - case StdStreamType::ErrorOut: return stderr; - case StdStreamType::Out: return stdout; - case StdStreamType::In: return stdin; - default: return nullptr; + case StdStreamType::ErrorOut: + return stderr; + case StdStreamType::Out: + return stdout; + case StdStreamType::In: + return stdin; + default: + return nullptr; } } @@ -693,10 +724,13 @@ static int _getBufferOptions(StreamBufferStyle style) { switch (style) { - case StreamBufferStyle::None: return _IONBF; - case StreamBufferStyle::Line: return _IOLBF; + case StreamBufferStyle::None: + return _IONBF; + case StreamBufferStyle::Line: + return _IOLBF; default: - case StreamBufferStyle::Full: return _IOFBF; + case StreamBufferStyle::Full: + return _IOFBF; } } diff --git a/source/core/slang-string-escape-util.cpp b/source/core/slang-string-escape-util.cpp index a6a70ce76..42e757b23 100644 --- a/source/core/slang-string-escape-util.cpp +++ b/source/core/slang-string-escape-util.cpp @@ -141,17 +141,28 @@ static char _getCppEscapedChar(char c) { switch (c) { - case '\b': return 'b'; - case '\f': return 'f'; - case '\n': return 'n'; - case '\r': return 'r'; - case '\a': return 'a'; - case '\t': return 't'; - case '\v': return 'v'; - case '\'': return '\''; - case '\"': return '"'; - case '\\': return '\\'; - default: return 0; + case '\b': + return 'b'; + case '\f': + return 'f'; + case '\n': + return 'n'; + case '\r': + return 'r'; + case '\a': + return 'a'; + case '\t': + return 't'; + case '\v': + return 'v'; + case '\'': + return '\''; + case '\"': + return '"'; + case '\\': + return '\\'; + default: + return 0; } } @@ -159,17 +170,28 @@ static char _getCppUnescapedChar(char c) { switch (c) { - case 'b': return '\b'; - case 'f': return '\f'; - case 'n': return '\n'; - case 'r': return '\r'; - case 'a': return '\a'; - case 't': return '\t'; - case 'v': return '\v'; - case '\'': return '\''; - case '\"': return '"'; - case '\\': return '\\'; - default: return 0; + case 'b': + return '\b'; + case 'f': + return '\f'; + case 'n': + return '\n'; + case 'r': + return '\r'; + case 'a': + return '\a'; + case 't': + return '\t'; + case 'v': + return '\v'; + case '\'': + return '\''; + case '\"': + return '"'; + case '\\': + return '\\'; + default: + return 0; } } @@ -669,7 +691,8 @@ SlangResult JSONStringEscapeHandler::lexQuoted(const char* cursor, const char** switch (c) { - case 0: return SLANG_FAIL; + case 0: + return SLANG_FAIL; case '"': { *outCursor = cursor; @@ -708,7 +731,8 @@ SlangResult JSONStringEscapeHandler::lexQuoted(const char* cursor, const char** } } // Somewhat surprisingly it appears it's valid to have \r\n inside of quotes. - default: break; + default: + break; } } } @@ -717,15 +741,24 @@ static char _getJSONEscapedChar(char c) { switch (c) { - case '\b': return 'b'; - case '\f': return 'f'; - case '\n': return 'n'; - case '\r': return 'r'; - case '\t': return 't'; - case '\\': return '\\'; - case '/': return '/'; - case '"': return '"'; - default: return 0; + case '\b': + return 'b'; + case '\f': + return 'f'; + case '\n': + return 'n'; + case '\r': + return 'r'; + case '\t': + return 't'; + case '\\': + return '\\'; + case '/': + return '/'; + case '"': + return '"'; + default: + return 0; } } @@ -733,15 +766,24 @@ static char _getJSONUnescapedChar(char c) { switch (c) { - case 'b': return '\b'; - case 'f': return '\f'; - case 'n': return '\n'; - case 'r': return '\r'; - case 't': return '\t'; - case '\\': return '\\'; - case '/': return '/'; - case '"': return '"'; - default: return 0; + case 'b': + return '\b'; + case 'f': + return '\f'; + case 'n': + return '\n'; + case 'r': + return '\r'; + case 't': + return '\t'; + case '\\': + return '\\'; + case '/': + return '/'; + case '"': + return '"'; + default: + return 0; } } @@ -997,14 +1039,19 @@ StringEscapeUtil::Handler* StringEscapeUtil::getHandler(Style style) { switch (style) { - case Style::Cpp: return &g_cppHandler; - case Style::Space: return &g_spaceHandler; - case Style::JSON: return &g_jsonHandler; + case Style::Cpp: + return &g_cppHandler; + case Style::Space: + return &g_spaceHandler; + case Style::JSON: + return &g_jsonHandler; // TODO(JS): For now we make Slang language string encoding/decoding the same as C++ // That may not be desirable because C++ has a variety of surprising edge cases (for example // around \x) - case Style::Slang: return &g_cppHandler; - default: return nullptr; + case Style::Slang: + return &g_cppHandler; + default: + return nullptr; } } diff --git a/source/core/slang-string-util.cpp b/source/core/slang-string-util.cpp index 1f67089a5..6f1dc2ccb 100644 --- a/source/core/slang-string-util.cpp +++ b/source/core/slang-string-util.cpp @@ -577,7 +577,8 @@ String StringUtil::replaceAll( outLine = UnownedStringSlice(begin, lineEnd); return true; } - default: break; + default: + break; } } diff --git a/source/core/slang-string.cpp b/source/core/slang-string.cpp index b58d466fa..e9804eaa8 100644 --- a/source/core/slang-string.cpp +++ b/source/core/slang-string.cpp @@ -367,11 +367,16 @@ OSString String::toWString(Index* outLength) const List<Byte> buf; switch (sizeof(wchar_t)) { - case 2: Slang::CharEncoding::UTF16->encode(getUnownedSlice(), buf); break; + case 2: + Slang::CharEncoding::UTF16->encode(getUnownedSlice(), buf); + break; - case 4: Slang::CharEncoding::UTF32->encode(getUnownedSlice(), buf); break; + case 4: + Slang::CharEncoding::UTF32->encode(getUnownedSlice(), buf); + break; - default: break; + default: + break; } auto length = Index(buf.getCount() / sizeof(wchar_t)); @@ -688,9 +693,12 @@ Index UnownedStringSlice::indexOf(const UnownedStringSlice& in) const const char* inChars = in.m_begin; switch (inLen) { - case 0: return 0; - case 1: return indexOf(inChars[0]); - default: break; + case 0: + return 0; + case 1: + return indexOf(inChars[0]); + default: + break; } const char* chars = m_begin; diff --git a/source/core/slang-test-tool-util.cpp b/source/core/slang-test-tool-util.cpp index a71048f10..06a94bb9d 100644 --- a/source/core/slang-test-tool-util.cpp +++ b/source/core/slang-test-tool-util.cpp @@ -12,10 +12,14 @@ namespace Slang { switch (res) { - case SLANG_OK: return ToolReturnCode::Success; - case SLANG_E_INTERNAL_FAIL: return ToolReturnCode::CompilationFailed; - case SLANG_FAIL: return ToolReturnCode::Failed; - case SLANG_E_NOT_AVAILABLE: return ToolReturnCode::Ignored; + case SLANG_OK: + return ToolReturnCode::Success; + case SLANG_E_INTERNAL_FAIL: + return ToolReturnCode::CompilationFailed; + case SLANG_FAIL: + return ToolReturnCode::Failed; + case SLANG_E_NOT_AVAILABLE: + return ToolReturnCode::Ignored; default: { return (SLANG_SUCCEEDED(res)) ? ToolReturnCode::Success : ToolReturnCode::Failed; diff --git a/source/core/slang-token-reader.cpp b/source/core/slang-token-reader.cpp index d37ee0ed4..1dcce0655 100644 --- a/source/core/slang-token-reader.cpp +++ b/source/core/slang-token-reader.cpp @@ -369,12 +369,24 @@ List<Token> TokenizeText(const String& fileName, const String& text) { case '\\': case '\"': - case '\'': tokenBuilder.append(nextChar); break; - case 't': tokenBuilder.append('\t'); break; - case 's': tokenBuilder.append(' '); break; - case 'n': tokenBuilder.append('\n'); break; - case 'r': tokenBuilder.append('\r'); break; - case 'b': tokenBuilder.append('\b'); break; + case '\'': + tokenBuilder.append(nextChar); + break; + case 't': + tokenBuilder.append('\t'); + break; + case 's': + tokenBuilder.append(' '); + break; + case 'n': + tokenBuilder.append('\n'); + break; + case 'r': + tokenBuilder.append('\r'); + break; + case 'b': + tokenBuilder.append('\b'); + break; } }; while (pos <= text.getLength()) diff --git a/source/core/slang-type-convert-util.cpp b/source/core/slang-type-convert-util.cpp index 3eb053726..db59215b5 100644 --- a/source/core/slang-type-convert-util.cpp +++ b/source/core/slang-type-convert-util.cpp @@ -13,14 +13,22 @@ namespace Slang { return SLANG_SOURCE_LANGUAGE_GLSL; } - case SLANG_HLSL: return SLANG_SOURCE_LANGUAGE_HLSL; - case SLANG_C_SOURCE: return SLANG_SOURCE_LANGUAGE_C; - case SLANG_CPP_SOURCE: return SLANG_SOURCE_LANGUAGE_CPP; - case SLANG_CPP_PYTORCH_BINDING: return SLANG_SOURCE_LANGUAGE_CPP; - case SLANG_HOST_CPP_SOURCE: return SLANG_SOURCE_LANGUAGE_CPP; - case SLANG_CUDA_SOURCE: return SLANG_SOURCE_LANGUAGE_CUDA; - case SLANG_WGSL: return SLANG_SOURCE_LANGUAGE_WGSL; - default: break; + case SLANG_HLSL: + return SLANG_SOURCE_LANGUAGE_HLSL; + case SLANG_C_SOURCE: + return SLANG_SOURCE_LANGUAGE_C; + case SLANG_CPP_SOURCE: + return SLANG_SOURCE_LANGUAGE_CPP; + case SLANG_CPP_PYTORCH_BINDING: + return SLANG_SOURCE_LANGUAGE_CPP; + case SLANG_HOST_CPP_SOURCE: + return SLANG_SOURCE_LANGUAGE_CPP; + case SLANG_CUDA_SOURCE: + return SLANG_SOURCE_LANGUAGE_CUDA; + case SLANG_WGSL: + return SLANG_SOURCE_LANGUAGE_WGSL; + default: + break; } return SLANG_SOURCE_LANGUAGE_UNKNOWN; } @@ -30,11 +38,16 @@ namespace Slang { switch (lang) { - case SLANG_SOURCE_LANGUAGE_GLSL: return SLANG_GLSL; - case SLANG_SOURCE_LANGUAGE_HLSL: return SLANG_HLSL; - case SLANG_SOURCE_LANGUAGE_C: return SLANG_C_SOURCE; - case SLANG_SOURCE_LANGUAGE_CPP: return SLANG_CPP_SOURCE; - case SLANG_SOURCE_LANGUAGE_CUDA: return SLANG_CUDA_SOURCE; + case SLANG_SOURCE_LANGUAGE_GLSL: + return SLANG_GLSL; + case SLANG_SOURCE_LANGUAGE_HLSL: + return SLANG_HLSL; + case SLANG_SOURCE_LANGUAGE_C: + return SLANG_C_SOURCE; + case SLANG_SOURCE_LANGUAGE_CPP: + return SLANG_CPP_SOURCE; + case SLANG_SOURCE_LANGUAGE_CUDA: + return SLANG_CUDA_SOURCE; } return SLANG_TARGET_UNKNOWN; diff --git a/source/core/slang-type-text-util.cpp b/source/core/slang-type-text-util.cpp index 0afd25342..01ce0d1ac 100644 --- a/source/core/slang-type-text-util.cpp +++ b/source/core/slang-type-text-util.cpp @@ -281,9 +281,11 @@ static const NamesDescriptionValue s_fileSystemTypes[] = { switch (scalarType) { #define SLANG_SCALAR_TYPE_TO_TEXT(value, text) \ - case ScalarType::value: return UnownedStringSlice::fromLiteral(#text); + case ScalarType::value: \ + return UnownedStringSlice::fromLiteral(#text); SLANG_SCALAR_TYPES(SLANG_SCALAR_TYPE_TO_TEXT) - default: break; + default: + break; } return UnownedStringSlice(); diff --git a/source/core/slang-writer.cpp b/source/core/slang-writer.cpp index eb315323c..b3a48d9c7 100644 --- a/source/core/slang-writer.cpp +++ b/source/core/slang-writer.cpp @@ -177,7 +177,8 @@ SlangResult FileWriter::setMode(SlangWriterMode mode) break; #endif } - default: break; + default: + break; } return SLANG_FAIL; } diff --git a/source/core/slang-zip-file-system.cpp b/source/core/slang-zip-file-system.cpp index b3c50ab57..9c805dc55 100644 --- a/source/core/slang-zip-file-system.cpp +++ b/source/core/slang-zip-file-system.cpp @@ -289,7 +289,8 @@ SlangResult ZipFileSystemImpl::_copyToAndInitWriter(mz_zip_archive& outWriter) return SLANG_OK; } - default: break; + default: + break; } return SLANG_FAIL; } @@ -316,7 +317,8 @@ SlangResult ZipFileSystemImpl::_requireModeImpl(Mode newMode) _initReadWrite(m_archive); break; } - default: break; + default: + break; } break; } @@ -412,7 +414,8 @@ SlangResult ZipFileSystemImpl::_requireModeImpl(Mode newMode) } break; } - default: break; + default: + break; } } } @@ -581,7 +584,8 @@ SlangResult ZipFileSystemImpl::getPath(PathKind pathKind, const char* path, ISla *outPath = StringUtil::createStringBlob(Path::simplify(path)).detach(); return SLANG_OK; } - default: break; + default: + break; } return SLANG_E_NOT_AVAILABLE; @@ -856,9 +860,15 @@ void ZipFileSystemImpl::setCompressionStyle(const CompressionStyle& style) { switch (style.m_type) { - case CompressionStyle::Type::BestSpeed: m_compressionLevel = MZ_BEST_SPEED; break; - case CompressionStyle::Type::BestCompression: m_compressionLevel = MZ_BEST_COMPRESSION; break; - case CompressionStyle::Type::Default: m_compressionLevel = MZ_DEFAULT_LEVEL; break; + case CompressionStyle::Type::BestSpeed: + m_compressionLevel = MZ_BEST_SPEED; + break; + case CompressionStyle::Type::BestCompression: + m_compressionLevel = MZ_BEST_COMPRESSION; + break; + case CompressionStyle::Type::Default: + m_compressionLevel = MZ_DEFAULT_LEVEL; + break; case CompressionStyle::Type::Level: { int level = int(style.m_level * 10.0f + 0.5); diff --git a/source/core/unix/slang-unix-process.cpp b/source/core/unix/slang-unix-process.cpp index 97b59f21c..b3abc873c 100644 --- a/source/core/unix/slang-unix-process.cpp +++ b/source/core/unix/slang-unix-process.cpp @@ -653,7 +653,8 @@ closePipes: out = new UnixPipeStream(STDERR_FILENO, FileAccess::Write, false); break; } - default: return SLANG_FAIL; + default: + return SLANG_FAIL; } return SLANG_OK; } diff --git a/source/slang-glslang/slang-glslang.cpp b/source/slang-glslang/slang-glslang.cpp index 29a18642b..6bfd112a7 100644 --- a/source/slang-glslang/slang-glslang.cpp +++ b/source/slang-glslang/slang-glslang.cpp @@ -104,11 +104,18 @@ struct SPIRVOptimizationDiagnostic { case SPV_MSG_FATAL: case SPV_MSG_INTERNAL_ERROR: - case SPV_MSG_ERROR: out << "error: "; break; - case SPV_MSG_WARNING: out << "warning: "; break; + case SPV_MSG_ERROR: + out << "error: "; + break; + case SPV_MSG_WARNING: + out << "warning: "; + break; case SPV_MSG_INFO: - case SPV_MSG_DEBUG: out << "info: "; break; - default: break; + case SPV_MSG_DEBUG: + out << "info: "; + break; + default: + break; } if (source.length()) { @@ -149,7 +156,8 @@ static void validationMessageConsumer( case SPV_MSG_INFO: std::cout << "info: line " << position.index << ": " << message << std::endl; break; - default: break; + default: + break; } } @@ -560,13 +568,20 @@ static spv_target_env _getUniversalTargetEnv(glslang::EShTargetLanguageVersion i switch (ver) { - case 0x100: return SPV_ENV_UNIVERSAL_1_0; - case 0x101: return SPV_ENV_UNIVERSAL_1_1; - case 0x102: return SPV_ENV_UNIVERSAL_1_2; - case 0x103: return SPV_ENV_UNIVERSAL_1_3; - case 0x104: return SPV_ENV_UNIVERSAL_1_4; - case 0x105: return SPV_ENV_UNIVERSAL_1_5; - case 0x106: return SPV_ENV_UNIVERSAL_1_6; + case 0x100: + return SPV_ENV_UNIVERSAL_1_0; + case 0x101: + return SPV_ENV_UNIVERSAL_1_1; + case 0x102: + return SPV_ENV_UNIVERSAL_1_2; + case 0x103: + return SPV_ENV_UNIVERSAL_1_3; + case 0x104: + return SPV_ENV_UNIVERSAL_1_4; + case 0x105: + return SPV_ENV_UNIVERSAL_1_5; + case 0x106: + return SPV_ENV_UNIVERSAL_1_6; default: { if (ver > 0x106) @@ -589,8 +604,10 @@ static int glslang_compileGLSLToSPIRV(glslang_CompileRequest_1_2 request) EShLanguage glslangStage; switch (request.slangStage) { -#define CASE(SP, GL) \ - case SLANG_STAGE_##SP: glslangStage = EShLang##GL; break +#define CASE(SP, GL) \ + case SLANG_STAGE_##SP: \ + glslangStage = EShLang##GL; \ + break CASE(VERTEX, Vertex); CASE(FRAGMENT, Fragment); CASE(GEOMETRY, Geometry); @@ -609,7 +626,9 @@ static int glslang_compileGLSLToSPIRV(glslang_CompileRequest_1_2 request) CASE(AMPLIFICATION, Task); #undef CASE - default: dumpDiagnostics(request, "internal error: stage unsupported by glslang\n"); return 1; + default: + dumpDiagnostics(request, "internal error: stage unsupported by glslang\n"); + return 1; } spv_target_env targetEnv = SPV_ENV_UNIVERSAL_1_2; @@ -838,13 +857,21 @@ static int _compile(const glslang_CompileRequest_1_2& request) int result = 0; switch (request.action) { - default: result = 1; break; + default: + result = 1; + break; - case GLSLANG_ACTION_COMPILE_GLSL_TO_SPIRV: result = glslang_compileGLSLToSPIRV(request); break; + case GLSLANG_ACTION_COMPILE_GLSL_TO_SPIRV: + result = glslang_compileGLSLToSPIRV(request); + break; - case GLSLANG_ACTION_DISSASSEMBLE_SPIRV: result = glslang_dissassembleSPIRV(request); break; + case GLSLANG_ACTION_DISSASSEMBLE_SPIRV: + result = glslang_dissassembleSPIRV(request); + break; - case GLSLANG_ACTION_OPTIMIZE_SPIRV: result = spirv_Optimize_1_2(request); break; + case GLSLANG_ACTION_OPTIMIZE_SPIRV: + result = spirv_Optimize_1_2(request); + break; } return result; diff --git a/source/slang-llvm/slang-llvm.cpp b/source/slang-llvm/slang-llvm.cpp index e19bbc376..990f99f74 100644 --- a/source/slang-llvm/slang-llvm.cpp +++ b/source/slang-llvm/slang-llvm.cpp @@ -507,11 +507,15 @@ static int _getOptimizationLevel(DownstreamCompileOptions::OptimizationLevel lev typedef DownstreamCompileOptions::OptimizationLevel OptimizationLevel; switch (level) { - case OptimizationLevel::None: return 0; + case OptimizationLevel::None: + return 0; default: - case OptimizationLevel::Default: return 1; - case OptimizationLevel::High: return 2; - case OptimizationLevel::Maximal: return 3; + case OptimizationLevel::Default: + return 1; + case OptimizationLevel::High: + return 2; + case OptimizationLevel::Maximal: + return 3; } } diff --git a/source/slang-record-replay/replay/json-consumer.h b/source/slang-record-replay/replay/json-consumer.h index 8a367cc20..4eb03ba0a 100644 --- a/source/slang-record-replay/replay/json-consumer.h +++ b/source/slang-record-replay/replay/json-consumer.h @@ -16,13 +16,21 @@ public: { switch (classId) { - case ApiClassId::Class_IModule: m_className = "IModule"; break; - case ApiClassId::Class_IEntryPoint: m_className = "IEntryPoint"; break; + case ApiClassId::Class_IModule: + m_className = "IModule"; + break; + case ApiClassId::Class_IEntryPoint: + m_className = "IEntryPoint"; + break; case ApiClassId::Class_ICompositeComponentType: m_className = "ICompositeComponentType"; break; - case ApiClassId::Class_ITypeConformance: m_className = "ITypeConformance"; break; - default: slangRecordLog(LogLevel::Error, "Invalid classNo %u\n", classId); break; + case ApiClassId::Class_ITypeConformance: + m_className = "ITypeConformance"; + break; + default: + slangRecordLog(LogLevel::Error, "Invalid classNo %u\n", classId); + break; } } CommonInterfaceWriter() = delete; diff --git a/source/slang-record-replay/replay/slang-decoder.cpp b/source/slang-record-replay/replay/slang-decoder.cpp index a0ae842ea..7d9648a2a 100644 --- a/source/slang-record-replay/replay/slang-decoder.cpp +++ b/source/slang-record-replay/replay/slang-decoder.cpp @@ -46,7 +46,9 @@ bool SlangDecoder::processIGlobalSessionMethods( { switch (callId) { - default: slangRecordLog(LogLevel::Error, "Unhandled Slang API call: %d\n", callId); break; + default: + slangRecordLog(LogLevel::Error, "Unhandled Slang API call: %d\n", callId); + break; case ApiCallId::IGlobalSession_createSession: IGlobalSession_createSession(objectId, parameterBlock); break; @@ -143,7 +145,9 @@ bool SlangDecoder::processISessionMethods( case ApiCallId::ISession_getGlobalSession: ISession_getGlobalSession(objectId, parameterBlock); break; - case ApiCallId::ISession_loadModule: ISession_loadModule(objectId, parameterBlock); break; + case ApiCallId::ISession_loadModule: + ISession_loadModule(objectId, parameterBlock); + break; case ApiCallId::ISession_loadModuleFromIRBlob: ISession_loadModuleFromIRBlob(objectId, parameterBlock); break; @@ -159,7 +163,9 @@ bool SlangDecoder::processISessionMethods( case ApiCallId::ISession_specializeType: ISession_specializeType(objectId, parameterBlock); break; - case ApiCallId::ISession_getTypeLayout: ISession_getTypeLayout(objectId, parameterBlock); break; + case ApiCallId::ISession_getTypeLayout: + ISession_getTypeLayout(objectId, parameterBlock); + break; case ApiCallId::ISession_getContainerType: ISession_getContainerType(objectId, parameterBlock); break; @@ -213,33 +219,51 @@ bool SlangDecoder::processIModuleMethods( case ApiCallId::IModule_getDefinedEntryPoint: IModule_getDefinedEntryPoint(objectId, parameterBlock); break; - case ApiCallId::IModule_serialize: IModule_serialize(objectId, parameterBlock); break; - case ApiCallId::IModule_writeToFile: IModule_writeToFile(objectId, parameterBlock); break; - case ApiCallId::IModule_getName: IModule_getName(objectId, parameterBlock); break; - case ApiCallId::IModule_getFilePath: IModule_getFilePath(objectId, parameterBlock); break; + case ApiCallId::IModule_serialize: + IModule_serialize(objectId, parameterBlock); + break; + case ApiCallId::IModule_writeToFile: + IModule_writeToFile(objectId, parameterBlock); + break; + case ApiCallId::IModule_getName: + IModule_getName(objectId, parameterBlock); + break; + case ApiCallId::IModule_getFilePath: + IModule_getFilePath(objectId, parameterBlock); + break; case ApiCallId::IModule_getUniqueIdentity: IModule_getUniqueIdentity(objectId, parameterBlock); break; case ApiCallId::IModule_findAndCheckEntryPoint: IModule_findAndCheckEntryPoint(objectId, parameterBlock); break; - case ApiCallId::IModule_getSession: IModule_getSession(objectId, parameterBlock); break; - case ApiCallId::IModule_getLayout: IModule_getLayout(objectId, parameterBlock); break; + case ApiCallId::IModule_getSession: + IModule_getSession(objectId, parameterBlock); + break; + case ApiCallId::IModule_getLayout: + IModule_getLayout(objectId, parameterBlock); + break; case ApiCallId::IModule_getSpecializationParamCount: IModule_getSpecializationParamCount(objectId, parameterBlock); break; case ApiCallId::IModule_getEntryPointCode: IModule_getEntryPointCode(objectId, parameterBlock); break; - case ApiCallId::IModule_getTargetCode: IModule_getTargetCode(objectId, parameterBlock); break; + case ApiCallId::IModule_getTargetCode: + IModule_getTargetCode(objectId, parameterBlock); + break; case ApiCallId::IModule_getResultAsFileSystem: IModule_getResultAsFileSystem(objectId, parameterBlock); break; case ApiCallId::IModule_getEntryPointHash: IModule_getEntryPointHash(objectId, parameterBlock); break; - case ApiCallId::IModule_specialize: IModule_specialize(objectId, parameterBlock); break; - case ApiCallId::IModule_link: IModule_link(objectId, parameterBlock); break; + case ApiCallId::IModule_specialize: + IModule_specialize(objectId, parameterBlock); + break; + case ApiCallId::IModule_link: + IModule_link(objectId, parameterBlock); + break; case ApiCallId::IModule_getEntryPointHostCallable: IModule_getEntryPointHostCallable(objectId, parameterBlock); break; @@ -263,8 +287,12 @@ bool SlangDecoder::processIEntryPointMethods( default: slangRecordLog(LogLevel::Error, "Unhandled Slang API call: %d\n", callId); return false; - case ApiCallId::IEntryPoint_getSession: IEntryPoint_getSession(objectId, parameterBlock); break; - case ApiCallId::IEntryPoint_getLayout: IEntryPoint_getLayout(objectId, parameterBlock); break; + case ApiCallId::IEntryPoint_getSession: + IEntryPoint_getSession(objectId, parameterBlock); + break; + case ApiCallId::IEntryPoint_getLayout: + IEntryPoint_getLayout(objectId, parameterBlock); + break; case ApiCallId::IEntryPoint_getSpecializationParamCount: IEntryPoint_getSpecializationParamCount(objectId, parameterBlock); break; @@ -280,8 +308,12 @@ bool SlangDecoder::processIEntryPointMethods( case ApiCallId::IEntryPoint_getEntryPointHash: IEntryPoint_getEntryPointHash(objectId, parameterBlock); break; - case ApiCallId::IEntryPoint_specialize: IEntryPoint_specialize(objectId, parameterBlock); break; - case ApiCallId::IEntryPoint_link: IEntryPoint_link(objectId, parameterBlock); break; + case ApiCallId::IEntryPoint_specialize: + IEntryPoint_specialize(objectId, parameterBlock); + break; + case ApiCallId::IEntryPoint_link: + IEntryPoint_link(objectId, parameterBlock); + break; case ApiCallId::IEntryPoint_getEntryPointHostCallable: IEntryPoint_getEntryPointHostCallable(objectId, parameterBlock); break; @@ -302,7 +334,9 @@ bool SlangDecoder::processICompositeComponentTypeMethods( { switch (callId) { - default: slangRecordLog(LogLevel::Error, "Unhandled Slang API call: %d\n", callId); break; + default: + slangRecordLog(LogLevel::Error, "Unhandled Slang API call: %d\n", callId); + break; case ApiCallId::ICompositeComponentType_getSession: ICompositeComponentType_getSession(objectId, parameterBlock); break; @@ -377,7 +411,9 @@ bool SlangDecoder::processITypeConformanceMethods( case ApiCallId::ITypeConformance_specialize: ITypeConformance_specialize(objectId, parameterBlock); break; - case ApiCallId::ITypeConformance_link: ITypeConformance_link(objectId, parameterBlock); break; + case ApiCallId::ITypeConformance_link: + ITypeConformance_link(objectId, parameterBlock); + break; case ApiCallId::ITypeConformance_getEntryPointHostCallable: ITypeConformance_getEntryPointHostCallable(objectId, parameterBlock); break; @@ -400,7 +436,9 @@ bool SlangDecoder::processFunctionCall( default: slangRecordLog(LogLevel::Error, "Unhandled Slang API call: %d\n", header.callId); return false; - case ApiCallId::CreateGlobalSession: CreateGlobalSession(parameterBlock); break; + case ApiCallId::CreateGlobalSession: + CreateGlobalSession(parameterBlock); + break; } return true; } diff --git a/source/slang-record-replay/util/emum-to-string.h b/source/slang-record-replay/util/emum-to-string.h index 60e5e2416..b19782126 100644 --- a/source/slang-record-replay/util/emum-to-string.h +++ b/source/slang-record-replay/util/emum-to-string.h @@ -5,7 +5,8 @@ namespace SlangRecord static Slang::String SlangCompileTargetToString(const SlangCompileTarget target) { #define CASE(x) \ - case x: return #x + case x: \ + return #x switch (target) { @@ -49,7 +50,8 @@ static Slang::String SlangProfileIDToString(const SlangProfileID profile) { switch (profile) { - case SLANG_PROFILE_UNKNOWN: return "SLANG_PROFILE_UNKNOWN"; + case SLANG_PROFILE_UNKNOWN: + return "SLANG_PROFILE_UNKNOWN"; default: Slang::StringBuilder str; str << "Unknown SlangProfileID: " << static_cast<uint32_t>(profile); @@ -65,7 +67,8 @@ static Slang::String SlangTargetFlagsToString(const SlangTargetFlags flags) return "SLANG_TARGET_FLAG_PARAMETER_BLOCKS_USE_REGISTER_SPACES"; case SLANG_TARGET_FLAG_GENERATE_WHOLE_PROGRAM: return "SLANG_TARGET_FLAG_GENERATE_WHOLE_PROGRAM"; - case SLANG_TARGET_FLAG_DUMP_IR: return "SLANG_TARGET_FLAG_DUMP_IR"; + case SLANG_TARGET_FLAG_DUMP_IR: + return "SLANG_TARGET_FLAG_DUMP_IR"; case SLANG_TARGET_FLAG_GENERATE_SPIRV_DIRECTLY: return "SLANG_TARGET_FLAG_GENERATE_SPIRV_DIRECTLY"; default: @@ -79,9 +82,12 @@ static Slang::String SlangFloatingPointModeToString(const SlangFloatingPointMode { switch (mode) { - case SLANG_FLOATING_POINT_MODE_DEFAULT: return "SLANG_FLOATING_POINT_MODE_DEFAULT"; - case SLANG_FLOATING_POINT_MODE_FAST: return "SLANG_FLOATING_POINT_MODE_FAST"; - case SLANG_FLOATING_POINT_MODE_PRECISE: return "SLANG_FLOATING_POINT_MODE_PRECISE"; + case SLANG_FLOATING_POINT_MODE_DEFAULT: + return "SLANG_FLOATING_POINT_MODE_DEFAULT"; + case SLANG_FLOATING_POINT_MODE_FAST: + return "SLANG_FLOATING_POINT_MODE_FAST"; + case SLANG_FLOATING_POINT_MODE_PRECISE: + return "SLANG_FLOATING_POINT_MODE_PRECISE"; default: Slang::StringBuilder str; str << "Unknown SlangFloatingPointMode: " << static_cast<uint32_t>(mode); @@ -93,11 +99,16 @@ static Slang::String SlangLineDirectiveModeToString(const SlangLineDirectiveMode { switch (mode) { - case SLANG_LINE_DIRECTIVE_MODE_DEFAULT: return "SLANG_LINE_DIRECTIVE_MODE_DEFAULT"; - case SLANG_LINE_DIRECTIVE_MODE_NONE: return "SLANG_LINE_DIRECTIVE_MODE_NONE"; - case SLANG_LINE_DIRECTIVE_MODE_STANDARD: return "SLANG_LINE_DIRECTIVE_MODE_STANDARD"; - case SLANG_LINE_DIRECTIVE_MODE_GLSL: return "SLANG_LINE_DIRECTIVE_MODE_GLSL"; - case SLANG_LINE_DIRECTIVE_MODE_SOURCE_MAP: return "SLANG_LINE_DIRECTIVE_MODE_SOURCE_MAP"; + case SLANG_LINE_DIRECTIVE_MODE_DEFAULT: + return "SLANG_LINE_DIRECTIVE_MODE_DEFAULT"; + case SLANG_LINE_DIRECTIVE_MODE_NONE: + return "SLANG_LINE_DIRECTIVE_MODE_NONE"; + case SLANG_LINE_DIRECTIVE_MODE_STANDARD: + return "SLANG_LINE_DIRECTIVE_MODE_STANDARD"; + case SLANG_LINE_DIRECTIVE_MODE_GLSL: + return "SLANG_LINE_DIRECTIVE_MODE_GLSL"; + case SLANG_LINE_DIRECTIVE_MODE_SOURCE_MAP: + return "SLANG_LINE_DIRECTIVE_MODE_SOURCE_MAP"; default: Slang::StringBuilder str; str << "Unknown SlangLineDirectiveMode: " << static_cast<uint32_t>(mode); @@ -107,8 +118,9 @@ static Slang::String SlangLineDirectiveModeToString(const SlangLineDirectiveMode static Slang::String CompilerOptionNameToString(const slang::CompilerOptionName name) { -#define CASE(x) \ - case CompilerOptionName::x: return #x +#define CASE(x) \ + case CompilerOptionName::x: \ + return #x using namespace slang; switch (name) @@ -235,8 +247,10 @@ static Slang::String CompilerOptionValueKindToString(const slang::CompilerOption using namespace slang; switch (kind) { - case CompilerOptionValueKind::Int: return "Int"; - case CompilerOptionValueKind::String: return "String"; + case CompilerOptionValueKind::Int: + return "Int"; + case CompilerOptionValueKind::String: + return "String"; default: Slang::StringBuilder str; str << "Unknown CompilerOptionValueKind: " << static_cast<uint32_t>(kind); @@ -249,7 +263,8 @@ static Slang::String SessionFlagsToString(const slang::SessionFlags flags) using namespace slang; switch (flags) { - case kSessionFlags_None: return "kSessionFlags_None"; + case kSessionFlags_None: + return "kSessionFlags_None"; default: Slang::StringBuilder str; str << "Unknown SessionFlags: " << static_cast<uint32_t>(flags); @@ -261,9 +276,12 @@ static Slang::String SlangMatrixLayoutModeToString(const SlangMatrixLayoutMode m { switch (mode) { - case SLANG_MATRIX_LAYOUT_MODE_UNKNOWN: return "SLANG_MATRIX_LAYOUT_MODE_UNKNOWN"; - case SLANG_MATRIX_LAYOUT_ROW_MAJOR: return "SLANG_MATRIX_LAYOUT_ROW_MAJOR"; - case SLANG_MATRIX_LAYOUT_COLUMN_MAJOR: return "SLANG_MATRIX_LAYOUT_COLUMN_MAJOR"; + case SLANG_MATRIX_LAYOUT_MODE_UNKNOWN: + return "SLANG_MATRIX_LAYOUT_MODE_UNKNOWN"; + case SLANG_MATRIX_LAYOUT_ROW_MAJOR: + return "SLANG_MATRIX_LAYOUT_ROW_MAJOR"; + case SLANG_MATRIX_LAYOUT_COLUMN_MAJOR: + return "SLANG_MATRIX_LAYOUT_COLUMN_MAJOR"; default: Slang::StringBuilder str; str << "Unknown SlangMatrixLayoutMode: " << static_cast<uint32_t>(mode); @@ -274,7 +292,8 @@ static Slang::String SlangMatrixLayoutModeToString(const SlangMatrixLayoutMode m static Slang::String SlangPassThroughToString(const SlangPassThrough passThrough) { #define CASE(x) \ - case x: return #x + case x: \ + return #x switch (passThrough) { @@ -303,7 +322,8 @@ static Slang::String SlangPassThroughToString(const SlangPassThrough passThrough static Slang::String SlangSourceLanguageToString(const SlangSourceLanguage language) { #define CASE(x) \ - case x: return #x + case x: \ + return #x switch (language) { @@ -329,7 +349,8 @@ static Slang::String CompileCoreModuleFlagsToString(const slang::CompileCoreModu using namespace slang; switch (flags) { - case CompileCoreModuleFlag::WriteDocumentation: return "WriteDocumentation"; + case CompileCoreModuleFlag::WriteDocumentation: + return "WriteDocumentation"; default: Slang::StringBuilder str; str << "Unknown CompileCoreModuleFlags: " << static_cast<uint32_t>(flags); @@ -340,7 +361,8 @@ static Slang::String CompileCoreModuleFlagsToString(const slang::CompileCoreModu static Slang::String SlangArchiveTypeToString(const SlangArchiveType type) { #define CASE(x) \ - case x: return #x + case x: \ + return #x switch (type) { CASE(SLANG_ARCHIVE_TYPE_UNDEFINED); @@ -361,8 +383,10 @@ static Slang::String SpecializationArgKindToString(const slang::SpecializationAr using namespace slang; switch (kind) { - case SpecializationArg::Kind::Unknown: return "Unknown"; - case SpecializationArg::Kind::Type: return "Type"; + case SpecializationArg::Kind::Unknown: + return "Unknown"; + case SpecializationArg::Kind::Type: + return "Type"; default: Slang::StringBuilder str; str << "Unknown SpecializationArg::Kind: " << static_cast<uint32_t>(kind); @@ -375,8 +399,10 @@ static Slang::String LayoutRulesToString(const slang::LayoutRules rules) using namespace slang; switch (rules) { - case LayoutRules::Default: return "Default"; - case LayoutRules::MetalArgumentBufferTier2: return "MetalArgumentBufferTier2"; + case LayoutRules::Default: + return "Default"; + case LayoutRules::MetalArgumentBufferTier2: + return "MetalArgumentBufferTier2"; default: Slang::StringBuilder str; str << "Unknown LayoutRules: " << static_cast<uint32_t>(rules); @@ -387,7 +413,8 @@ static Slang::String LayoutRulesToString(const slang::LayoutRules rules) static Slang::String SlangStageToString(const SlangStage stage) { #define CASE(x) \ - case x: return #x + case x: \ + return #x switch (stage) { @@ -419,11 +446,16 @@ static Slang::String ContainerTypeToString(const slang::ContainerType type) using namespace slang; switch (type) { - case ContainerType::None: return "None"; - case ContainerType::UnsizedArray: return "UnsizedArray"; - case ContainerType::StructuredBuffer: return "StructuredBuffer"; - case ContainerType::ConstantBuffer: return "ConstantBuffer"; - case ContainerType::ParameterBlock: return "ParameterBlock"; + case ContainerType::None: + return "None"; + case ContainerType::UnsizedArray: + return "UnsizedArray"; + case ContainerType::StructuredBuffer: + return "StructuredBuffer"; + case ContainerType::ConstantBuffer: + return "ConstantBuffer"; + case ContainerType::ParameterBlock: + return "ParameterBlock"; default: Slang::StringBuilder str; str << "Unknown ContainerType: " << static_cast<uint32_t>(type); diff --git a/source/slang/slang-ast-builder.h b/source/slang/slang-ast-builder.h index cbd4f86c3..22f6bb91e 100644 --- a/source/slang/slang-ast-builder.h +++ b/source/slang/slang-ast-builder.h @@ -349,7 +349,8 @@ public: lookupDeclRef->getWitness(), memberDecl) .template as<T>(); - default: break; + default: + break; } } else if (auto directDeclRef = as<DirectDeclRef>(parent.declRefBase)) diff --git a/source/slang/slang-ast-dump.cpp b/source/slang/slang-ast-dump.cpp index dd80b1d4b..b77003bff 100644 --- a/source/slang/slang-ast-dump.cpp +++ b/source/slang/slang-ast-dump.cpp @@ -431,8 +431,12 @@ struct ASTDumpContext const char* name = nullptr; switch (kind) { - case FeedbackType::Kind::MinMip: name = "MinMip"; break; - case FeedbackType::Kind::MipRegionUsed: name = "MipRegionUsed"; break; + case FeedbackType::Kind::MinMip: + name = "MinMip"; + break; + case FeedbackType::Kind::MipRegionUsed: + name = "MipRegionUsed"; + break; } m_buf << "FeedbackType::Kind{" << name << "}"; @@ -444,9 +448,15 @@ struct ASTDumpContext { switch (flavor) { - case SamplerStateFlavor::SamplerState: m_writer->emit("sampler"); break; - case SamplerStateFlavor::SamplerComparisonState: m_writer->emit("samplerComparison"); break; - default: m_writer->emit("unknown"); break; + case SamplerStateFlavor::SamplerState: + m_writer->emit("sampler"); + break; + case SamplerStateFlavor::SamplerComparisonState: + m_writer->emit("samplerComparison"); + break; + default: + m_writer->emit("unknown"); + break; } } @@ -595,9 +605,15 @@ struct ASTDumpContext { switch (operand.kind) { - case ValNodeOperandKind::ConstantValue: dump(operand.values.intOperand); break; - case ValNodeOperandKind::ValNode: dump(operand.values.nodeOperand); break; - case ValNodeOperandKind::ASTNode: dump(operand.values.nodeOperand); break; + case ValNodeOperandKind::ConstantValue: + dump(operand.values.intOperand); + break; + case ValNodeOperandKind::ValNode: + dump(operand.values.nodeOperand); + break; + case ValNodeOperandKind::ASTNode: + dump(operand.values.nodeOperand); + break; } } @@ -622,14 +638,27 @@ struct ASTDumpContext { switch (operand.flavor) { - case SPIRVAsmOperand::Id: m_writer->emit("%"); break; - case SPIRVAsmOperand::ResultMarker: m_writer->emit("result"); break; + case SPIRVAsmOperand::Id: + m_writer->emit("%"); + break; + case SPIRVAsmOperand::ResultMarker: + m_writer->emit("result"); + break; case SPIRVAsmOperand::Literal: - case SPIRVAsmOperand::NamedValue: break; - case SPIRVAsmOperand::SlangValue: m_writer->emit("$"); break; - case SPIRVAsmOperand::SlangValueAddr: m_writer->emit("&"); break; - case SPIRVAsmOperand::SlangType: m_writer->emit("$$"); break; - case SPIRVAsmOperand::SlangImmediateValue: m_writer->emit("!"); break; + case SPIRVAsmOperand::NamedValue: + break; + case SPIRVAsmOperand::SlangValue: + m_writer->emit("$"); + break; + case SPIRVAsmOperand::SlangValueAddr: + m_writer->emit("&"); + break; + case SPIRVAsmOperand::SlangType: + m_writer->emit("$$"); + break; + case SPIRVAsmOperand::SlangImmediateValue: + m_writer->emit("!"); + break; case SPIRVAsmOperand::RayPayloadFromLocation: m_writer->emit("__rayPayloadFromLocation"); break; @@ -639,8 +668,11 @@ struct ASTDumpContext case SPIRVAsmOperand::RayCallableFromLocation: m_writer->emit("__rayCallableFromLocation"); break; - case SPIRVAsmOperand::BuiltinVar: m_writer->emit("builtin"); break; - default: SLANG_UNREACHABLE("Unhandled case in ast dump for SPIRVAsmOperand"); + case SPIRVAsmOperand::BuiltinVar: + m_writer->emit("builtin"); + break; + default: + SLANG_UNREACHABLE("Unhandled case in ast dump for SPIRVAsmOperand"); } if (operand.expr) dump(operand.expr); diff --git a/source/slang/slang-ast-print.cpp b/source/slang/slang-ast-print.cpp index 8900706fa..8547fcda9 100644 --- a/source/slang/slang-ast-print.cpp +++ b/source/slang/slang-ast-print.cpp @@ -14,14 +14,22 @@ ASTPrinter::Part::Kind ASTPrinter::Part::getKind(ASTPrinter::Part::Type type) switch (type) { - case Type::ParamType: return Kind::Type; - case Type::ParamName: return Kind::Name; - case Type::ReturnType: return Kind::Type; - case Type::DeclPath: return Kind::Name; - case Type::GenericParamType: return Kind::Type; - case Type::GenericParamValue: return Kind::Value; - case Type::GenericParamValueType: return Kind::Type; - default: break; + case Type::ParamType: + return Kind::Type; + case Type::ParamName: + return Kind::Name; + case Type::ReturnType: + return Kind::Type; + case Type::DeclPath: + return Kind::Name; + case Type::GenericParamType: + return Kind::Type; + case Type::GenericParamValue: + return Kind::Value; + case Type::GenericParamValueType: + return Kind::Type; + default: + break; } return Kind::None; } diff --git a/source/slang/slang-ast-reflect.cpp b/source/slang/slang-ast-reflect.cpp index c6c51cb73..3f4ba9534 100644 --- a/source/slang/slang-ast-reflect.cpp +++ b/source/slang/slang-ast-reflect.cpp @@ -71,7 +71,8 @@ SLANG_ALL_ASTNode_NodeBase(SLANG_REFLECT_CLASS_INFO, _) // We dispatch to non 'abstract' types #define SLANG_CASE_AST(NAME) \ - case ASTNodeType::NAME: return visitor->dispatch_##NAME(static_cast<NAME*>(this), extra); + case ASTNodeType::NAME: \ + return visitor->dispatch_##NAME(static_cast<NAME*>(this), extra); #define SLANG_CASE_ABSTRACT_AST(NAME) #define SLANG_CASE_DISPATCH(NAME, SUPER, ORIGIN, LAST, MARKER, TYPE, param) \ diff --git a/source/slang/slang-ast-reflect.h b/source/slang/slang-ast-reflect.h index 5bf412955..56e42c8bd 100644 --- a/source/slang/slang-ast-reflect.h +++ b/source/slang/slang-ast-reflect.h @@ -35,7 +35,8 @@ public: #define SLANG_AST_NODE_INVOKE(method, methodParams) _##method##Override methodParams #define SLANG_AST_NODE_CASE(NAME, SUPER, ORIGIN, LAST, MARKER, TYPE, param) \ - case ASTNodeType::NAME: return static_cast<NAME*>(this)->SLANG_AST_NODE_INVOKE param; + case ASTNodeType::NAME: \ + return static_cast<NAME*>(this)->SLANG_AST_NODE_INVOKE param; #define SLANG_AST_NODE_VIRTUAL_CALL(base, methodName, methodParams) \ switch (astNodeType) \ @@ -46,7 +47,8 @@ public: // Same but for a method that's const #define SLANG_AST_NODE_CONST_CASE(NAME, SUPER, ORIGIN, LAST, MARKER, TYPE, param) \ - case ASTNodeType::NAME: return static_cast<const NAME*>(this)->SLANG_AST_NODE_INVOKE param; + case ASTNodeType::NAME: \ + return static_cast<const NAME*>(this)->SLANG_AST_NODE_INVOKE param; #define SLANG_AST_NODE_CONST_VIRTUAL_CALL(base, methodName, methodParams) \ switch (astNodeType) \ { \ diff --git a/source/slang/slang-ast-type.cpp b/source/slang/slang-ast-type.cpp index 8c7561e8d..7e4777a76 100644 --- a/source/slang/slang-ast-type.cpp +++ b/source/slang/slang-ast-type.cpp @@ -436,12 +436,22 @@ void maybePrintAddrSpaceOperand(StringBuilder& out, AddressSpace addrSpace) switch (addrSpace) { case AddressSpace::Generic: - case AddressSpace::UserPointer: break; - case AddressSpace::GroupShared: out << toSlice(", groupshared"); break; - case AddressSpace::Global: out << toSlice(", global"); break; - case AddressSpace::ThreadLocal: out << toSlice(", threadlocal"); break; - case AddressSpace::Uniform: out << toSlice(", uniform"); break; - default: break; + case AddressSpace::UserPointer: + break; + case AddressSpace::GroupShared: + out << toSlice(", groupshared"); + break; + case AddressSpace::Global: + out << toSlice(", global"); + break; + case AddressSpace::ThreadLocal: + out << toSlice(", threadlocal"); + break; + case AddressSpace::Uniform: + out << toSlice(", uniform"); + break; + default: + break; } } @@ -1130,13 +1140,18 @@ SlangResourceAccess ResourceType::getAccess() { switch (constIntVal->getValue()) { - case kCoreModule_ResourceAccessReadOnly: return SLANG_RESOURCE_ACCESS_READ; - case kCoreModule_ResourceAccessReadWrite: return SLANG_RESOURCE_ACCESS_READ_WRITE; - case kCoreModule_ResourceAccessWriteOnly: return SLANG_RESOURCE_ACCESS_WRITE; + case kCoreModule_ResourceAccessReadOnly: + return SLANG_RESOURCE_ACCESS_READ; + case kCoreModule_ResourceAccessReadWrite: + return SLANG_RESOURCE_ACCESS_READ_WRITE; + case kCoreModule_ResourceAccessWriteOnly: + return SLANG_RESOURCE_ACCESS_WRITE; case kCoreModule_ResourceAccessRasterizerOrdered: return SLANG_RESOURCE_ACCESS_RASTER_ORDERED; - case kCoreModule_ResourceAccessFeedback: return SLANG_RESOURCE_ACCESS_FEEDBACK; - default: break; + case kCoreModule_ResourceAccessFeedback: + return SLANG_RESOURCE_ACCESS_FEEDBACK; + default: + break; } } return SLANG_RESOURCE_ACCESS_NONE; @@ -1166,14 +1181,20 @@ void ResourceType::_toTextOverride(StringBuilder& out) auto access = getAccess(); switch (access) { - case SLANG_RESOURCE_ACCESS_READ: break; + case SLANG_RESOURCE_ACCESS_READ: + break; case SLANG_RESOURCE_ACCESS_READ_WRITE: resultSB << "RW"; ; break; - case SLANG_RESOURCE_ACCESS_RASTER_ORDERED: resultSB << "RasterizerOrdered"; break; - case SLANG_RESOURCE_ACCESS_FEEDBACK: resultSB << "Feedback"; break; - default: return false; + case SLANG_RESOURCE_ACCESS_RASTER_ORDERED: + resultSB << "RasterizerOrdered"; + break; + case SLANG_RESOURCE_ACCESS_FEEDBACK: + resultSB << "Feedback"; + break; + default: + return false; } auto combined = as<ConstantIntVal>(_getGenericTypeArg(this, 7)); auto shapeVal = _getGenericTypeArg(this, 1); @@ -1193,10 +1214,18 @@ void ResourceType::_toTextOverride(StringBuilder& out) } switch (shape) { - case SLANG_TEXTURE_1D: resultSB << "1D"; break; - case SLANG_TEXTURE_2D: resultSB << "2D"; break; - case SLANG_TEXTURE_3D: resultSB << "3D"; break; - case SLANG_TEXTURE_CUBE: resultSB << "Cube"; break; + case SLANG_TEXTURE_1D: + resultSB << "1D"; + break; + case SLANG_TEXTURE_2D: + resultSB << "2D"; + break; + case SLANG_TEXTURE_3D: + resultSB << "3D"; + break; + case SLANG_TEXTURE_CUBE: + resultSB << "Cube"; + break; } auto isArrayVal = as<ConstantIntVal>(_getGenericTypeArg(this, 2)); if (!isArrayVal) diff --git a/source/slang/slang-ast-val.cpp b/source/slang/slang-ast-val.cpp index 2a2f275ee..fdb7e6990 100644 --- a/source/slang/slang-ast-val.cpp +++ b/source/slang/slang-ast-val.cpp @@ -598,7 +598,8 @@ breakLabel:; tryLookUpRequirementWitness(astBuilder, thisTypeWitness, requirementKey); switch (requirementWitness.getFlavor()) { - default: break; + default: + break; case RequirementWitness::Flavor::val: { @@ -1321,17 +1322,34 @@ Val* TypeCastIntVal::tryFoldImpl( { switch (baseType->getBaseType()) { - case BaseType::Int: resultValue = (int)resultValue; return true; - case BaseType::UInt: resultValue = (unsigned int)resultValue; return true; + case BaseType::Int: + resultValue = (int)resultValue; + return true; + case BaseType::UInt: + resultValue = (unsigned int)resultValue; + return true; case BaseType::Int64: - case BaseType::IntPtr: resultValue = (Int64)resultValue; return true; + case BaseType::IntPtr: + resultValue = (Int64)resultValue; + return true; case BaseType::UInt64: - case BaseType::UIntPtr: resultValue = (UInt64)resultValue; return true; - case BaseType::Int16: resultValue = (int16_t)resultValue; return true; - case BaseType::UInt16: resultValue = (uint16_t)resultValue; return true; - case BaseType::Int8: resultValue = (int8_t)resultValue; return true; - case BaseType::UInt8: resultValue = (uint8_t)resultValue; return true; - default: return false; + case BaseType::UIntPtr: + resultValue = (UInt64)resultValue; + return true; + case BaseType::Int16: + resultValue = (int16_t)resultValue; + return true; + case BaseType::UInt16: + resultValue = (uint16_t)resultValue; + return true; + case BaseType::Int8: + resultValue = (int8_t)resultValue; + return true; + case BaseType::UInt8: + resultValue = (uint8_t)resultValue; + return true; + default: + return false; } }; if (auto c = as<ConstantIntVal>(base)) @@ -1789,8 +1807,11 @@ Val* WitnessLookupIntVal::tryFoldOrNull(ASTBuilder* astBuilder, SubtypeWitness* auto witnessEntry = tryLookUpRequirementWitness(astBuilder, witness, key); switch (witnessEntry.getFlavor()) { - case RequirementWitness::Flavor::val: return witnessEntry.getVal(); break; - default: break; + case RequirementWitness::Flavor::val: + return witnessEntry.getVal(); + break; + default: + break; } return nullptr; } diff --git a/source/slang/slang-check-conversion.cpp b/source/slang/slang-check-conversion.cpp index 7e33158e6..0c06fb113 100644 --- a/source/slang/slang-check-conversion.cpp +++ b/source/slang/slang-check-conversion.cpp @@ -636,11 +636,13 @@ static bool _canModifierBeAddedDuringCoercion(Val* modifier) { switch (modifier->astNodeType) { - default: return false; + default: + return false; case ASTNodeType::UNormModifierVal: case ASTNodeType::SNormModifierVal: - case ASTNodeType::NoDiffModifierVal: return true; + case ASTNodeType::NoDiffModifierVal: + return true; } } @@ -653,11 +655,13 @@ static bool _canModifierBeDroppedDuringCoercion(Val* modifier) { switch (modifier->astNodeType) { - default: return false; + default: + return false; case ASTNodeType::UNormModifierVal: case ASTNodeType::SNormModifierVal: - case ASTNodeType::NoDiffModifierVal: return true; + case ASTNodeType::NoDiffModifierVal: + return true; } } @@ -672,8 +676,10 @@ static bool isSigned(Type* t) case BaseType::Int16: case BaseType::Int: case BaseType::Int64: - case BaseType::IntPtr: return true; - default: return false; + case BaseType::IntPtr: + return true; + default: + return false; } } @@ -686,13 +692,17 @@ int getTypeBitSize(Type* t) switch (basicType->getBaseType()) { case BaseType::Int8: - case BaseType::UInt8: return 8; + case BaseType::UInt8: + return 8; case BaseType::Int16: - case BaseType::UInt16: return 16; + case BaseType::UInt16: + return 16; case BaseType::Int: - case BaseType::UInt: return 32; + case BaseType::UInt: + return 32; case BaseType::Int64: - case BaseType::UInt64: return 64; + case BaseType::UInt64: + return 64; case BaseType::IntPtr: case BaseType::UIntPtr: #if SLANG_PTR_IS_32 @@ -700,7 +710,8 @@ int getTypeBitSize(Type* t) #else return 64; #endif - default: return 0; + default: + return 0; } } diff --git a/source/slang/slang-check-decl.cpp b/source/slang/slang-check-decl.cpp index 4293db5ee..663a2186e 100644 --- a/source/slang/slang-check-decl.cpp +++ b/source/slang/slang-check-decl.cpp @@ -648,8 +648,11 @@ struct SemanticsDeclReferenceVisitor : public SemanticsDeclVisitorBase, auto& operand = val->m_operands[i]; switch (operand.kind) { - case ValNodeOperandKind::ValNode: dispatchIfNotNull(val->getOperand(i)); break; - default: break; + case ValNodeOperandKind::ValNode: + dispatchIfNotNull(val->getOperand(i)); + break; + default: + break; } } return; @@ -1122,7 +1125,8 @@ bool SemanticsVisitor::isUsableAsStaticMember(LookupResultItem const& item) // TODO: Are there any other cases that need special-case // handling here? - default: break; + default: + break; } } @@ -1548,71 +1552,119 @@ ImageFormat inferImageFormatFromTextureType( case BaseType::UInt: switch (vectorWidth) { - case 1: format = ImageFormat::r32ui; break; - case 2: format = ImageFormat::rg32ui; break; - case 4: format = ImageFormat::rgba32ui; break; + case 1: + format = ImageFormat::r32ui; + break; + case 2: + format = ImageFormat::rg32ui; + break; + case 4: + format = ImageFormat::rgba32ui; + break; } break; case BaseType::Int: switch (vectorWidth) { - case 1: format = ImageFormat::r32i; break; - case 2: format = ImageFormat::rg32i; break; - case 4: format = ImageFormat::rgba32i; break; + case 1: + format = ImageFormat::r32i; + break; + case 2: + format = ImageFormat::rg32i; + break; + case 4: + format = ImageFormat::rgba32i; + break; } break; case BaseType::UInt16: switch (vectorWidth) { - case 1: format = ImageFormat::r16ui; break; - case 2: format = ImageFormat::rg16ui; break; - case 4: format = ImageFormat::rgba16ui; break; + case 1: + format = ImageFormat::r16ui; + break; + case 2: + format = ImageFormat::rg16ui; + break; + case 4: + format = ImageFormat::rgba16ui; + break; } break; case BaseType::Int16: switch (vectorWidth) { - case 1: format = ImageFormat::r16i; break; - case 2: format = ImageFormat::rg16i; break; - case 4: format = ImageFormat::rgba16i; break; + case 1: + format = ImageFormat::r16i; + break; + case 2: + format = ImageFormat::rg16i; + break; + case 4: + format = ImageFormat::rgba16i; + break; } break; case BaseType::UInt8: switch (vectorWidth) { - case 1: format = ImageFormat::r8ui; break; - case 2: format = ImageFormat::rg8ui; break; - case 4: format = ImageFormat::rgba8ui; break; + case 1: + format = ImageFormat::r8ui; + break; + case 2: + format = ImageFormat::rg8ui; + break; + case 4: + format = ImageFormat::rgba8ui; + break; } break; case BaseType::Int8: switch (vectorWidth) { - case 1: format = ImageFormat::r8i; break; - case 2: format = ImageFormat::rg8i; break; - case 4: format = ImageFormat::rgba8i; break; + case 1: + format = ImageFormat::r8i; + break; + case 2: + format = ImageFormat::rg8i; + break; + case 4: + format = ImageFormat::rgba8i; + break; } break; case BaseType::Int64: switch (vectorWidth) { - case 1: format = ImageFormat::r64i; break; - default: break; + case 1: + format = ImageFormat::r64i; + break; + default: + break; } break; case BaseType::UInt64: switch (vectorWidth) { - case 1: format = ImageFormat::r64ui; break; - default: break; + case 1: + format = ImageFormat::r64ui; + break; + default: + break; } break; case BaseType::Half: switch (vectorWidth) { - case 1: format = ImageFormat::r16f; break; - case 2: format = ImageFormat::rg16f; break; - case 4: format = ImageFormat::rgba16f; break; + case 1: + format = ImageFormat::r16f; + break; + case 2: + format = ImageFormat::rg16f; + break; + case 4: + format = ImageFormat::rgba16f; + break; } break; } @@ -1836,7 +1888,8 @@ void SemanticsDeclHeaderVisitor::checkVarDeclCommon(VarDeclBase* varDecl) case BaseType::UInt16: case BaseType::UInt: case BaseType::UInt64: - case BaseType::UIntPtr: break; + case BaseType::UIntPtr: + break; default: getSink()->diagnose(varDecl, Diagnostics::staticConstRequirementMustBeIntOrBool); break; @@ -2362,10 +2415,17 @@ void addVisibilityModifier(ASTBuilder* builder, Decl* decl, DeclVisibility vis) { switch (vis) { - case DeclVisibility::Public: addModifier(decl, builder->create<PublicModifier>()); break; - case DeclVisibility::Internal: addModifier(decl, builder->create<InternalModifier>()); break; - case DeclVisibility::Private: addModifier(decl, builder->create<PrivateModifier>()); break; - default: break; + case DeclVisibility::Public: + addModifier(decl, builder->create<PublicModifier>()); + break; + case DeclVisibility::Internal: + addModifier(decl, builder->create<InternalModifier>()); + break; + case DeclVisibility::Private: + addModifier(decl, builder->create<PrivateModifier>()); + break; + default: + break; } } @@ -5981,20 +6041,47 @@ bool SemanticsVisitor::trySynthesizeEnumTypeMethodRequirementWitness( auto intrinsicOpModifier = getASTBuilder()->create<IntrinsicOpModifier>(); switch (requirementKind) { - case BuiltinRequirementKind::And: intrinsicOpModifier->op = kIROp_And; break; - case BuiltinRequirementKind::Or: intrinsicOpModifier->op = kIROp_Or; break; - case BuiltinRequirementKind::Not: intrinsicOpModifier->op = kIROp_Not; break; - case BuiltinRequirementKind::BitAnd: intrinsicOpModifier->op = kIROp_BitAnd; break; - case BuiltinRequirementKind::BitNot: intrinsicOpModifier->op = kIROp_BitNot; break; - case BuiltinRequirementKind::BitOr: intrinsicOpModifier->op = kIROp_BitOr; break; - case BuiltinRequirementKind::BitXor: intrinsicOpModifier->op = kIROp_BitXor; break; - case BuiltinRequirementKind::Shl: intrinsicOpModifier->op = kIROp_Lsh; break; - case BuiltinRequirementKind::Shr: intrinsicOpModifier->op = kIROp_Rsh; break; - case BuiltinRequirementKind::Equals: intrinsicOpModifier->op = kIROp_Eql; break; - case BuiltinRequirementKind::LessThan: intrinsicOpModifier->op = kIROp_Less; break; - case BuiltinRequirementKind::LessThanOrEquals: intrinsicOpModifier->op = kIROp_Leq; break; - case BuiltinRequirementKind::InitLogicalFromInt: intrinsicOpModifier->op = kIROp_IntCast; break; - default: SLANG_UNEXPECTED("unknown builtin requirement kind."); + case BuiltinRequirementKind::And: + intrinsicOpModifier->op = kIROp_And; + break; + case BuiltinRequirementKind::Or: + intrinsicOpModifier->op = kIROp_Or; + break; + case BuiltinRequirementKind::Not: + intrinsicOpModifier->op = kIROp_Not; + break; + case BuiltinRequirementKind::BitAnd: + intrinsicOpModifier->op = kIROp_BitAnd; + break; + case BuiltinRequirementKind::BitNot: + intrinsicOpModifier->op = kIROp_BitNot; + break; + case BuiltinRequirementKind::BitOr: + intrinsicOpModifier->op = kIROp_BitOr; + break; + case BuiltinRequirementKind::BitXor: + intrinsicOpModifier->op = kIROp_BitXor; + break; + case BuiltinRequirementKind::Shl: + intrinsicOpModifier->op = kIROp_Lsh; + break; + case BuiltinRequirementKind::Shr: + intrinsicOpModifier->op = kIROp_Rsh; + break; + case BuiltinRequirementKind::Equals: + intrinsicOpModifier->op = kIROp_Eql; + break; + case BuiltinRequirementKind::LessThan: + intrinsicOpModifier->op = kIROp_Less; + break; + case BuiltinRequirementKind::LessThanOrEquals: + intrinsicOpModifier->op = kIROp_Leq; + break; + case BuiltinRequirementKind::InitLogicalFromInt: + intrinsicOpModifier->op = kIROp_IntCast; + break; + default: + SLANG_UNEXPECTED("unknown builtin requirement kind."); } synFunc->loc = context->parentDecl->closingSourceLoc; synFunc->nameAndLoc.loc = synFunc->loc; @@ -6157,7 +6244,9 @@ bool SemanticsVisitor::trySynthesizeDifferentialMethodRequirementWitness( } break; } - default: SLANG_UNIMPLEMENTED_X("unhandled synthesis pattern"); break; + default: + SLANG_UNIMPLEMENTED_X("unhandled synthesis pattern"); + break; } // Invoke the method for the field and assign the value to resultVar. @@ -7335,7 +7424,8 @@ bool SemanticsVisitor::isIntValueInRangeOfType(IntegerLiteralValue value, Type* #endif return value >= std::numeric_limits<int64_t>::min() && value <= std::numeric_limits<int64_t>::max(); - default: return false; + default: + return false; } } @@ -8949,7 +9039,8 @@ void SemanticsDeclHeaderVisitor::setFuncTypeIntoRequirementDecl( case ParameterDirection::kParameterDirection_ConstRef: addModifier(param, m_astBuilder->create<ConstRefModifier>()); break; - default: break; + default: + break; } decl->members.add(param); param->parentDecl = decl; @@ -10519,7 +10610,8 @@ FunctionDifferentiableLevel SharedSemanticsContext::_getFuncDifferentiableLevelI return _getFuncDifferentiableLevelImpl(assocFunc, recurseLimit - 1); } break; - default: break; + default: + break; } } if (auto builtinReq = func->findModifier<BuiltinRequirementModifier>()) @@ -10528,8 +10620,10 @@ FunctionDifferentiableLevel SharedSemanticsContext::_getFuncDifferentiableLevelI { case BuiltinRequirementKind::DAddFunc: case BuiltinRequirementKind::DMulFunc: - case BuiltinRequirementKind::DZeroFunc: return FunctionDifferentiableLevel::Backward; - default: break; + case BuiltinRequirementKind::DZeroFunc: + return FunctionDifferentiableLevel::Backward; + default: + break; } } return diffLevel; @@ -10608,15 +10702,21 @@ static void _dispatchDeclCheckingVisitor(Decl* decl, DeclCheckState state, Seman case DeclCheckState::ModifiersChecked: SemanticsDeclModifiersVisitor(shared).dispatch(decl); break; - case DeclCheckState::ScopesWired: SemanticsDeclScopeWiringVisitor(shared).dispatch(decl); break; + case DeclCheckState::ScopesWired: + SemanticsDeclScopeWiringVisitor(shared).dispatch(decl); + break; - case DeclCheckState::SignatureChecked: SemanticsDeclHeaderVisitor(shared).dispatch(decl); break; + case DeclCheckState::SignatureChecked: + SemanticsDeclHeaderVisitor(shared).dispatch(decl); + break; case DeclCheckState::ReadyForReference: SemanticsDeclRedeclarationVisitor(shared).dispatch(decl); break; - case DeclCheckState::ReadyForLookup: SemanticsDeclBasesVisitor(shared).dispatch(decl); break; + case DeclCheckState::ReadyForLookup: + SemanticsDeclBasesVisitor(shared).dispatch(decl); + break; case DeclCheckState::ReadyForConformances: SemanticsDeclConformancesVisitor(shared).dispatch(decl); @@ -10631,7 +10731,9 @@ static void _dispatchDeclCheckingVisitor(Decl* decl, DeclCheckState state, Seman SemanticsDeclAttributesVisitor(shared).dispatch(decl); break; - case DeclCheckState::DefinitionChecked: SemanticsDeclBodyVisitor(shared).dispatch(decl); break; + case DeclCheckState::DefinitionChecked: + SemanticsDeclBodyVisitor(shared).dispatch(decl); + break; case DeclCheckState::CapabilityChecked: if (!shared.getOptionSet().getBoolOption(CompilerOptionName::IgnoreCapabilities)) diff --git a/source/slang/slang-check-expr.cpp b/source/slang/slang-check-expr.cpp index 47eb6be45..44e399e79 100644 --- a/source/slang/slang-check-expr.cpp +++ b/source/slang/slang-check-expr.cpp @@ -548,14 +548,16 @@ Expr* SemanticsVisitor::maybeUseSynthesizedDeclForLookupResult( // decl in the interface. switch (item.declRef.getDecl()->astNodeType) { - case ASTNodeType::AssocTypeDecl: break; + case ASTNodeType::AssocTypeDecl: + break; case ASTNodeType::FuncDecl: // We don't need to intercept lookup results with synthesized decls for methods, // because function lookups will only take place when we are checking the decl bodies. // At that point conformance check and synthesis is already done so they will always // resolve to the synthesized method. return nullptr; - default: return nullptr; + default: + return nullptr; } // We need to check if the lookup should resolve to a definition in an implementation type @@ -595,7 +597,8 @@ Expr* SemanticsVisitor::maybeUseSynthesizedDeclForLookupResult( } } break; - default: break; + default: + break; } } if (!subType) @@ -688,7 +691,8 @@ Expr* SemanticsVisitor::maybeUseSynthesizedDeclForLookupResult( } } break; - default: return nullptr; + default: + return nullptr; } auto synthDeclMemberRef = @@ -731,7 +735,9 @@ Expr* SemanticsVisitor::ConstructLookupResultExpr( bb = ConstructDeclRefExpr(breadcrumb->declRef, bb, name, loc, originalExpr); break; - case LookupResultItem::Breadcrumb::Kind::Deref: bb = ConstructDerefExpr(bb, loc); break; + case LookupResultItem::Breadcrumb::Kind::Deref: + bb = ConstructDerefExpr(bb, loc); + break; case LookupResultItem::Breadcrumb::Kind::SuperType: { @@ -846,7 +852,8 @@ Expr* SemanticsVisitor::ConstructLookupResultExpr( } break; - default: SLANG_UNREACHABLE("all cases handle"); + default: + SLANG_UNREACHABLE("all cases handle"); } if (getShared()->isInLanguageServer()) { @@ -2215,7 +2222,8 @@ IntVal* SemanticsVisitor::CheckIntegerConstantExpression( else expr = coerce(CoercionSite::General, m_astBuilder->getIntType(), inExpr); break; - default: break; + default: + break; } // No need to issue further errors if the type coercion failed. @@ -4415,13 +4423,21 @@ Expr* SemanticsVisitor::CheckSwizzleExpr( switch (ch) { case 'x': - case 'r': elementIndex = 0; break; + case 'r': + elementIndex = 0; + break; case 'y': - case 'g': elementIndex = 1; break; + case 'g': + elementIndex = 1; + break; case 'z': - case 'b': elementIndex = 2; break; + case 'b': + elementIndex = 2; + break; case 'w': - case 'a': elementIndex = 3; break; + case 'a': + elementIndex = 3; + break; default: // An invalid character in the swizzle is an error anyError = true; diff --git a/source/slang/slang-check-modifier.cpp b/source/slang/slang-check-modifier.cpp index 36a73b2e9..0794279a7 100644 --- a/source/slang/slang-check-modifier.cpp +++ b/source/slang/slang-check-modifier.cpp @@ -1224,7 +1224,8 @@ ASTNodeType getModifierConflictGroupKind(ASTNodeType modifierType) switch (modifierType) { // Allowed only on parameters and global variables. - case ASTNodeType::InModifier: return modifierType; + case ASTNodeType::InModifier: + return modifierType; case ASTNodeType::OutModifier: case ASTNodeType::RefModifier: case ASTNodeType::ConstRefModifier: @@ -1270,28 +1271,34 @@ ASTNodeType getModifierConflictGroupKind(ASTNodeType modifierType) case ASTNodeType::HLSLEffectSharedModifier: case ASTNodeType::HLSLVolatileModifier: case ASTNodeType::GLSLPrecisionModifier: - case ASTNodeType::HLSLGroupSharedModifier: return modifierType; + case ASTNodeType::HLSLGroupSharedModifier: + return modifierType; case ASTNodeType::HLSLStaticModifier: case ASTNodeType::ActualGlobalModifier: - case ASTNodeType::HLSLUniformModifier: return ASTNodeType::HLSLStaticModifier; + case ASTNodeType::HLSLUniformModifier: + return ASTNodeType::HLSLStaticModifier; case ASTNodeType::HLSLNoInterpolationModifier: case ASTNodeType::HLSLNoPerspectiveModifier: case ASTNodeType::HLSLLinearModifier: case ASTNodeType::HLSLSampleModifier: case ASTNodeType::HLSLCentroidModifier: - case ASTNodeType::PerVertexModifier: return ASTNodeType::InterpolationModeModifier; + case ASTNodeType::PerVertexModifier: + return ASTNodeType::InterpolationModeModifier; case ASTNodeType::PrefixModifier: - case ASTNodeType::PostfixModifier: return ASTNodeType::PrefixModifier; + case ASTNodeType::PostfixModifier: + return ASTNodeType::PrefixModifier; case ASTNodeType::BuiltinModifier: case ASTNodeType::PublicModifier: case ASTNodeType::PrivateModifier: - case ASTNodeType::InternalModifier: return ASTNodeType::VisibilityModifier; + case ASTNodeType::InternalModifier: + return ASTNodeType::VisibilityModifier; - default: return ASTNodeType::NodeBase; + default: + return ASTNodeType::NodeBase; } } @@ -1381,7 +1388,8 @@ bool isModifierAllowedOnDecl(bool isGLSLInput, ASTNodeType modifierType, Decl* d case ASTNodeType::SpecializedForTargetModifier: case ASTNodeType::InlineModifier: case ASTNodeType::PrefixModifier: - case ASTNodeType::PostfixModifier: return as<CallableDecl>(decl); + case ASTNodeType::PostfixModifier: + return as<CallableDecl>(decl); case ASTNodeType::BuiltinModifier: case ASTNodeType::PublicModifier: @@ -1394,12 +1402,14 @@ bool isModifierAllowedOnDecl(bool isGLSLInput, ASTNodeType modifierType, Decl* d as<CallableDecl>(decl) || as<TypeDefDecl>(decl) || as<PropertyDecl>(decl) || as<SyntaxDecl>(decl) || as<AttributeDecl>(decl) || as<InheritanceDecl>(decl); - case ASTNodeType::ExportedModifier: return as<ImportDecl>(decl); + case ASTNodeType::ExportedModifier: + return as<ImportDecl>(decl); case ASTNodeType::ConstModifier: case ASTNodeType::HLSLStaticModifier: case ASTNodeType::ConstExprModifier: - case ASTNodeType::PreciseModifier: return as<VarDeclBase>(decl) || as<CallableDecl>(decl); + case ASTNodeType::PreciseModifier: + return as<VarDeclBase>(decl) || as<CallableDecl>(decl); case ASTNodeType::ActualGlobalModifier: case ASTNodeType::MatrixLayoutModifier: @@ -1419,7 +1429,8 @@ bool isModifierAllowedOnDecl(bool isGLSLInput, ASTNodeType modifierType, Decl* d if (!as<VarDeclBase>(decl)) return false; return isGlobalDecl(decl) || isEffectivelyStatic(decl); - default: return true; + default: + return true; } } @@ -1568,10 +1579,18 @@ Modifier* SemanticsVisitor::checkModifier( { switch (packOffsetModifier->componentMask.getContent()[0]) { - case 'x': uniformOffset += 0; break; - case 'y': uniformOffset += 4; break; - case 'z': uniformOffset += 8; break; - case 'w': uniformOffset += 12; break; + case 'x': + uniformOffset += 0; + break; + case 'y': + uniformOffset += 4; + break; + case 'z': + uniformOffset += 8; + break; + case 'w': + uniformOffset += 12; + break; default: getSink()->diagnose( packOffsetModifier, diff --git a/source/slang/slang-check-overload.cpp b/source/slang/slang-check-overload.cpp index 609fa8635..fcc6780b6 100644 --- a/source/slang/slang-check-overload.cpp +++ b/source/slang/slang-check-overload.cpp @@ -150,7 +150,9 @@ bool SemanticsVisitor::TryCheckOverloadCandidateArity( } break; - default: SLANG_UNEXPECTED("unknown flavor of overload candidate"); break; + default: + SLANG_UNEXPECTED("unknown flavor of overload candidate"); + break; } if (argCount >= paramCounts.required && @@ -598,7 +600,9 @@ static QualType getParamQualType(ASTBuilder* astBuilder, DeclRef<ParamDecl> para { case kParameterDirection_InOut: case kParameterDirection_Out: - case kParameterDirection_Ref: isLVal = true; break; + case kParameterDirection_Ref: + isLVal = true; + break; } return QualType(paramType, isLVal); } @@ -645,7 +649,9 @@ bool SemanticsVisitor::TryCheckOverloadCandidateTypes( { return TryCheckGenericOverloadCandidateTypes(context, candidate); } - default: SLANG_UNEXPECTED("unknown flavor of overload candidate"); break; + default: + SLANG_UNEXPECTED("unknown flavor of overload candidate"); + break; } Index paramIndex = 0; @@ -1087,7 +1093,9 @@ Expr* SemanticsVisitor::CompleteOverloadCandidate( context.originalExpr); break; case OverloadCandidate::Flavor::Expr: - default: baseExpr = nullptr; break; + default: + baseExpr = nullptr; + break; } switch (candidate.flavor) @@ -2715,8 +2723,10 @@ Expr* SemanticsVisitor::ResolveInvoke(InvokeExpr* expr) case kParameterDirection_Out: case kParameterDirection_InOut: case kParameterDirection_Ref: - case kParameterDirection_ConstRef: break; - default: continue; + case kParameterDirection_ConstRef: + break; + default: + continue; } } if (auto extractExistentialExpr = as<ExtractExistentialValueExpr>(arg)) diff --git a/source/slang/slang-check-shader.cpp b/source/slang/slang-check-shader.cpp index 38c7fa5c1..80c950c17 100644 --- a/source/slang/slang-check-shader.cpp +++ b/source/slang/slang-check-shader.cpp @@ -470,8 +470,11 @@ void validateEntryPoint(EntryPoint* entryPoint, DiagnosticSink* sink) case Stage::Geometry: case Stage::Mesh: case Stage::Hull: - case Stage::Domain: canHaveVaryingInput = true; break; - default: break; + case Stage::Domain: + canHaveVaryingInput = true; + break; + default: + break; } for (const auto& param : entryPointFuncDecl->getParameters()) @@ -1241,7 +1244,8 @@ RefPtr<ComponentType::SpecializationInfo> Module::_validateSpecializationArgsImp } break; - default: SLANG_UNEXPECTED("unhandled specialization parameter flavor"); + default: + SLANG_UNEXPECTED("unhandled specialization parameter flavor"); } } diff --git a/source/slang/slang-check-stmt.cpp b/source/slang/slang-check-stmt.cpp index d02140d70..550993957 100644 --- a/source/slang/slang-check-stmt.cpp +++ b/source/slang/slang-check-stmt.cpp @@ -586,8 +586,10 @@ void SemanticsStmtVisitor::tryInferLoopMaxIterations(ForStmt* stmt) case kIROp_Less: case kIROp_Leq: case kIROp_Greater: - case kIROp_Geq: break; - default: return; + case kIROp_Geq: + break; + default: + return; } ConstantIntVal* stepSize = nullptr; diff --git a/source/slang/slang-compiler-options.cpp b/source/slang/slang-compiler-options.cpp index 4350bcf0d..84a22535a 100644 --- a/source/slang/slang-compiler-options.cpp +++ b/source/slang/slang-compiler-options.cpp @@ -82,11 +82,20 @@ void CompilerOptionSet::writeCommandLineArgs(Session* globalSession, StringBuild v.unpackInt3(kind, set, shift); switch ((HLSLToVulkanLayoutOptions::Kind)(kind)) { - case HLSLToVulkanLayoutOptions::Kind::UnorderedAccess: sb << " -fvk-u-shift"; break; - case HLSLToVulkanLayoutOptions::Kind::Sampler: sb << " -fvk-s-shift"; break; - case HLSLToVulkanLayoutOptions::Kind::ShaderResource: sb << " -fvk-t-shift"; break; - case HLSLToVulkanLayoutOptions::Kind::ConstantBuffer: sb << " -fvk-b-shift"; break; - default: continue; + case HLSLToVulkanLayoutOptions::Kind::UnorderedAccess: + sb << " -fvk-u-shift"; + break; + case HLSLToVulkanLayoutOptions::Kind::Sampler: + sb << " -fvk-s-shift"; + break; + case HLSLToVulkanLayoutOptions::Kind::ShaderResource: + sb << " -fvk-t-shift"; + break; + case HLSLToVulkanLayoutOptions::Kind::ConstantBuffer: + sb << " -fvk-b-shift"; + break; + default: + continue; } sb << " " << shift << " " << set; } @@ -176,7 +185,8 @@ bool CompilerOptionSet::allowDuplicate(CompilerOptionName name) case CompilerOptionName::Capability: case CompilerOptionName::DownstreamArgs: case CompilerOptionName::VulkanBindShift: - case CompilerOptionName::VulkanBindShiftAll: return true; + case CompilerOptionName::VulkanBindShiftAll: + return true; } return false; } @@ -186,7 +196,8 @@ CompilerOptionValue Slang::CompilerOptionSet::getDefault(CompilerOptionName name { case CompilerOptionName::Optimization: return CompilerOptionValue::fromEnum(OptimizationLevel::Default); - default: return CompilerOptionValue(); + default: + return CompilerOptionValue(); } } diff --git a/source/slang/slang-compiler-tu.cpp b/source/slang/slang-compiler-tu.cpp index 4a74ca64c..c20fc9a80 100644 --- a/source/slang/slang-compiler-tu.cpp +++ b/source/slang/slang-compiler-tu.cpp @@ -127,8 +127,10 @@ Module::precompileForTarget(SlangCompileTarget target, slang::IBlob** outDiagnos case CodeGenTarget::DXIL: tp.getOptionSet().add(CompilerOptionName::Profile, Profile::RawEnum::DX_Lib_6_6); break; - case CodeGenTarget::SPIRV: break; - default: return SLANG_FAIL; + case CodeGenTarget::SPIRV: + break; + default: + return SLANG_FAIL; } tp.getOptionSet().add(CompilerOptionName::EmbedDownstreamIR, true); diff --git a/source/slang/slang-compiler.cpp b/source/slang/slang-compiler.cpp index 63952db3d..4126b79eb 100644 --- a/source/slang/slang-compiler.cpp +++ b/source/slang/slang-compiler.cpp @@ -356,17 +356,23 @@ CapabilitySet Profile::getCapabilityName() List<CapabilityName> result; switch (getVersion()) { -#define PROFILE_VERSION(TAG, NAME) \ - case ProfileVersion::TAG: result.add(CapabilityName::TAG); break; +#define PROFILE_VERSION(TAG, NAME) \ + case ProfileVersion::TAG: \ + result.add(CapabilityName::TAG); \ + break; #include "slang-profile-defs.h" - default: break; + default: + break; } switch (getStage()) { -#define PROFILE_STAGE(TAG, NAME, VAL) \ - case Stage::TAG: result.add(CapabilityName::NAME); break; +#define PROFILE_STAGE(TAG, NAME, VAL) \ + case Stage::TAG: \ + result.add(CapabilityName::NAME); \ + break; #include "slang-profile-defs.h" - default: break; + default: + break; } CapabilitySet resultSet = CapabilitySet(result); @@ -379,10 +385,12 @@ char const* Profile::getName() { switch (raw) { - default: return "unknown"; + default: + return "unknown"; #define PROFILE(TAG, NAME, STAGE, VERSION) \ - case Profile::TAG: return #NAME; + case Profile::TAG: \ + return #NAME; #define PROFILE_ALIAS(TAG, DEF, NAME) /* empty */ #include "slang-profile-defs.h" } @@ -430,21 +438,37 @@ Stage getStageFromAtom(CapabilityAtom atom) { switch (atom) { - case CapabilityAtom::vertex: return Stage::Vertex; - case CapabilityAtom::hull: return Stage::Hull; - case CapabilityAtom::domain: return Stage::Domain; - case CapabilityAtom::geometry: return Stage::Geometry; - case CapabilityAtom::fragment: return Stage::Fragment; - case CapabilityAtom::compute: return Stage::Compute; - case CapabilityAtom::_mesh: return Stage::Mesh; - case CapabilityAtom::_amplification: return Stage::Amplification; - case CapabilityAtom::_anyhit: return Stage::AnyHit; - case CapabilityAtom::_closesthit: return Stage::ClosestHit; - case CapabilityAtom::_intersection: return Stage::Intersection; - case CapabilityAtom::_raygen: return Stage::RayGeneration; - case CapabilityAtom::_miss: return Stage::Miss; - case CapabilityAtom::_callable: return Stage::Callable; - default: SLANG_UNEXPECTED("unknown stage atom"); UNREACHABLE_RETURN(Stage::Unknown); + case CapabilityAtom::vertex: + return Stage::Vertex; + case CapabilityAtom::hull: + return Stage::Hull; + case CapabilityAtom::domain: + return Stage::Domain; + case CapabilityAtom::geometry: + return Stage::Geometry; + case CapabilityAtom::fragment: + return Stage::Fragment; + case CapabilityAtom::compute: + return Stage::Compute; + case CapabilityAtom::_mesh: + return Stage::Mesh; + case CapabilityAtom::_amplification: + return Stage::Amplification; + case CapabilityAtom::_anyhit: + return Stage::AnyHit; + case CapabilityAtom::_closesthit: + return Stage::ClosestHit; + case CapabilityAtom::_intersection: + return Stage::Intersection; + case CapabilityAtom::_raygen: + return Stage::RayGeneration; + case CapabilityAtom::_miss: + return Stage::Miss; + case CapabilityAtom::_callable: + return Stage::Callable; + default: + SLANG_UNEXPECTED("unknown stage atom"); + UNREACHABLE_RETURN(Stage::Unknown); } } @@ -504,7 +528,8 @@ SourceLanguage getDefaultSourceLanguageForDownstreamCompiler(PassThroughMode com { return SourceLanguage::Metal; } - default: break; + default: + break; } SLANG_ASSERT(!"Unknown compiler"); return SourceLanguage::Unknown; @@ -569,7 +594,8 @@ PassThroughMode getDownstreamCompilerRequiredForTarget(CodeGenTarget target) { return PassThroughMode::Tint; } - default: break; + default: + break; } SLANG_ASSERT(!"Unhandled target"); @@ -640,7 +666,8 @@ void trackGLSLTargetCaps(GLSLExtensionTracker* extensionTracker, CapabilitySet c { switch (asAtom(atom)) { - default: break; + default: + break; case CapabilityAtom::glsl_spirv_1_0: extensionTracker->requireSPIRVVersion(SemanticVersion(1, 0)); @@ -810,8 +837,10 @@ String GetHLSLProfileName(Profile profile) // both the stage and shader model, which need to be // used when compiling a single entry point. // -#define CASE(NAME, PREFIX) \ - case Stage::NAME: stagePrefix = #PREFIX; break +#define CASE(NAME, PREFIX) \ + case Stage::NAME: \ + stagePrefix = #PREFIX; \ + break CASE(Vertex, vs); CASE(Hull, hs); CASE(Domain, ds); @@ -826,8 +855,10 @@ String GetHLSLProfileName(Profile profile) char const* versionSuffix = nullptr; switch (profile.getVersion()) { -#define CASE(TAG, SUFFIX) \ - case ProfileVersion::TAG: versionSuffix = #SUFFIX; break +#define CASE(TAG, SUFFIX) \ + case ProfileVersion::TAG: \ + versionSuffix = #SUFFIX; \ + break CASE(DX_4_0, _4_0); CASE(DX_4_1, _4_1); CASE(DX_5_0, _5_0); @@ -842,7 +873,8 @@ String GetHLSLProfileName(Profile profile) CASE(DX_6_7, _6_7); #undef CASE - default: return "unknown"; + default: + return "unknown"; } String result; @@ -934,8 +966,10 @@ String CodeGenContext::calcSourcePathForEntryPoints() switch (numSourceFiles) { - case 0: return "unknown"; - case 1: return _getDisplayPath(sink, sourceFiles[0]); + case 0: + return "unknown"; + case 1: + return _getDisplayPath(sink, sourceFiles[0]); default: { StringBuilder builder; @@ -982,9 +1016,12 @@ static Severity _getDiagnosticSeverity(ArtifactDiagnostic::Severity severity) { switch (severity) { - case ArtifactDiagnostic::Severity::Warning: return Severity::Warning; - case ArtifactDiagnostic::Severity::Info: return Severity::Note; - default: return Severity::Error; + case ArtifactDiagnostic::Severity::Warning: + return Severity::Warning; + case ArtifactDiagnostic::Severity::Info: + return Severity::Note; + default: + return Severity::Error; } } @@ -1002,7 +1039,8 @@ static RefPtr<ExtensionTracker> _newExtensionTracker(CodeGenTarget target) { return new GLSLExtensionTracker; } - default: return nullptr; + default: + return nullptr; } } @@ -1021,13 +1059,20 @@ static CodeGenTarget _getDefaultSourceForTarget(CodeGenTarget target) { return CodeGenTarget::HostCPPSource; } - case CodeGenTarget::PTX: return CodeGenTarget::CUDASource; - case CodeGenTarget::DXBytecode: return CodeGenTarget::HLSL; - case CodeGenTarget::DXIL: return CodeGenTarget::HLSL; - case CodeGenTarget::SPIRV: return CodeGenTarget::GLSL; - case CodeGenTarget::MetalLib: return CodeGenTarget::Metal; - case CodeGenTarget::WGSLSPIRV: return CodeGenTarget::WGSL; - default: break; + case CodeGenTarget::PTX: + return CodeGenTarget::CUDASource; + case CodeGenTarget::DXBytecode: + return CodeGenTarget::HLSL; + case CodeGenTarget::DXIL: + return CodeGenTarget::HLSL; + case CodeGenTarget::SPIRV: + return CodeGenTarget::GLSL; + case CodeGenTarget::MetalLib: + return CodeGenTarget::Metal; + case CodeGenTarget::WGSLSPIRV: + return CodeGenTarget::WGSL; + default: + break; } return CodeGenTarget::Unknown; } @@ -1528,7 +1573,9 @@ SlangResult CodeGenContext::emitWithDownstreamForEntryPoints(ComPtr<IArtifact>& case OptimizationLevel::Maximal: options.optimizationLevel = DownstreamCompileOptions::OptimizationLevel::Maximal; break; - default: SLANG_ASSERT(!"Unhandled optimization level"); break; + default: + SLANG_ASSERT(!"Unhandled optimization level"); + break; } switch (getTargetProgram()->getOptionSet().getEnumOption<DebugInfoLevel>( @@ -1547,7 +1594,9 @@ SlangResult CodeGenContext::emitWithDownstreamForEntryPoints(ComPtr<IArtifact>& case DebugInfoLevel::Maximal: options.debugInfoType = DownstreamCompileOptions::DebugInfoType::Maximal; break; - default: SLANG_ASSERT(!"Unhandled debug level"); break; + default: + SLANG_ASSERT(!"Unhandled debug level"); + break; } switch (getTargetProgram()->getOptionSet().getEnumOption<FloatingPointMode>( @@ -1562,7 +1611,8 @@ SlangResult CodeGenContext::emitWithDownstreamForEntryPoints(ComPtr<IArtifact>& case FloatingPointMode::Fast: options.floatingPointMode = DownstreamCompileOptions::FloatingPointMode::Fast; break; - default: SLANG_ASSERT(!"Unhandled floating point mode"); + default: + SLANG_ASSERT(!"Unhandled floating point mode"); } { @@ -1587,7 +1637,8 @@ SlangResult CodeGenContext::emitWithDownstreamForEntryPoints(ComPtr<IArtifact>& auto stage = getEntryPoint(ee)->getStage(); switch (stage) { - default: break; + default: + break; case Stage::Compute: options.pipelineType = DownstreamCompileOptions::PipelineType::Compute; @@ -1707,11 +1758,16 @@ static CodeGenTarget _getIntermediateTarget(CodeGenTarget target) { switch (target) { - case CodeGenTarget::DXBytecodeAssembly: return CodeGenTarget::DXBytecode; - case CodeGenTarget::DXILAssembly: return CodeGenTarget::DXIL; - case CodeGenTarget::SPIRVAssembly: return CodeGenTarget::SPIRV; - case CodeGenTarget::WGSLSPIRVAssembly: return CodeGenTarget::WGSLSPIRV; - default: return CodeGenTarget::None; + case CodeGenTarget::DXBytecodeAssembly: + return CodeGenTarget::DXBytecode; + case CodeGenTarget::DXILAssembly: + return CodeGenTarget::DXIL; + case CodeGenTarget::SPIRVAssembly: + return CodeGenTarget::SPIRV; + case CodeGenTarget::WGSLSPIRVAssembly: + return CodeGenTarget::WGSLSPIRV; + default: + return CodeGenTarget::None; } } @@ -1768,7 +1824,8 @@ SlangResult CodeGenContext::_emitEntryPoints(ComPtr<IArtifact>& outArtifact) SLANG_RETURN_ON_FAIL(emitWithDownstreamForEntryPoints(outArtifact)); return SLANG_OK; - default: break; + default: + break; } return SLANG_FAIL; @@ -1834,9 +1891,12 @@ SlangResult CodeGenContext::emitEntryPoints(ComPtr<IArtifact>& outArtifact) return SLANG_OK; // Note(tfoley): We currently hit this case when compiling the core module - case CodeGenTarget::Unknown: return SLANG_OK; + case CodeGenTarget::Unknown: + return SLANG_OK; - default: SLANG_UNEXPECTED("unhandled code generation target"); break; + default: + SLANG_UNEXPECTED("unhandled code generation target"); + break; } return SLANG_FAIL; } @@ -2274,9 +2334,13 @@ static void _escapeDependencyString(const char* string, StringBuilder& outBuilde case '#': case '[': case ']': - case '\\': outBuilder.appendChar('\\'); break; + case '\\': + outBuilder.appendChar('\\'); + break; - case '$': outBuilder.appendChar('$'); break; + case '$': + outBuilder.appendChar('$'); + break; } outBuilder.appendChar(c); diff --git a/source/slang/slang-core-module-textures.cpp b/source/slang/slang-core-module-textures.cpp index 8198fa1db..0d20cc1dd 100644 --- a/source/slang/slang-core-module-textures.cpp +++ b/source/slang/slang-core-module-textures.cpp @@ -274,7 +274,9 @@ void TextureTypeInfo::writeGetDimensionFunctions() sizeDimCount = 3; break; - default: assert(!"unexpected"); break; + default: + assert(!"unexpected"); + break; } if (isArray) @@ -352,7 +354,9 @@ void TextureTypeInfo::writeGetDimensionFunctions() cc = 3; break; - default: SLANG_UNEXPECTED("unhandled resource shape"); break; + default: + SLANG_UNEXPECTED("unhandled resource shape"); + break; } if (isArray) @@ -429,7 +433,9 @@ void TextureTypeInfo::writeGetDimensionFunctions() }; switch (baseShape) { - case SLANG_TEXTURE_1D: extractSizeComponent(0, "width"); break; + case SLANG_TEXTURE_1D: + extractSizeComponent(0, "width"); + break; case SLANG_TEXTURE_2D: case SLANG_TEXTURE_CUBE: @@ -443,7 +449,9 @@ void TextureTypeInfo::writeGetDimensionFunctions() extractSizeComponent(2, "depth"); break; - default: assert(!"unexpected"); break; + default: + assert(!"unexpected"); + break; } if (isArray) diff --git a/source/slang/slang-doc-markdown-writer.cpp b/source/slang/slang-doc-markdown-writer.cpp index 2c0e6a040..df8a8bfb8 100644 --- a/source/slang/slang-doc-markdown-writer.cpp +++ b/source/slang/slang-doc-markdown-writer.cpp @@ -514,7 +514,8 @@ void DocMarkdownWriter::_appendCommaList(const List<String>& strings, char wrapC break; } - default: break; + default: + break; } } } @@ -525,11 +526,21 @@ void escapeHTMLContent(StringBuilder& sb, UnownedStringSlice str) { switch (ch) { - case '<': sb << "<"; break; - case '>': sb << ">"; break; - case '&': sb << "&"; break; - case '"': sb << """; break; - default: sb.appendChar(ch); break; + case '<': + sb << "<"; + break; + case '>': + sb << ">"; + break; + case '&': + sb << "&"; + break; + case '"': + sb << """; + break; + default: + sb.appendChar(ch); + break; } } } @@ -1450,7 +1461,9 @@ void DeclDocumentation::parse(const UnownedStringSlice& text) { case DocPageSection::ExperimentalCallout: case DocPageSection::InternalCallout: - case DocPageSection::DeprecatedCallout: currentSection = DocPageSection::Description; break; + case DocPageSection::DeprecatedCallout: + currentSection = DocPageSection::Description; + break; } } for (auto& kv : sectionBuilders) @@ -1744,7 +1757,8 @@ void DocMarkdownWriter::_appendEscaped(const UnownedStringSlice& text) start = cur; break; } - default: break; + default: + break; } } @@ -2052,7 +2066,9 @@ String DocMarkdownWriter::escapeMarkdownText(String text) sb << '\\'; sb.appendChar(c); break; - default: sb.appendChar(c); break; + default: + sb.appendChar(c); + break; } } return sb.produceString(); @@ -2154,7 +2170,9 @@ String DocMarkdownWriter::translateToMarkdownWithLinks(String text, bool strictC case Slang::Misc::TokenType::Comma: case Slang::Misc::TokenType::Dot: case Slang::Misc::TokenType::IntLiteral: - case Slang::Misc::TokenType::Semicolon: requireSpaceBeforeNextToken = false; break; + case Slang::Misc::TokenType::Semicolon: + requireSpaceBeforeNextToken = false; + break; default: requireSpaceBeforeNextToken = true; sb.appendChar(' '); @@ -2287,13 +2305,20 @@ const char* getSectionTitle(DocPageSection section) { switch (section) { - case DocPageSection::Description: return "Description"; - case DocPageSection::Parameter: return "Parameters"; - case DocPageSection::ReturnInfo: return "Return value"; - case DocPageSection::Remarks: return "Remarks"; - case DocPageSection::Example: return "Example"; - case DocPageSection::SeeAlso: return "See also"; - default: return ""; + case DocPageSection::Description: + return "Description"; + case DocPageSection::Parameter: + return "Parameters"; + case DocPageSection::ReturnInfo: + return "Return value"; + case DocPageSection::Remarks: + return "Remarks"; + case DocPageSection::Example: + return "Example"; + case DocPageSection::SeeAlso: + return "See also"; + default: + return ""; } } diff --git a/source/slang/slang-emit-c-like.cpp b/source/slang/slang-emit-c-like.cpp index 8b0794ef2..5d04a50db 100644 --- a/source/slang/slang-emit-c-like.cpp +++ b/source/slang/slang-emit-c-like.cpp @@ -232,7 +232,9 @@ void CLikeSourceEmitter::emitDeclaratorImpl(DeclaratorInfo* declarator) emitDeclarator(attributedDeclarator->next); } break; - default: SLANG_DIAGNOSE_UNEXPECTED(getSink(), SourceLoc(), "unknown declarator flavor"); break; + default: + SLANG_DIAGNOSE_UNEXPECTED(getSink(), SourceLoc(), "unknown declarator flavor"); + break; } } @@ -245,28 +247,45 @@ void CLikeSourceEmitter::emitSimpleType(IRType* type) { switch (op) { - case kIROp_VoidType: return UnownedStringSlice("void"); - case kIROp_BoolType: return UnownedStringSlice("bool"); - - case kIROp_Int8Type: return UnownedStringSlice("int8_t"); - case kIROp_Int16Type: return UnownedStringSlice("int16_t"); - case kIROp_IntType: return UnownedStringSlice("int"); - case kIROp_Int64Type: return UnownedStringSlice("int64_t"); - case kIROp_IntPtrType: return UnownedStringSlice("intptr_t"); - - case kIROp_UInt8Type: return UnownedStringSlice("uint8_t"); - case kIROp_UInt16Type: return UnownedStringSlice("uint16_t"); - case kIROp_UIntType: return UnownedStringSlice("uint"); - case kIROp_UInt64Type: return UnownedStringSlice("uint64_t"); - case kIROp_UIntPtrType: return UnownedStringSlice("uintptr_t"); - - case kIROp_HalfType: return UnownedStringSlice("half"); - - case kIROp_FloatType: return UnownedStringSlice("float"); - case kIROp_DoubleType: return UnownedStringSlice("double"); - - case kIROp_CharType: return UnownedStringSlice("uint8_t"); - default: return UnownedStringSlice(); + case kIROp_VoidType: + return UnownedStringSlice("void"); + case kIROp_BoolType: + return UnownedStringSlice("bool"); + + case kIROp_Int8Type: + return UnownedStringSlice("int8_t"); + case kIROp_Int16Type: + return UnownedStringSlice("int16_t"); + case kIROp_IntType: + return UnownedStringSlice("int"); + case kIROp_Int64Type: + return UnownedStringSlice("int64_t"); + case kIROp_IntPtrType: + return UnownedStringSlice("intptr_t"); + + case kIROp_UInt8Type: + return UnownedStringSlice("uint8_t"); + case kIROp_UInt16Type: + return UnownedStringSlice("uint16_t"); + case kIROp_UIntType: + return UnownedStringSlice("uint"); + case kIROp_UInt64Type: + return UnownedStringSlice("uint64_t"); + case kIROp_UIntPtrType: + return UnownedStringSlice("uintptr_t"); + + case kIROp_HalfType: + return UnownedStringSlice("half"); + + case kIROp_FloatType: + return UnownedStringSlice("float"); + case kIROp_DoubleType: + return UnownedStringSlice("double"); + + case kIROp_CharType: + return UnownedStringSlice("uint8_t"); + default: + return UnownedStringSlice(); } } @@ -357,7 +376,9 @@ void CLikeSourceEmitter::_emitType(IRType* type, DeclaratorInfo* declarator) { switch (type->getOp()) { - default: emitSimpleTypeAndDeclarator(type, declarator); break; + default: + emitSimpleTypeAndDeclarator(type, declarator); + break; case kIROp_RateQualifiedType: { @@ -527,8 +548,11 @@ void CLikeSourceEmitter::defaultEmitInstStmt(IRInst* inst) m_writer->emit(");\n"); } break; - case kIROp_discard: m_writer->emit("discard;\n"); break; - default: diagnoseUnhandledInst(inst); + case kIROp_discard: + m_writer->emit("discard;\n"); + break; + default: + diagnoseUnhandledInst(inst); } } @@ -610,7 +634,8 @@ void CLikeSourceEmitter::emitLivenessImpl(IRInst* inst) text = UnownedStringSlice::fromLiteral("SLANG_LIVE_END"); break; } - default: break; + default: + break; } m_writer->emit(text); @@ -695,14 +720,28 @@ void CLikeSourceEmitter::emitStringLiteral(String const& value) char buffer[] = {c, 0}; switch (c) { - default: m_writer->emit(buffer); break; + default: + m_writer->emit(buffer); + break; - case '\"': m_writer->emit("\\\""); break; - case '\'': m_writer->emit("\\\'"); break; - case '\\': m_writer->emit("\\\\"); break; - case '\n': m_writer->emit("\\n"); break; - case '\r': m_writer->emit("\\r"); break; - case '\t': m_writer->emit("\\t"); break; + case '\"': + m_writer->emit("\\\""); + break; + case '\'': + m_writer->emit("\\\'"); + break; + case '\\': + m_writer->emit("\\\\"); + break; + case '\n': + m_writer->emit("\\n"); + break; + case '\r': + m_writer->emit("\\r"); + break; + case '\t': + m_writer->emit("\\t"); + break; } } m_writer->emit("\""); @@ -912,11 +951,14 @@ void CLikeSourceEmitter::appendScrubbedName(const UnownedStringSlice& name, Stri // switch (c) { - default: break; + default: + break; case '.': case '\\': - case '/': c = '_'; break; + case '/': + c = '_'; + break; } if (((c >= 'a') && (c <= 'z')) || ((c >= 'A') && (c <= 'Z'))) @@ -1140,7 +1182,8 @@ String CLikeSourceEmitter::generateName(IRInst* inst) sb << "_" << Int32(getID(inst)); return sb.produceString(); } - default: break; + default: + break; } // Otherwise fall back to a construct temporary name // for the instruction. @@ -1276,7 +1319,9 @@ void CLikeSourceEmitter::emitSimpleValueImpl(IRInst* inst) break; } - case kIROp_FloatLit: m_writer->emit(((IRConstant*)inst)->value.floatVal); break; + case kIROp_FloatLit: + m_writer->emit(((IRConstant*)inst)->value.floatVal); + break; case kIROp_BoolLit: { @@ -1285,7 +1330,9 @@ void CLikeSourceEmitter::emitSimpleValueImpl(IRInst* inst) } break; - default: SLANG_UNIMPLEMENTED_X("val case for emit"); break; + default: + SLANG_UNIMPLEMENTED_X("val case for emit"); + break; } } @@ -1294,7 +1341,8 @@ bool CLikeSourceEmitter::shouldFoldInstIntoUseSites(IRInst* inst) // Certain opcodes should never/always be folded in switch (inst->getOp()) { - default: break; + default: + break; // Never fold these in, because they represent declarations // @@ -1305,13 +1353,15 @@ bool CLikeSourceEmitter::shouldFoldInstIntoUseSites(IRInst* inst) case kIROp_Param: case kIROp_Func: case kIROp_Alloca: - case kIROp_Store: return false; + case kIROp_Store: + return false; // Never fold these, because their result cannot be computed // as a sub-expression (they must be emitted as a declaration // or statement). case kIROp_UpdateElement: - case kIROp_DefaultConstruct: return false; + case kIROp_DefaultConstruct: + return false; // Always fold these in, because they are trivial // @@ -1319,7 +1369,8 @@ bool CLikeSourceEmitter::shouldFoldInstIntoUseSites(IRInst* inst) case kIROp_FloatLit: case kIROp_BoolLit: case kIROp_CapabilityConjunction: - case kIROp_CapabilityDisjunction: return true; + case kIROp_CapabilityDisjunction: + return true; // Always fold these in, because their results // cannot be represented in the type system of @@ -1333,11 +1384,14 @@ bool CLikeSourceEmitter::shouldFoldInstIntoUseSites(IRInst* inst) case kIROp_GetElementPtr: case kIROp_Specialize: case kIROp_LookupWitness: - case kIROp_GetValueFromBoundInterface: return true; + case kIROp_GetValueFromBoundInterface: + return true; - case kIROp_GetVulkanRayTracingPayloadLocation: return true; + case kIROp_GetVulkanRayTracingPayloadLocation: + return true; - case kIROp_NonUniformResourceIndex: return true; + case kIROp_NonUniformResourceIndex: + return true; } // Layouts and attributes are only present to annotate other @@ -1351,7 +1405,8 @@ bool CLikeSourceEmitter::shouldFoldInstIntoUseSites(IRInst* inst) switch (inst->getOp()) { - default: break; + default: + break; // HACK: don't fold these in because we currently lower // them to initializer lists, which aren't allowed in @@ -1360,7 +1415,8 @@ bool CLikeSourceEmitter::shouldFoldInstIntoUseSites(IRInst* inst) case kIROp_MakeStruct: case kIROp_MakeArray: case kIROp_swizzleSet: - case kIROp_MakeArrayFromElement: return false; + case kIROp_MakeArrayFromElement: + return false; } // Instructions with specific result *types* will usually @@ -1710,11 +1766,21 @@ void CLikeSourceEmitter::emitDereferenceOperand(IRInst* inst, EmitOpInfo const& emitBracketPostfix = false; switch (intLit->getValue()) { - case 0: m_writer->emit(".x"); break; - case 1: m_writer->emit(".y"); break; - case 2: m_writer->emit(".z"); break; - case 3: m_writer->emit(".w"); break; - default: emitBracketPostfix = true; break; + case 0: + m_writer->emit(".x"); + break; + case 1: + m_writer->emit(".y"); + break; + case 2: + m_writer->emit(".z"); + break; + case 3: + m_writer->emit(".w"); + break; + default: + emitBracketPostfix = true; + break; } } } @@ -1727,7 +1793,8 @@ void CLikeSourceEmitter::emitDereferenceOperand(IRInst* inst, EmitOpInfo const& maybeCloseParens(rightSideNeedClose); return; } - default: break; + default: + break; } auto dereferencePrec = EmitOpInfo::get(EmitOp::Prefix); @@ -1770,8 +1837,12 @@ void CLikeSourceEmitter::emitOperandImpl(IRInst* inst, EmitOpInfo const& outerPr switch (inst->getOp()) { case kIROp_Var: - case kIROp_GlobalVar: emitVarExpr(inst, outerPrec); break; - default: m_writer->emit(getName(inst)); break; + case kIROp_GlobalVar: + emitVarExpr(inst, outerPrec); + break; + default: + m_writer->emit(getName(inst)); + break; } } @@ -1832,12 +1903,18 @@ void CLikeSourceEmitter::emitInstResultDecl(IRInst* inst) case SourceLanguage::CUDA: case SourceLanguage::HLSL: case SourceLanguage::C: - case SourceLanguage::CPP: m_writer->emit("static const "); break; - case SourceLanguage::Metal: m_writer->emit("constant "); break; + case SourceLanguage::CPP: + m_writer->emit("static const "); + break; + case SourceLanguage::Metal: + m_writer->emit("constant "); + break; case SourceLanguage::WGSL: // This is handled by emitVarKeyword, below break; - default: m_writer->emit("const "); break; + default: + m_writer->emit("const "); + break; } } @@ -2069,7 +2146,9 @@ void CLikeSourceEmitter::emitCallExpr(IRCall* inst, EmitOpInfo outerPrec) break; case kIROp_ComPtrType: case kIROp_PtrType: - case kIROp_NativePtrType: emitComInterfaceCallExpr(inst, outerPrec); return; + case kIROp_NativePtrType: + emitComInterfaceCallExpr(inst, outerPrec); + return; } } @@ -2191,14 +2270,19 @@ void CLikeSourceEmitter::defaultEmitInstExpr(IRInst* inst, const EmitOpInfo& inO /* Don't need to to output anything for this instruction - it's used for reflecting string literals that are hashed with 'getStringHash' */ break; - case kIROp_RTTIPointerType: break; + case kIROp_RTTIPointerType: + break; case kIROp_undefined: - case kIROp_DefaultConstruct: m_writer->emit(getName(inst)); break; + case kIROp_DefaultConstruct: + m_writer->emit(getName(inst)); + break; case kIROp_IntLit: case kIROp_FloatLit: - case kIROp_BoolLit: emitSimpleValue(inst); break; + case kIROp_BoolLit: + emitSimpleValue(inst); + break; case kIROp_MakeVector: case kIROp_MakeMatrix: @@ -2678,7 +2762,9 @@ void CLikeSourceEmitter::defaultEmitInstExpr(IRInst* inst, const EmitOpInfo& inO } break; - case kIROp_Param: m_writer->emit(getName(inst)); break; + case kIROp_Param: + m_writer->emit(getName(inst)); + break; case kIROp_MakeArray: case kIROp_MakeStruct: @@ -2739,7 +2825,9 @@ void CLikeSourceEmitter::defaultEmitInstExpr(IRInst* inst, const EmitOpInfo& inO } break; case kIROp_GlobalConstant: - case kIROp_GetValueFromBoundInterface: emitOperand(inst->getOperand(0), outerPrec); break; + case kIROp_GetValueFromBoundInterface: + emitOperand(inst->getOperand(0), outerPrec); + break; case kIROp_ByteAddressBufferLoad: { @@ -2860,7 +2948,9 @@ void CLikeSourceEmitter::defaultEmitInstExpr(IRInst* inst, const EmitOpInfo& inO { break; // should already have been parsed and used. } - default: diagnoseUnhandledInst(inst); break; + default: + diagnoseUnhandledInst(inst); + break; } maybeCloseParens(needClose); } @@ -2913,7 +3003,8 @@ void CLikeSourceEmitter::_emitInst(IRInst* inst) case kIROp_DebugSource: case kIROp_DebugLine: case kIROp_DebugVar: - case kIROp_DebugValue: break; + case kIROp_DebugValue: + break; case kIROp_Unmodified: break; @@ -2934,10 +3025,14 @@ void CLikeSourceEmitter::_emitInst(IRInst* inst) case kIROp_AtomicExchange: case kIROp_AtomicCompareExchange: case kIROp_StructuredBufferGetDimensions: - case kIROp_MetalAtomicCast: emitInstStmt(inst); break; + case kIROp_MetalAtomicCast: + emitInstStmt(inst); + break; case kIROp_LiveRangeStart: - case kIROp_LiveRangeEnd: emitLiveness(inst); break; + case kIROp_LiveRangeEnd: + emitLiveness(inst); + break; case kIROp_undefined: case kIROp_DefaultConstruct: { @@ -2946,7 +3041,8 @@ void CLikeSourceEmitter::_emitInst(IRInst* inst) } break; - case kIROp_AllocateOpaqueHandle: break; + case kIROp_AllocateOpaqueHandle: + break; case kIROp_Var: { auto var = cast<IRVar>(inst); @@ -2980,7 +3076,9 @@ void CLikeSourceEmitter::_emitInst(IRInst* inst) m_writer->emit(";\n"); break; - case kIROp_discard: emitInstStmt(inst); break; + case kIROp_discard: + emitInstStmt(inst); + break; case kIROp_swizzleSet: { @@ -3157,7 +3255,9 @@ void CLikeSourceEmitter::_emitInstAsDefaultInitializedVar(IRInst* inst, IRType* case CodeGenTarget::CPPSource: case CodeGenTarget::HostCPPSource: case CodeGenTarget::PyTorchCppBinding: - case CodeGenTarget::CUDASource: m_writer->emit(" = {}"); break; + case CodeGenTarget::CUDASource: + m_writer->emit(" = {}"); + break; } m_writer->emit(";\n"); } @@ -3293,8 +3393,12 @@ void CLikeSourceEmitter::emitRegion(Region* inRegion) // Break and continue regions are trivial to handle, as long as we // don't need to consider multi-level break/continue (which we // don't for now). - case Region::Flavor::Break: m_writer->emit("break;\n"); break; - case Region::Flavor::Continue: m_writer->emit("continue;\n"); break; + case Region::Flavor::Break: + m_writer->emit("break;\n"); + break; + case Region::Flavor::Continue: + m_writer->emit("continue;\n"); + break; case Region::Flavor::If: { @@ -3655,7 +3759,8 @@ bool shouldWrapInExternCBlock(IRFunc* func) { switch (decor->getOp()) { - case kIROp_ExternCDecoration: return true; + case kIROp_ExternCDecoration: + return true; } } return false; @@ -4083,7 +4188,8 @@ bool _isFoldableValue(IRInst* val) return false; return true; } - default: return false; + default: + return false; } } @@ -4154,7 +4260,8 @@ void CLikeSourceEmitter::emitGlobalVar(IRGlobalVar* varDecl) m_writer->emit("static "); break; - default: break; + default: + break; } emitVarModifiers(layout, varDecl, varType); @@ -4305,18 +4412,34 @@ void CLikeSourceEmitter::emitGlobalInstImpl(IRInst* inst) } break; - case kIROp_GlobalVar: emitGlobalVar((IRGlobalVar*)inst); break; + case kIROp_GlobalVar: + emitGlobalVar((IRGlobalVar*)inst); + break; - case kIROp_GlobalParam: emitGlobalParam((IRGlobalParam*)inst); break; + case kIROp_GlobalParam: + emitGlobalParam((IRGlobalParam*)inst); + break; - case kIROp_Var: emitVar((IRVar*)inst); break; + case kIROp_Var: + emitVar((IRVar*)inst); + break; - case kIROp_StructType: emitStruct(cast<IRStructType>(inst)); break; - case kIROp_ClassType: emitClass(cast<IRClassType>(inst)); break; - case kIROp_InterfaceType: emitInterface(cast<IRInterfaceType>(inst)); break; - case kIROp_WitnessTable: emitWitnessTable(cast<IRWitnessTable>(inst)); break; + case kIROp_StructType: + emitStruct(cast<IRStructType>(inst)); + break; + case kIROp_ClassType: + emitClass(cast<IRClassType>(inst)); + break; + case kIROp_InterfaceType: + emitInterface(cast<IRInterfaceType>(inst)); + break; + case kIROp_WitnessTable: + emitWitnessTable(cast<IRWitnessTable>(inst)); + break; - case kIROp_RTTIObject: emitRTTIObject(cast<IRRTTIObject>(inst)); break; + case kIROp_RTTIObject: + emitRTTIObject(cast<IRRTTIObject>(inst)); + break; default: // We have an "ordinary" instruction at the global @@ -4368,7 +4491,9 @@ void CLikeSourceEmitter::ensureInstOperandsRec(ComputeEmitActionsContext* ctx, I } break; } - case kIROp_NativePtrType: requiredLevel = EmitAction::ForwardDeclaration; break; + case kIROp_NativePtrType: + requiredLevel = EmitAction::ForwardDeclaration; + break; case kIROp_LookupWitness: case kIROp_FieldExtract: case kIROp_FieldAddress: @@ -4380,7 +4505,8 @@ void CLikeSourceEmitter::ensureInstOperandsRec(ComputeEmitActionsContext* ctx, I } break; } - default: break; + default: + break; } if (auto comWitnessDecoration = as<IRCOMWitnessDecoration>(inst)) @@ -4423,9 +4549,12 @@ void CLikeSourceEmitter::ensureGlobalInst( // Skip certain instructions that don't affect output. switch (inst->getOp()) { - case kIROp_Generic: return; - case kIROp_ThisType: return; - default: break; + case kIROp_Generic: + return; + case kIROp_ThisType: + return; + default: + break; } if (as<IRBasicType>(inst)) return; @@ -4439,7 +4568,8 @@ void CLikeSourceEmitter::ensureGlobalInst( // but the pointer type itself should be considered emitted as definition. requiredLevel = EmitAction::Level::Definition; break; - default: break; + default: + break; } // Have we already processed this instruction? @@ -4481,7 +4611,8 @@ void CLikeSourceEmitter::ensureGlobalInst( return; } - default: break; + default: + break; } ctx->actions->add(action); } @@ -4547,7 +4678,9 @@ void CLikeSourceEmitter::emitForwardDeclaration(IRInst* inst) { switch (inst->getOp()) { - case kIROp_Func: emitFuncDecl(cast<IRFunc>(inst)); break; + case kIROp_Func: + emitFuncDecl(cast<IRFunc>(inst)); + break; case kIROp_StructType: m_writer->emit("struct "); m_writer->emit(getName(inst)); @@ -4563,7 +4696,8 @@ void CLikeSourceEmitter::emitForwardDeclaration(IRInst* inst) } break; } - default: SLANG_UNREACHABLE("emit forward declaration"); + default: + SLANG_UNREACHABLE("emit forward declaration"); } } @@ -4573,9 +4707,13 @@ void CLikeSourceEmitter::executeEmitActions(List<EmitAction> const& actions) { switch (action.level) { - case EmitAction::Level::ForwardDeclaration: emitForwardDeclaration(action.inst); break; + case EmitAction::Level::ForwardDeclaration: + emitForwardDeclaration(action.inst); + break; - case EmitAction::Level::Definition: emitGlobalInst(action.inst); break; + case EmitAction::Level::Definition: + emitGlobalInst(action.inst); + break; } } } diff --git a/source/slang/slang-emit-cpp.cpp b/source/slang/slang-emit-cpp.cpp index 04d513e7a..ed51f7825 100644 --- a/source/slang/slang-emit-cpp.cpp +++ b/source/slang/slang-emit-cpp.cpp @@ -74,32 +74,48 @@ static const char s_xyzwNames[] = "xyzw"; { switch (op) { - case kIROp_VoidType: return UnownedStringSlice("void"); - case kIROp_BoolType: return UnownedStringSlice("bool"); - - case kIROp_Int8Type: return UnownedStringSlice("int8_t"); - case kIROp_Int16Type: return UnownedStringSlice("int16_t"); - case kIROp_IntType: return UnownedStringSlice("int32_t"); - case kIROp_Int64Type: return UnownedStringSlice("int64_t"); - case kIROp_IntPtrType: return UnownedStringSlice("intptr_t"); - - case kIROp_UInt8Type: return UnownedStringSlice("uint8_t"); - case kIROp_UInt16Type: return UnownedStringSlice("uint16_t"); - case kIROp_UIntType: return UnownedStringSlice("uint32_t"); - case kIROp_UInt64Type: return UnownedStringSlice("uint64_t"); + case kIROp_VoidType: + return UnownedStringSlice("void"); + case kIROp_BoolType: + return UnownedStringSlice("bool"); + + case kIROp_Int8Type: + return UnownedStringSlice("int8_t"); + case kIROp_Int16Type: + return UnownedStringSlice("int16_t"); + case kIROp_IntType: + return UnownedStringSlice("int32_t"); + case kIROp_Int64Type: + return UnownedStringSlice("int64_t"); + case kIROp_IntPtrType: + return UnownedStringSlice("intptr_t"); + + case kIROp_UInt8Type: + return UnownedStringSlice("uint8_t"); + case kIROp_UInt16Type: + return UnownedStringSlice("uint16_t"); + case kIROp_UIntType: + return UnownedStringSlice("uint32_t"); + case kIROp_UInt64Type: + return UnownedStringSlice("uint64_t"); case kIROp_UIntPtrType: return UnownedStringSlice("uintptr_t"); // Not clear just yet how we should handle half... we want all processing as float // probly, but when reading/writing to memory converting - case kIROp_HalfType: return UnownedStringSlice("half"); + case kIROp_HalfType: + return UnownedStringSlice("half"); - case kIROp_FloatType: return UnownedStringSlice("float"); - case kIROp_DoubleType: return UnownedStringSlice("double"); - case kIROp_CharType: return UnownedStringSlice("char"); + case kIROp_FloatType: + return UnownedStringSlice("float"); + case kIROp_DoubleType: + return UnownedStringSlice("double"); + case kIROp_CharType: + return UnownedStringSlice("char"); - default: return UnownedStringSlice(); + default: + return UnownedStringSlice(); } } @@ -129,13 +145,26 @@ SlangResult CPPSourceEmitter::_calcCPPTextureTypeName( { switch (texType->getAccess()) { - case SLANG_RESOURCE_ACCESS_READ: break; - case SLANG_RESOURCE_ACCESS_WRITE: outName << "RW"; break; - case SLANG_RESOURCE_ACCESS_READ_WRITE: outName << "RW"; break; - case SLANG_RESOURCE_ACCESS_RASTER_ORDERED: outName << "RasterizerOrdered"; break; - case SLANG_RESOURCE_ACCESS_APPEND: outName << "Append"; break; - case SLANG_RESOURCE_ACCESS_CONSUME: outName << "Consume"; break; - case SLANG_RESOURCE_ACCESS_FEEDBACK: outName << "Feedback"; break; + case SLANG_RESOURCE_ACCESS_READ: + break; + case SLANG_RESOURCE_ACCESS_WRITE: + outName << "RW"; + break; + case SLANG_RESOURCE_ACCESS_READ_WRITE: + outName << "RW"; + break; + case SLANG_RESOURCE_ACCESS_RASTER_ORDERED: + outName << "RasterizerOrdered"; + break; + case SLANG_RESOURCE_ACCESS_APPEND: + outName << "Append"; + break; + case SLANG_RESOURCE_ACCESS_CONSUME: + outName << "Consume"; + break; + case SLANG_RESOURCE_ACCESS_FEEDBACK: + outName << "Feedback"; + break; default: SLANG_DIAGNOSE_UNEXPECTED(getSink(), SourceLoc(), "unhandled resource access mode"); return SLANG_FAIL; @@ -143,11 +172,21 @@ SlangResult CPPSourceEmitter::_calcCPPTextureTypeName( switch (texType->GetBaseShape()) { - case SLANG_TEXTURE_1D: outName << "Texture1D"; break; - case SLANG_TEXTURE_2D: outName << "Texture2D"; break; - case SLANG_TEXTURE_3D: outName << "Texture3D"; break; - case SLANG_TEXTURE_CUBE: outName << "TextureCube"; break; - case SLANG_TEXTURE_BUFFER: outName << "Buffer"; break; + case SLANG_TEXTURE_1D: + outName << "Texture1D"; + break; + case SLANG_TEXTURE_2D: + outName << "Texture2D"; + break; + case SLANG_TEXTURE_3D: + outName << "Texture3D"; + break; + case SLANG_TEXTURE_CUBE: + outName << "TextureCube"; + break; + case SLANG_TEXTURE_BUFFER: + outName << "Buffer"; + break; default: SLANG_DIAGNOSE_UNEXPECTED(getSink(), SourceLoc(), "unhandled resource shape"); return SLANG_FAIL; @@ -170,14 +209,16 @@ static UnownedStringSlice _getResourceTypePrefix(IROp op) { switch (op) { - case kIROp_HLSLStructuredBufferType: return UnownedStringSlice::fromLiteral("StructuredBuffer"); + case kIROp_HLSLStructuredBufferType: + return UnownedStringSlice::fromLiteral("StructuredBuffer"); case kIROp_HLSLRWStructuredBufferType: return UnownedStringSlice::fromLiteral("RWStructuredBuffer"); case kIROp_HLSLRWByteAddressBufferType: return UnownedStringSlice::fromLiteral("RWByteAddressBuffer"); case kIROp_HLSLByteAddressBufferType: return UnownedStringSlice::fromLiteral("ByteAddressBuffer"); - case kIROp_SamplerStateType: return UnownedStringSlice::fromLiteral("SamplerState"); + case kIROp_SamplerStateType: + return UnownedStringSlice::fromLiteral("SamplerState"); case kIROp_SamplerComparisonStateType: return UnownedStringSlice::fromLiteral("SamplerComparisonState"); case kIROp_HLSLRasterizerOrderedStructuredBufferType: @@ -191,7 +232,8 @@ static UnownedStringSlice _getResourceTypePrefix(IROp op) case kIROp_RaytracingAccelerationStructureType: return UnownedStringSlice::fromLiteral("RaytracingAccelerationStructure"); - default: return UnownedStringSlice(); + default: + return UnownedStringSlice(); } } @@ -444,7 +486,8 @@ void CPPSourceEmitter::useType(IRType* type) type = static_cast<IRPtrTypeBase*>(type)->getValueType(); break; } - default: break; + default: + break; } switch (type->getOp()) @@ -893,7 +936,8 @@ void CPPSourceEmitter::emitEntryPointAttributesImpl( m_writer->emit(")]\n"); break; } - default: break; + default: + break; } m_writer->emit("SLANG_PRELUDE_EXPORT\n"); @@ -916,7 +960,8 @@ bool isPublicOrExportedFunc(IRFunc* func) { return true; } - default: break; + default: + break; } } return false; @@ -1069,7 +1114,9 @@ void CPPSourceEmitter::_emitType(IRType* type, DeclaratorInfo* declarator) { switch (type->getOp()) { - default: CLikeSourceEmitter::_emitType(type, declarator); break; + default: + CLikeSourceEmitter::_emitType(type, declarator); + break; case kIROp_VectorType: case kIROp_MatrixType: { @@ -1278,7 +1325,8 @@ bool CPPSourceEmitter::tryEmitInstStmtImpl(IRInst* inst) m_writer->emit(");\n"); return true; } - default: return false; + default: + return false; } } @@ -1587,10 +1635,17 @@ bool CPPSourceEmitter::tryEmitInstExprImpl(IRInst* inst, const EmitOpInfo& inOut { switch (basicType->getOp()) { - case kIROp_HalfType: m_writer->emit("F16_fmod("); break; - case kIROp_FloatType: m_writer->emit("F32_fmod("); break; - case kIROp_DoubleType: m_writer->emit("F64_fmod("); break; - default: return false; + case kIROp_HalfType: + m_writer->emit("F16_fmod("); + break; + case kIROp_FloatType: + m_writer->emit("F32_fmod("); + break; + case kIROp_DoubleType: + m_writer->emit("F64_fmod("); + break; + default: + return false; } emitOperand(inst->getOperand(0), getInfo(EmitOp::General)); m_writer->emit(", "); @@ -1803,8 +1858,10 @@ bool CPPSourceEmitter::shouldFoldInstIntoUseSites(IRInst* inst) case kIROp_IntCast: case kIROp_FloatCast: case kIROp_CastIntToFloat: - case kIROp_CastFloatToInt: return false; - default: break; + case kIROp_CastFloatToInt: + return false; + default: + break; } } switch (inst->getOp()) @@ -1814,8 +1871,10 @@ bool CPPSourceEmitter::shouldFoldInstIntoUseSites(IRInst* inst) case kIROp_IntCast: case kIROp_FloatCast: case kIROp_CastIntToFloat: - case kIROp_CastFloatToInt: return false; - default: break; + case kIROp_CastFloatToInt: + return false; + default: + break; } } return true; @@ -1913,8 +1972,12 @@ void CPPSourceEmitter::emitOperandImpl(IRInst* inst, EmitOpInfo const& outerPrec switch (inst->getOp()) { case kIROp_Var: - case kIROp_GlobalVar: emitVarExpr(inst, outerPrec); break; - default: m_writer->emit(getName(inst)); break; + case kIROp_GlobalVar: + emitVarExpr(inst, outerPrec); + break; + default: + m_writer->emit(getName(inst)); + break; } } @@ -1928,7 +1991,8 @@ void CPPSourceEmitter::emitOperandImpl(IRInst* inst, EmitOpInfo const& outerPrec { return true; } - default: return false; + default: + return false; } } @@ -2125,8 +2189,11 @@ void CPPSourceEmitter::_emitForwardDeclarations(const List<EmitAction>& actions) { case kIROp_Func: case kIROp_StructType: - case kIROp_InterfaceType: emitForwardDeclaration(action.inst); break; - default: break; + case kIROp_InterfaceType: + emitForwardDeclaration(action.inst); + break; + default: + break; } } break; diff --git a/source/slang/slang-emit-cuda.cpp b/source/slang/slang-emit-cuda.cpp index 4caddbc11..c51d0c20a 100644 --- a/source/slang/slang-emit-cuda.cpp +++ b/source/slang/slang-emit-cuda.cpp @@ -51,30 +51,48 @@ UnownedStringSlice CUDASourceEmitter::getBuiltinTypeName(IROp op) { switch (op) { - case kIROp_VoidType: return UnownedStringSlice("void"); - case kIROp_BoolType: return UnownedStringSlice("bool"); - - case kIROp_Int8Type: return UnownedStringSlice("char"); - case kIROp_Int16Type: return UnownedStringSlice("short"); - case kIROp_IntType: return UnownedStringSlice("int"); - case kIROp_Int64Type: return UnownedStringSlice("longlong"); - - case kIROp_UInt8Type: return UnownedStringSlice("uchar"); - case kIROp_UInt16Type: return UnownedStringSlice("ushort"); - case kIROp_UIntType: return UnownedStringSlice("uint"); - case kIROp_UInt64Type: return UnownedStringSlice("ulonglong"); + case kIROp_VoidType: + return UnownedStringSlice("void"); + case kIROp_BoolType: + return UnownedStringSlice("bool"); + + case kIROp_Int8Type: + return UnownedStringSlice("char"); + case kIROp_Int16Type: + return UnownedStringSlice("short"); + case kIROp_IntType: + return UnownedStringSlice("int"); + case kIROp_Int64Type: + return UnownedStringSlice("longlong"); + + case kIROp_UInt8Type: + return UnownedStringSlice("uchar"); + case kIROp_UInt16Type: + return UnownedStringSlice("ushort"); + case kIROp_UIntType: + return UnownedStringSlice("uint"); + case kIROp_UInt64Type: + return UnownedStringSlice("ulonglong"); #if SLANG_PTR_IS_64 - case kIROp_IntPtrType: return UnownedStringSlice("int64_t"); - case kIROp_UIntPtrType: return UnownedStringSlice("uint64_t"); + case kIROp_IntPtrType: + return UnownedStringSlice("int64_t"); + case kIROp_UIntPtrType: + return UnownedStringSlice("uint64_t"); #else - case kIROp_IntPtrType: return UnownedStringSlice("int"); - case kIROp_UIntPtrType: return UnownedStringSlice("uint"); + case kIROp_IntPtrType: + return UnownedStringSlice("int"); + case kIROp_UIntPtrType: + return UnownedStringSlice("uint"); #endif - case kIROp_HalfType: return UnownedStringSlice("__half"); + case kIROp_HalfType: + return UnownedStringSlice("__half"); - case kIROp_FloatType: return UnownedStringSlice("float"); - case kIROp_DoubleType: return UnownedStringSlice("double"); - default: return UnownedStringSlice(); + case kIROp_FloatType: + return UnownedStringSlice("float"); + case kIROp_DoubleType: + return UnownedStringSlice("double"); + default: + return UnownedStringSlice(); } } @@ -83,23 +101,36 @@ UnownedStringSlice CUDASourceEmitter::getVectorPrefix(IROp op) { switch (op) { - case kIROp_BoolType: return UnownedStringSlice("bool"); - - case kIROp_Int8Type: return UnownedStringSlice("char"); - case kIROp_Int16Type: return UnownedStringSlice("short"); - case kIROp_IntType: return UnownedStringSlice("int"); - case kIROp_Int64Type: return UnownedStringSlice("longlong"); - - case kIROp_UInt8Type: return UnownedStringSlice("uchar"); - case kIROp_UInt16Type: return UnownedStringSlice("ushort"); - case kIROp_UIntType: return UnownedStringSlice("uint"); - case kIROp_UInt64Type: return UnownedStringSlice("ulonglong"); - - case kIROp_HalfType: return UnownedStringSlice("__half"); - - case kIROp_FloatType: return UnownedStringSlice("float"); - case kIROp_DoubleType: return UnownedStringSlice("double"); - default: return UnownedStringSlice(); + case kIROp_BoolType: + return UnownedStringSlice("bool"); + + case kIROp_Int8Type: + return UnownedStringSlice("char"); + case kIROp_Int16Type: + return UnownedStringSlice("short"); + case kIROp_IntType: + return UnownedStringSlice("int"); + case kIROp_Int64Type: + return UnownedStringSlice("longlong"); + + case kIROp_UInt8Type: + return UnownedStringSlice("uchar"); + case kIROp_UInt16Type: + return UnownedStringSlice("ushort"); + case kIROp_UIntType: + return UnownedStringSlice("uint"); + case kIROp_UInt64Type: + return UnownedStringSlice("ulonglong"); + + case kIROp_HalfType: + return UnownedStringSlice("__half"); + + case kIROp_FloatType: + return UnownedStringSlice("float"); + case kIROp_DoubleType: + return UnownedStringSlice("double"); + default: + return UnownedStringSlice(); } } @@ -136,7 +167,8 @@ SlangResult CUDASourceEmitter::_calcCUDATextureTypeName( outName << "CUsurfObject"; return SLANG_OK; } - default: break; + default: + break; } return SLANG_FAIL; } @@ -190,9 +222,14 @@ SlangResult CUDASourceEmitter::calcTypeName(IRType* type, CodeGenTarget target, switch (type->getOp()) { - case kIROp_SamplerStateType: out << "SamplerState"; return SLANG_OK; - case kIROp_SamplerComparisonStateType: out << "SamplerComparisonState"; return SLANG_OK; - default: break; + case kIROp_SamplerStateType: + out << "SamplerState"; + return SLANG_OK; + case kIROp_SamplerComparisonStateType: + out << "SamplerComparisonState"; + return SLANG_OK; + default: + break; } break; @@ -210,7 +247,8 @@ SlangResult CUDASourceEmitter::calcTypeName(IRType* type, CodeGenTarget target, break; } - default: break; + default: + break; } } @@ -293,10 +331,13 @@ String CUDASourceEmitter::generateEntryPointNameImpl(IREntryPointDecoration* ent auto stage = entryPointDecor->getProfile().getStage(); switch (stage) { - default: break; + default: + break; -#define CASE(STAGE, PREFIX) \ - case Stage::STAGE: globalSymbolName = #PREFIX + funcName; break +#define CASE(STAGE, PREFIX) \ + case Stage::STAGE: \ + globalSymbolName = #PREFIX + funcName; \ + break // Optix 7 Guide, Section 6.1 (Program input) // @@ -654,7 +695,8 @@ bool CUDASourceEmitter::tryEmitInstStmtImpl(IRInst* inst) m_writer->emit(", -1);\n"); return true; } - default: return false; + default: + return false; } } @@ -876,7 +918,8 @@ bool CUDASourceEmitter::tryEmitInstExprImpl(IRInst* inst, const EmitOpInfo& inOu m_writer->emit(")"); return true; } - default: break; + default: + break; } return Super::tryEmitInstExprImpl(inst, inOuterPrec); @@ -915,7 +958,9 @@ void CUDASourceEmitter::emitSimpleTypeImpl(IRType* type) m_writer->emit(as<IRIntLit>(vectorType->getElementCount())->getValue()); break; } - default: m_writer->emit(_getTypeName(type)); break; + default: + m_writer->emit(_getTypeName(type)); + break; } } diff --git a/source/slang/slang-emit-glsl.cpp b/source/slang/slang-emit-glsl.cpp index bd8987d03..43ab7b74e 100644 --- a/source/slang/slang-emit-glsl.cpp +++ b/source/slang/slang-emit-glsl.cpp @@ -55,7 +55,8 @@ SlangResult GLSLSourceEmitter::init() _requireSPIRVVersion(SemanticVersion(1, 4)); break; } - default: break; + default: + break; } if (getTargetProgram()->getOptionSet().shouldUseScalarLayout()) @@ -112,8 +113,10 @@ void GLSLSourceEmitter::_requireGLSLVersion(int version) { switch (version) { -#define CASE(NUMBER) \ - case NUMBER: _requireGLSLVersion(ProfileVersion::GLSL_##NUMBER); break +#define CASE(NUMBER) \ + case NUMBER: \ + _requireGLSLVersion(ProfileVersion::GLSL_##NUMBER); \ + break CASE(150); CASE(330); CASE(400); @@ -180,13 +183,19 @@ void GLSLSourceEmitter::_emitGLSLStructuredBuffer( m_writer->emit( getTargetProgram()->getOptionSet().shouldUseScalarLayout() ? "scalar" : "std430"); break; - case kIROp_Std430BufferLayoutType: m_writer->emit("std430"); break; - case kIROp_Std140BufferLayoutType: m_writer->emit("std140"); break; + case kIROp_Std430BufferLayoutType: + m_writer->emit("std430"); + break; + case kIROp_Std140BufferLayoutType: + m_writer->emit("std140"); + break; case kIROp_ScalarBufferLayoutType: _requireGLSLExtension(toSlice("GL_EXT_scalar_block_layout")); m_writer->emit("scalar"); break; - default: m_writer->emit("std430"); break; + default: + m_writer->emit("std430"); + break; } bool isReadOnly = (as<IRHLSLStructuredBufferType>(structuredBufferType) != nullptr); @@ -297,8 +306,12 @@ void GLSLSourceEmitter::emitSSBOHeader(IRGlobalParam* varDecl, IRType* bufferTyp m_writer->emit( getTargetProgram()->getOptionSet().shouldUseScalarLayout() ? "scalar" : "std430"); break; - case kIROp_Std430BufferLayoutType: m_writer->emit("std430"); break; - case kIROp_Std140BufferLayoutType: m_writer->emit("std140"); break; + case kIROp_Std430BufferLayoutType: + m_writer->emit("std430"); + break; + case kIROp_Std140BufferLayoutType: + m_writer->emit("std140"); + break; case kIROp_ScalarBufferLayoutType: _requireGLSLExtension(toSlice("GL_EXT_scalar_block_layout")); m_writer->emit("scalar"); @@ -607,7 +620,9 @@ void GLSLSourceEmitter::_emitGLSLImageFormatModifier(IRInst* var, IRTextureType* m_writer->emit("layout("); switch (vectorWidth) { - default: m_writer->emit("rgba"); break; + default: + m_writer->emit("rgba"); + break; case 3: { @@ -635,23 +650,49 @@ void GLSLSourceEmitter::_emitGLSLImageFormatModifier(IRInst* var, IRTextureType* break; } - case 2: m_writer->emit("rg"); break; - case 1: m_writer->emit("r"); break; + case 2: + m_writer->emit("rg"); + break; + case 1: + m_writer->emit("r"); + break; } switch (elementBasicType->getBaseType()) { default: - case BaseType::Float: m_writer->emit("32f"); break; - case BaseType::Half: m_writer->emit("16f"); break; - case BaseType::UInt: m_writer->emit("32ui"); break; - case BaseType::Int: m_writer->emit("32i"); break; - case BaseType::Int8: m_writer->emit("8i"); break; - case BaseType::Int16: m_writer->emit("16i"); break; - case BaseType::Int64: m_writer->emit("64i"); break; - case BaseType::IntPtr: m_writer->emit("64i"); break; - case BaseType::UInt8: m_writer->emit("8ui"); break; - case BaseType::UInt16: m_writer->emit("16ui"); break; - case BaseType::UInt64: m_writer->emit("64ui"); break; + case BaseType::Float: + m_writer->emit("32f"); + break; + case BaseType::Half: + m_writer->emit("16f"); + break; + case BaseType::UInt: + m_writer->emit("32ui"); + break; + case BaseType::Int: + m_writer->emit("32i"); + break; + case BaseType::Int8: + m_writer->emit("8i"); + break; + case BaseType::Int16: + m_writer->emit("16i"); + break; + case BaseType::Int64: + m_writer->emit("64i"); + break; + case BaseType::IntPtr: + m_writer->emit("64i"); + break; + case BaseType::UInt8: + m_writer->emit("8ui"); + break; + case BaseType::UInt16: + m_writer->emit("16ui"); + break; + case BaseType::UInt64: + m_writer->emit("64ui"); + break; case BaseType::UIntPtr: m_writer->emit("64ui"); break; @@ -783,8 +824,12 @@ bool GLSLSourceEmitter::_emitGLSLLayoutQualifierWithBindingKinds( m_writer->emit(")\n"); break; - case LayoutResourceKind::PushConstantBuffer: m_writer->emit("layout(push_constant)\n"); break; - case LayoutResourceKind::ShaderRecord: m_writer->emit("layout(shaderRecordEXT)\n"); break; + case LayoutResourceKind::PushConstantBuffer: + m_writer->emit("layout(push_constant)\n"); + break; + case LayoutResourceKind::ShaderRecord: + m_writer->emit("layout(shaderRecordEXT)\n"); + break; case LayoutResourceKind::InputAttachmentIndex: m_writer->emit("layout(input_attachment_index = "); @@ -805,9 +850,11 @@ void GLSLSourceEmitter::_emitGLSLLayoutQualifiers( switch (getSourceLanguage()) { - default: return; + default: + return; - case SourceLanguage::GLSL: break; + case SourceLanguage::GLSL: + break; } EmitVarChain chain(layout, inChain); @@ -850,12 +897,24 @@ void GLSLSourceEmitter::_emitGLSLTextureOrTextureSamplerType( m_writer->emit(baseName); switch (type->GetBaseShape()) { - case SLANG_TEXTURE_1D: m_writer->emit("1D"); break; - case SLANG_TEXTURE_2D: m_writer->emit("2D"); break; - case SLANG_TEXTURE_3D: m_writer->emit("3D"); break; - case SLANG_TEXTURE_CUBE: m_writer->emit("Cube"); break; - case SLANG_TEXTURE_BUFFER: m_writer->emit("Buffer"); break; - default: SLANG_DIAGNOSE_UNEXPECTED(getSink(), SourceLoc(), "unhandled resource shape"); break; + case SLANG_TEXTURE_1D: + m_writer->emit("1D"); + break; + case SLANG_TEXTURE_2D: + m_writer->emit("2D"); + break; + case SLANG_TEXTURE_3D: + m_writer->emit("3D"); + break; + case SLANG_TEXTURE_CUBE: + m_writer->emit("Cube"); + break; + case SLANG_TEXTURE_BUFFER: + m_writer->emit("Buffer"); + break; + default: + SLANG_DIAGNOSE_UNEXPECTED(getSink(), SourceLoc(), "unhandled resource shape"); + break; } if (type->isMultisample()) @@ -882,9 +941,15 @@ void GLSLSourceEmitter::_emitGLSLTypePrefix(IRType* type, bool promoteHalfToFloa // no prefix break; - case kIROp_Int8Type: m_writer->emit("i8"); break; - case kIROp_Int16Type: m_writer->emit("i16"); break; - case kIROp_IntType: m_writer->emit("i"); break; + case kIROp_Int8Type: + m_writer->emit("i8"); + break; + case kIROp_Int16Type: + m_writer->emit("i16"); + break; + case kIROp_IntType: + m_writer->emit("i"); + break; case kIROp_Int64Type: { _requireBaseType(BaseType::Int64); @@ -902,9 +967,15 @@ void GLSLSourceEmitter::_emitGLSLTypePrefix(IRType* type, bool promoteHalfToFloa break; } - case kIROp_UInt8Type: m_writer->emit("u8"); break; - case kIROp_UInt16Type: m_writer->emit("u16"); break; - case kIROp_UIntType: m_writer->emit("u"); break; + case kIROp_UInt8Type: + m_writer->emit("u8"); + break; + case kIROp_UInt16Type: + m_writer->emit("u16"); + break; + case kIROp_UIntType: + m_writer->emit("u"); + break; case kIROp_UInt64Type: { @@ -922,7 +993,9 @@ void GLSLSourceEmitter::_emitGLSLTypePrefix(IRType* type, bool promoteHalfToFloa #endif break; } - case kIROp_BoolType: m_writer->emit("b"); break; + case kIROp_BoolType: + m_writer->emit("b"); + break; case kIROp_HalfType: { @@ -937,7 +1010,9 @@ void GLSLSourceEmitter::_emitGLSLTypePrefix(IRType* type, bool promoteHalfToFloa } break; } - case kIROp_DoubleType: m_writer->emit("d"); break; + case kIROp_DoubleType: + m_writer->emit("d"); + break; case kIROp_VectorType: _emitGLSLTypePrefix(cast<IRVectorType>(type)->getElementType(), promoteHalfToFloat); @@ -947,7 +1022,9 @@ void GLSLSourceEmitter::_emitGLSLTypePrefix(IRType* type, bool promoteHalfToFloa _emitGLSLTypePrefix(cast<IRMatrixType>(type)->getElementType(), promoteHalfToFloat); break; - default: SLANG_DIAGNOSE_UNEXPECTED(getSink(), SourceLoc(), "unhandled GLSL type prefix"); break; + default: + SLANG_DIAGNOSE_UNEXPECTED(getSink(), SourceLoc(), "unhandled GLSL type prefix"); + break; } } @@ -1044,11 +1121,14 @@ void GLSLSourceEmitter::_maybeEmitGLSLFlatModifier(IRType* valueType) switch (tt->getOp()) { - default: break; + default: + break; case kIROp_IntType: case kIROp_UIntType: - case kIROp_UInt64Type: m_writer->emit("flat "); break; + case kIROp_UInt64Type: + m_writer->emit("flat "); + break; } } @@ -1183,9 +1263,14 @@ void GLSLSourceEmitter::emitSimpleValueImpl(IRInst* inst) m_writer->emit(((IRConstant*)inst)->value.floatVal); switch (type->getOp()) { - case kIROp_HalfType: m_writer->emit("HF"); break; - case kIROp_DoubleType: m_writer->emit("LF"); break; - default: break; + case kIROp_HalfType: + m_writer->emit("HF"); + break; + case kIROp_DoubleType: + m_writer->emit("LF"); + break; + default: + break; } return; @@ -1194,7 +1279,8 @@ void GLSLSourceEmitter::emitSimpleValueImpl(IRInst* inst) break; } - default: break; + default: + break; } Super::emitSimpleValueImpl(inst); @@ -1296,12 +1382,17 @@ void GLSLSourceEmitter::emitEntryPointAttributesImpl( switch (type->getOp()) { - case kIROp_HLSLPointStreamType: m_writer->emit("layout(points) out;\n"); break; - case kIROp_HLSLLineStreamType: m_writer->emit("layout(line_strip) out;\n"); break; + case kIROp_HLSLPointStreamType: + m_writer->emit("layout(points) out;\n"); + break; + case kIROp_HLSLLineStreamType: + m_writer->emit("layout(line_strip) out;\n"); + break; case kIROp_HLSLTriangleStreamType: m_writer->emit("layout(triangle_strip) out;\n"); break; - default: SLANG_ASSERT(!"Unknown stream out type"); + default: + SLANG_ASSERT(!"Unknown stream out type"); } } } @@ -1347,7 +1438,8 @@ void GLSLSourceEmitter::emitEntryPointAttributesImpl( } break; // TODO: There are other stages that will need this kind of handling. - default: break; + default: + break; } } @@ -1508,7 +1600,8 @@ void GLSLSourceEmitter::emitImageFormatModifierImpl(IRInst* varDecl, IRType* var } break; - default: break; + default: + break; } } } @@ -1535,7 +1628,9 @@ void GLSLSourceEmitter::emitLayoutQualifiersImpl(IRVarLayout* layout) case LayoutResourceKind::Uniform: // - case LayoutResourceKind::DescriptorTableSlot: m_writer->emit("uniform "); break; + case LayoutResourceKind::DescriptorTableSlot: + m_writer->emit("uniform "); + break; case LayoutResourceKind::VaryingInput: { @@ -1567,7 +1662,8 @@ void GLSLSourceEmitter::emitLayoutQualifiersImpl(IRVarLayout* layout) } break; - default: continue; + default: + continue; } break; @@ -1581,13 +1677,20 @@ static const char* _getGLSLVectorCompareFunctionName(IROp op) switch (op) { - case kIROp_Eql: return "equal"; - case kIROp_Neq: return "notEqual"; - case kIROp_Greater: return "greaterThan"; - case kIROp_Less: return "lessThan"; - case kIROp_Geq: return "greaterThanEqual"; - case kIROp_Leq: return "lessThanEqual"; - default: return nullptr; + case kIROp_Eql: + return "equal"; + case kIROp_Neq: + return "notEqual"; + case kIROp_Greater: + return "greaterThan"; + case kIROp_Less: + return "lessThan"; + case kIROp_Geq: + return "greaterThanEqual"; + case kIROp_Leq: + return "lessThanEqual"; + default: + return nullptr; } } @@ -1760,13 +1863,17 @@ void GLSLSourceEmitter::emitGlobalInstImpl(IRInst* inst) { switch (inst->getOp()) { - case kIROp_HLSLConstBufferPointerType: emitBufferPointerTypeDefinition(inst); break; + case kIROp_HLSLConstBufferPointerType: + emitBufferPointerTypeDefinition(inst); + break; // No need to use structs which are just taking part in a SSBO declaration case kIROp_StructType: if (isSSBOInternalStructType(inst)) break; [[fallthrough]]; - default: Super::emitGlobalInstImpl(inst); break; + default: + Super::emitGlobalInstImpl(inst); + break; } } @@ -1845,7 +1952,9 @@ bool GLSLSourceEmitter::tryEmitInstExprImpl(IRInst* inst, const EmitOpInfo& inOu auto fromType = extractBaseType(inst->getOperand(0)->getDataType()); switch (toType) { - default: diagnoseUnhandledInst(inst); break; + default: + diagnoseUnhandledInst(inst); + break; case BaseType::UInt: if (fromType == BaseType::Float) @@ -1905,18 +2014,28 @@ bool GLSLSourceEmitter::tryEmitInstExprImpl(IRInst* inst, const EmitOpInfo& inOu emitOperand(inst->getOperand(0), getInfo(EmitOp::General)); m_writer->emit(")).x)"); return true; - default: emitType(inst->getDataType()); break; + default: + emitType(inst->getDataType()); + break; } break; case BaseType::Float: switch (fromType) { - case BaseType::Int: m_writer->emit("intBitsToFloat"); break; - case BaseType::UInt: m_writer->emit("uintBitsToFloat"); break; - default: emitType(inst->getDataType()); break; + case BaseType::Int: + m_writer->emit("intBitsToFloat"); + break; + case BaseType::UInt: + m_writer->emit("uintBitsToFloat"); + break; + default: + emitType(inst->getDataType()); + break; } break; - case BaseType::Bool: m_writer->emit("bool"); break; + case BaseType::Bool: + m_writer->emit("bool"); + break; } m_writer->emit("("); @@ -1925,8 +2044,10 @@ bool GLSLSourceEmitter::tryEmitInstExprImpl(IRInst* inst, const EmitOpInfo& inOu return true; } - case kIROp_And: return _tryEmitLogicalBinOp(inst, getInfo(EmitOp::BitAnd), inOuterPrec); - case kIROp_Or: return _tryEmitLogicalBinOp(inst, getInfo(EmitOp::BitOr), inOuterPrec); + case kIROp_And: + return _tryEmitLogicalBinOp(inst, getInfo(EmitOp::BitAnd), inOuterPrec); + case kIROp_Or: + return _tryEmitLogicalBinOp(inst, getInfo(EmitOp::BitOr), inOuterPrec); case kIROp_Not: { IRInst* operand = inst->getOperand(0); @@ -2197,7 +2318,8 @@ bool GLSLSourceEmitter::tryEmitInstExprImpl(IRInst* inst, const EmitOpInfo& inOu m_writer->emit(")"); return true; } - default: break; + default: + break; } // Not handled @@ -2526,7 +2648,8 @@ bool GLSLSourceEmitter::tryEmitInstStmtImpl(IRInst* inst) m_writer->emit(");\n"); return true; } - default: return false; + default: + return false; } } @@ -2539,7 +2662,8 @@ void GLSLSourceEmitter::handleRequiredCapabilitiesImpl(IRInst* inst) { switch (decoration->getOp()) { - default: break; + default: + break; case kIROp_RequireGLSLExtensionDecoration: { @@ -2627,8 +2751,9 @@ static Index _getGLSLVersion(ProfileVersion profile) { switch (profile) { -#define CASE(TAG, VALUE) \ - case ProfileVersion::TAG: return VALUE; +#define CASE(TAG, VALUE) \ + case ProfileVersion::TAG: \ + return VALUE; CASE(GLSL_150, 150); CASE(GLSL_330, 330); CASE(GLSL_400, 400); @@ -2640,7 +2765,8 @@ static Index _getGLSLVersion(ProfileVersion profile) CASE(GLSL_460, 460); #undef CASE - default: break; + default: + break; } return -1; } @@ -2854,7 +2980,9 @@ void GLSLSourceEmitter::emitSimpleTypeImpl(IRType* type) return; } case kIROp_StructType: - case kIROp_HLSLConstBufferPointerType: m_writer->emit(getName(type)); return; + case kIROp_HLSLConstBufferPointerType: + m_writer->emit(getName(type)); + return; case kIROp_VectorType: { @@ -2883,8 +3011,12 @@ void GLSLSourceEmitter::emitSimpleTypeImpl(IRType* type) auto samplerStateType = cast<IRSamplerStateTypeBase>(type); switch (samplerStateType->getOp()) { - case kIROp_SamplerStateType: m_writer->emit("sampler"); break; - case kIROp_SamplerComparisonStateType: m_writer->emit("samplerShadow"); break; + case kIROp_SamplerStateType: + m_writer->emit("sampler"); + break; + case kIROp_SamplerComparisonStateType: + m_writer->emit("samplerShadow"); + break; default: SLANG_DIAGNOSE_UNEXPECTED(getSink(), SourceLoc(), "unhandled sampler state flavor"); break; @@ -2925,7 +3057,8 @@ void GLSLSourceEmitter::emitSimpleTypeImpl(IRType* type) emitSimpleTypeImpl(cast<IRAtomicType>(type)->getElementType()); return; } - default: break; + default: + break; } // TODO: Ideally the following should be data-driven, @@ -2946,7 +3079,9 @@ void GLSLSourceEmitter::emitSimpleTypeImpl(IRType* type) _emitGLSLTextureOrTextureSamplerType(texType, "image"); break; - default: _emitGLSLTextureOrTextureSamplerType(texType, "texture"); break; + default: + _emitGLSLTextureOrTextureSamplerType(texType, "texture"); + break; } return; } @@ -2988,7 +3123,9 @@ void GLSLSourceEmitter::emitSimpleTypeImpl(IRType* type) m_writer->emit("accelerationStructureEXT"); break; } - default: SLANG_DIAGNOSE_UNEXPECTED(getSink(), SourceLoc(), "unhandled buffer type"); break; + default: + SLANG_DIAGNOSE_UNEXPECTED(getSink(), SourceLoc(), "unhandled buffer type"); + break; } return; @@ -3031,11 +3168,21 @@ bool GLSLSourceEmitter::_maybeEmitInterpolationModifierText( { switch (mode) { - case IRInterpolationMode::NoInterpolation: m_writer->emit("flat "); return true; - case IRInterpolationMode::NoPerspective: m_writer->emit("noperspective "); return true; - case IRInterpolationMode::Linear: m_writer->emit("smooth "); return true; - case IRInterpolationMode::Sample: m_writer->emit("sample "); return true; - case IRInterpolationMode::Centroid: m_writer->emit("centroid "); return true; + case IRInterpolationMode::NoInterpolation: + m_writer->emit("flat "); + return true; + case IRInterpolationMode::NoPerspective: + m_writer->emit("noperspective "); + return true; + case IRInterpolationMode::Linear: + m_writer->emit("smooth "); + return true; + case IRInterpolationMode::Sample: + m_writer->emit("sample "); + return true; + case IRInterpolationMode::Centroid: + m_writer->emit("centroid "); + return true; case IRInterpolationMode::PerVertex: if (stage == Stage::Fragment && isInput) { @@ -3047,7 +3194,8 @@ bool GLSLSourceEmitter::_maybeEmitInterpolationModifierText( m_writer->emit("flat "); } return true; - default: return false; + default: + return false; } } @@ -3078,7 +3226,8 @@ void GLSLSourceEmitter::emitInterpolationModifiersImpl( switch (decoration->getMode()) { - default: break; + default: + break; case IRInterpolationMode::PerVertex: if (stage == Stage::Fragment) @@ -3188,7 +3337,8 @@ void GLSLSourceEmitter::emitVarDecorationsImpl(IRInst* varDecl) postfix = toSlice("NV"); locationValue = getIntVal(decoration->getOperand(0)); break; - default: continue; + default: + continue; } m_writer->emit(toSlice("layout(location = ")); m_writer->emit(locationValue); @@ -3222,9 +3372,13 @@ void GLSLSourceEmitter::emitMatrixLayoutModifiersImpl(IRType* varType) // switch (getIntVal(matrixType->getLayout())) { - case SLANG_MATRIX_LAYOUT_COLUMN_MAJOR: m_writer->emit("layout(row_major)\n"); break; + case SLANG_MATRIX_LAYOUT_COLUMN_MAJOR: + m_writer->emit("layout(row_major)\n"); + break; - case SLANG_MATRIX_LAYOUT_ROW_MAJOR: m_writer->emit("layout(column_major)\n"); break; + case SLANG_MATRIX_LAYOUT_ROW_MAJOR: + m_writer->emit("layout(column_major)\n"); + break; } } } diff --git a/source/slang/slang-emit-hlsl.cpp b/source/slang/slang-emit-hlsl.cpp index 49ccc3c65..26d37d1f5 100644 --- a/source/slang/slang-emit-hlsl.cpp +++ b/source/slang/slang-emit-hlsl.cpp @@ -132,10 +132,18 @@ void HLSLSourceEmitter::_emitHLSLRegisterSemantic( m_writer->emit(" : register("); switch (kind) { - case LayoutResourceKind::ConstantBuffer: m_writer->emit("b"); break; - case LayoutResourceKind::ShaderResource: m_writer->emit("t"); break; - case LayoutResourceKind::UnorderedAccess: m_writer->emit("u"); break; - case LayoutResourceKind::SamplerState: m_writer->emit("s"); break; + case LayoutResourceKind::ConstantBuffer: + m_writer->emit("b"); + break; + case LayoutResourceKind::ShaderResource: + m_writer->emit("t"); + break; + case LayoutResourceKind::UnorderedAccess: + m_writer->emit("u"); + break; + case LayoutResourceKind::SamplerState: + m_writer->emit("s"); + break; default: SLANG_DIAGNOSE_UNEXPECTED(getSink(), SourceLoc(), "unhandled HLSL register type"); break; @@ -164,9 +172,11 @@ void HLSLSourceEmitter::_emitHLSLRegisterSemantics( switch (getSourceLanguage()) { - default: return; + default: + return; - case SourceLanguage::HLSL: break; + case SourceLanguage::HLSL: + break; } for (auto rr : layout->getOffsetAttrs()) @@ -274,19 +284,32 @@ void HLSLSourceEmitter::_emitHLSLTextureType(IRTextureTypeBase* texType) { switch (texType->getAccess()) { - case SLANG_RESOURCE_ACCESS_READ: break; + case SLANG_RESOURCE_ACCESS_READ: + break; - case SLANG_RESOURCE_ACCESS_READ_WRITE: m_writer->emit("RW"); break; + case SLANG_RESOURCE_ACCESS_READ_WRITE: + m_writer->emit("RW"); + break; - case SLANG_RESOURCE_ACCESS_WRITE: m_writer->emit("RW"); break; + case SLANG_RESOURCE_ACCESS_WRITE: + m_writer->emit("RW"); + break; - case SLANG_RESOURCE_ACCESS_RASTER_ORDERED: m_writer->emit("RasterizerOrdered"); break; + case SLANG_RESOURCE_ACCESS_RASTER_ORDERED: + m_writer->emit("RasterizerOrdered"); + break; - case SLANG_RESOURCE_ACCESS_APPEND: m_writer->emit("Append"); break; + case SLANG_RESOURCE_ACCESS_APPEND: + m_writer->emit("Append"); + break; - case SLANG_RESOURCE_ACCESS_CONSUME: m_writer->emit("Consume"); break; + case SLANG_RESOURCE_ACCESS_CONSUME: + m_writer->emit("Consume"); + break; - case SLANG_RESOURCE_ACCESS_FEEDBACK: m_writer->emit("Feedback"); break; + case SLANG_RESOURCE_ACCESS_FEEDBACK: + m_writer->emit("Feedback"); + break; default: SLANG_DIAGNOSE_UNEXPECTED(getSink(), SourceLoc(), "unhandled resource access mode"); @@ -295,12 +318,24 @@ void HLSLSourceEmitter::_emitHLSLTextureType(IRTextureTypeBase* texType) switch (texType->GetBaseShape()) { - case SLANG_TEXTURE_1D: m_writer->emit("Texture1D"); break; - case SLANG_TEXTURE_2D: m_writer->emit("Texture2D"); break; - case SLANG_TEXTURE_3D: m_writer->emit("Texture3D"); break; - case SLANG_TEXTURE_CUBE: m_writer->emit("TextureCube"); break; - case SLANG_TEXTURE_BUFFER: m_writer->emit("Buffer"); break; - default: SLANG_DIAGNOSE_UNEXPECTED(getSink(), SourceLoc(), "unhandled resource shape"); break; + case SLANG_TEXTURE_1D: + m_writer->emit("Texture1D"); + break; + case SLANG_TEXTURE_2D: + m_writer->emit("Texture2D"); + break; + case SLANG_TEXTURE_3D: + m_writer->emit("Texture3D"); + break; + case SLANG_TEXTURE_CUBE: + m_writer->emit("TextureCube"); + break; + case SLANG_TEXTURE_BUFFER: + m_writer->emit("Buffer"); + break; + default: + SLANG_DIAGNOSE_UNEXPECTED(getSink(), SourceLoc(), "unhandled resource shape"); + break; } if (texType->isMultisample()) @@ -506,7 +541,8 @@ void HLSLSourceEmitter::emitEntryPointAttributesImpl( break; } // TODO: There are other stages that will need this kind of handling. - default: break; + default: + break; } } @@ -698,7 +734,8 @@ bool HLSLSourceEmitter::tryEmitInstStmtImpl(IRInst* inst) m_writer->emit(");"); return true; } - default: return false; + default: + return false; } } @@ -753,7 +790,9 @@ bool HLSLSourceEmitter::tryEmitInstExprImpl(IRInst* inst, const EmitOpInfo& inOu auto toType = extractBaseType(inst->getDataType()); switch (toType) { - default: diagnoseUnhandledInst(inst); break; + default: + diagnoseUnhandledInst(inst); + break; case BaseType::Int8: case BaseType::Int16: @@ -774,7 +813,9 @@ bool HLSLSourceEmitter::tryEmitInstExprImpl(IRInst* inst, const EmitOpInfo& inOu emitType(inst->getDataType()); m_writer->emit(")"); break; - case BaseType::Half: m_writer->emit("asfloat16"); break; + case BaseType::Half: + m_writer->emit("asfloat16"); + break; case BaseType::Float: // Note: at present HLSL only supports // reinterpreting integer bits as a `float`. @@ -799,13 +840,17 @@ bool HLSLSourceEmitter::tryEmitInstExprImpl(IRInst* inst, const EmitOpInfo& inOu auto fromType = extractBaseType(inst->getOperand(0)->getDataType()); switch (fromType) { - default: diagnoseUnhandledInst(inst); break; + default: + diagnoseUnhandledInst(inst); + break; case BaseType::UInt: case BaseType::Int: - case BaseType::Bool: break; + case BaseType::Bool: + break; case BaseType::UInt16: - case BaseType::Int16: break; + case BaseType::Int16: + break; case BaseType::Float: m_writer->emit("asuint("); closeCount++; @@ -955,7 +1000,8 @@ bool HLSLSourceEmitter::tryEmitInstExprImpl(IRInst* inst, const EmitOpInfo& inOu return true; } break; - default: break; + default: + break; } // Not handled return false; @@ -978,7 +1024,8 @@ void HLSLSourceEmitter::emitVectorTypeNameImpl(IRType* elementType, IRIntegerVal m_writer->emit(elementCount); return; - default: break; + default: + break; } } @@ -997,9 +1044,14 @@ void HLSLSourceEmitter::emitLoopControlDecorationImpl(IRLoopControlDecoration* d { switch (decl->getMode()) { - case kIRLoopControl_Unroll: m_writer->emit("[unroll]\n"); break; - case kIRLoopControl_Loop: m_writer->emit("[loop]\n"); break; - default: break; + case kIRLoopControl_Unroll: + m_writer->emit("[unroll]\n"); + break; + case kIRLoopControl_Loop: + m_writer->emit("[loop]\n"); + break; + default: + break; } } @@ -1057,9 +1109,12 @@ void HLSLSourceEmitter::emitFuncDecorationImpl(IRDecoration* decoration) { switch (decoration->getOp()) { - case kIROp_NoInlineDecoration: m_writer->emit("[noinline]\n"); break; + case kIROp_NoInlineDecoration: + m_writer->emit("[noinline]\n"); + break; - default: break; + default: + break; } } @@ -1089,12 +1144,14 @@ void HLSLSourceEmitter::emitSimpleValueImpl(IRInst* inst) m_writer->emit("(-1.0 / 0.0)"); return; } - default: break; + default: + break; } break; } - default: break; + default: + break; } Super::emitSimpleValueImpl(inst); @@ -1122,13 +1179,23 @@ void HLSLSourceEmitter::emitSimpleTypeImpl(IRType* type) return; } #if SLANG_PTR_IS_64 - case kIROp_IntPtrType: m_writer->emit("int64_t"); return; - case kIROp_UIntPtrType: m_writer->emit("uint64_t"); return; + case kIROp_IntPtrType: + m_writer->emit("int64_t"); + return; + case kIROp_UIntPtrType: + m_writer->emit("uint64_t"); + return; #else - case kIROp_IntPtrType: m_writer->emit("int"); return; - case kIROp_UIntPtrType: m_writer->emit("uint"); return; + case kIROp_IntPtrType: + m_writer->emit("int"); + return; + case kIROp_UIntPtrType: + m_writer->emit("uint"); + return; #endif - case kIROp_StructType: m_writer->emit(getName(type)); return; + case kIROp_StructType: + m_writer->emit(getName(type)); + return; case kIROp_VectorType: { @@ -1146,8 +1213,12 @@ void HLSLSourceEmitter::emitSimpleTypeImpl(IRType* type) { case kIROp_IntType: case kIROp_UIntType: - case kIROp_FloatType: canUseSugar = true; break; - default: canUseSugar = false; break; + case kIROp_FloatType: + canUseSugar = true; + break; + default: + canUseSugar = false; + break; } if (!as<IRIntLit>(matType->getRowCount()) || !as<IRIntLit>(matType->getColumnCount())) canUseSugar = false; @@ -1177,8 +1248,12 @@ void HLSLSourceEmitter::emitSimpleTypeImpl(IRType* type) switch (samplerStateType->getOp()) { - case kIROp_SamplerStateType: m_writer->emit("SamplerState"); break; - case kIROp_SamplerComparisonStateType: m_writer->emit("SamplerComparisonState"); break; + case kIROp_SamplerStateType: + m_writer->emit("SamplerState"); + break; + case kIROp_SamplerComparisonStateType: + m_writer->emit("SamplerComparisonState"); + break; default: SLANG_DIAGNOSE_UNEXPECTED(getSink(), SourceLoc(), "unhandled sampler state flavor"); break; @@ -1213,7 +1288,8 @@ void HLSLSourceEmitter::emitSimpleTypeImpl(IRType* type) emitSimpleTypeImpl(cast<IRAtomicType>(type)->getElementType()); return; } - default: break; + default: + break; } // TODO: Ideally the following should be data-driven, @@ -1238,12 +1314,18 @@ void HLSLSourceEmitter::emitSimpleTypeImpl(IRType* type) { switch (structuredBufferType->getOp()) { - case kIROp_HLSLStructuredBufferType: m_writer->emit("StructuredBuffer"); break; - case kIROp_HLSLRWStructuredBufferType: m_writer->emit("RWStructuredBuffer"); break; + case kIROp_HLSLStructuredBufferType: + m_writer->emit("StructuredBuffer"); + break; + case kIROp_HLSLRWStructuredBufferType: + m_writer->emit("RWStructuredBuffer"); + break; case kIROp_HLSLRasterizerOrderedStructuredBufferType: m_writer->emit("RasterizerOrderedStructuredBuffer"); break; - case kIROp_HLSLAppendStructuredBufferType: m_writer->emit("AppendStructuredBuffer"); break; + case kIROp_HLSLAppendStructuredBufferType: + m_writer->emit("AppendStructuredBuffer"); + break; case kIROp_HLSLConsumeStructuredBufferType: m_writer->emit("ConsumeStructuredBuffer"); break; @@ -1263,15 +1345,21 @@ void HLSLSourceEmitter::emitSimpleTypeImpl(IRType* type) { switch (type->getOp()) { - case kIROp_HLSLByteAddressBufferType: m_writer->emit("ByteAddressBuffer"); break; - case kIROp_HLSLRWByteAddressBufferType: m_writer->emit("RWByteAddressBuffer"); break; + case kIROp_HLSLByteAddressBufferType: + m_writer->emit("ByteAddressBuffer"); + break; + case kIROp_HLSLRWByteAddressBufferType: + m_writer->emit("RWByteAddressBuffer"); + break; case kIROp_HLSLRasterizerOrderedByteAddressBufferType: m_writer->emit("RasterizerOrderedByteAddressBuffer"); break; case kIROp_RaytracingAccelerationStructureType: m_writer->emit("RaytracingAccelerationStructure"); break; - default: SLANG_DIAGNOSE_UNEXPECTED(getSink(), SourceLoc(), "unhandled buffer type"); break; + default: + SLANG_DIAGNOSE_UNEXPECTED(getSink(), SourceLoc(), "unhandled buffer type"); + break; } return; @@ -1342,10 +1430,17 @@ void HLSLSourceEmitter::emitSemanticsImpl(IRInst* inst, bool allowOffsets) { switch (packOffsetDecoration->getComponentOffset()->getValue()) { - case 0: break; - case 1: m_writer->emit(".y"); break; - case 2: m_writer->emit(".z"); break; - case 3: m_writer->emit(".w"); break; + case 0: + break; + case 1: + m_writer->emit(".y"); + break; + case 2: + m_writer->emit(".z"); + break; + case 3: + m_writer->emit(".w"); + break; } } m_writer->emit(")"); @@ -1407,10 +1502,16 @@ void HLSLSourceEmitter::_emitPrefixTypeAttr(IRAttr* attr) { switch (attr->getOp()) { - default: Super::_emitPrefixTypeAttr(attr); break; + default: + Super::_emitPrefixTypeAttr(attr); + break; - case kIROp_UNormAttr: m_writer->emit("unorm "); break; - case kIROp_SNormAttr: m_writer->emit("snorm "); break; + case kIROp_UNormAttr: + m_writer->emit("unorm "); + break; + case kIROp_SNormAttr: + m_writer->emit("snorm "); + break; } } @@ -1426,12 +1527,24 @@ void HLSLSourceEmitter::emitSimpleFuncParamImpl(IRParam* param) { switch (decor->getOp()) { - case kIROp_TriangleInputPrimitiveTypeDecoration: m_writer->emit("triangle "); break; - case kIROp_PointInputPrimitiveTypeDecoration: m_writer->emit("point "); break; - case kIROp_LineInputPrimitiveTypeDecoration: m_writer->emit("line "); break; - case kIROp_LineAdjInputPrimitiveTypeDecoration: m_writer->emit("lineadj "); break; - case kIROp_TriangleAdjInputPrimitiveTypeDecoration: m_writer->emit("triangleadj "); break; - default: SLANG_ASSERT(!"Unknown primitive type"); break; + case kIROp_TriangleInputPrimitiveTypeDecoration: + m_writer->emit("triangle "); + break; + case kIROp_PointInputPrimitiveTypeDecoration: + m_writer->emit("point "); + break; + case kIROp_LineInputPrimitiveTypeDecoration: + m_writer->emit("line "); + break; + case kIROp_LineAdjInputPrimitiveTypeDecoration: + m_writer->emit("lineadj "); + break; + case kIROp_TriangleAdjInputPrimitiveTypeDecoration: + m_writer->emit("triangleadj "); + break; + default: + SLANG_ASSERT(!"Unknown primitive type"); + break; } } @@ -1447,10 +1560,14 @@ static UnownedStringSlice _getInterpolationModifierText(IRInterpolationMode mode return UnownedStringSlice::fromLiteral("nointerpolation"); case IRInterpolationMode::NoPerspective: return UnownedStringSlice::fromLiteral("noperspective"); - case IRInterpolationMode::Linear: return UnownedStringSlice::fromLiteral("linear"); - case IRInterpolationMode::Sample: return UnownedStringSlice::fromLiteral("sample"); - case IRInterpolationMode::Centroid: return UnownedStringSlice::fromLiteral("centroid"); - default: return UnownedStringSlice(); + case IRInterpolationMode::Linear: + return UnownedStringSlice::fromLiteral("linear"); + case IRInterpolationMode::Sample: + return UnownedStringSlice::fromLiteral("sample"); + case IRInterpolationMode::Centroid: + return UnownedStringSlice::fromLiteral("centroid"); + default: + return UnownedStringSlice(); } } @@ -1532,9 +1649,14 @@ void HLSLSourceEmitter::emitMatrixLayoutModifiersImpl(IRType* type) { switch (matrixLayout) { - case SLANG_MATRIX_LAYOUT_COLUMN_MAJOR: m_writer->emit("column_major "); break; - case SLANG_MATRIX_LAYOUT_ROW_MAJOR: m_writer->emit("row_major "); break; - default: break; + case SLANG_MATRIX_LAYOUT_COLUMN_MAJOR: + m_writer->emit("column_major "); + break; + case SLANG_MATRIX_LAYOUT_ROW_MAJOR: + m_writer->emit("row_major "); + break; + default: + break; } } } @@ -1604,7 +1726,9 @@ void HLSLSourceEmitter::emitFrontMatterImpl(TargetRequest*) switch (getTargetProgram()->getOptionSet().getMatrixLayoutMode()) { case kMatrixLayoutMode_RowMajor: - default: m_writer->emit("#pragma pack_matrix(row_major)\n"); break; + default: + m_writer->emit("#pragma pack_matrix(row_major)\n"); + break; case kMatrixLayoutMode_ColumnMajor: m_writer->emit("#pragma pack_matrix(column_major)\n"); break; diff --git a/source/slang/slang-emit-metal.cpp b/source/slang/slang-emit-metal.cpp index b4d682e86..3548e9369 100644 --- a/source/slang/slang-emit-metal.cpp +++ b/source/slang/slang-emit-metal.cpp @@ -101,12 +101,24 @@ void MetalSourceEmitter::_emitHLSLTextureType(IRTextureTypeBase* texType) switch (texType->GetBaseShape()) { - case SLANG_TEXTURE_1D: m_writer->emit("1d"); break; - case SLANG_TEXTURE_2D: m_writer->emit("2d"); break; - case SLANG_TEXTURE_3D: m_writer->emit("3d"); break; - case SLANG_TEXTURE_CUBE: m_writer->emit("cube"); break; - case SLANG_TEXTURE_BUFFER: m_writer->emit("_buffer"); break; - default: SLANG_DIAGNOSE_UNEXPECTED(getSink(), SourceLoc(), "unhandled resource shape"); break; + case SLANG_TEXTURE_1D: + m_writer->emit("1d"); + break; + case SLANG_TEXTURE_2D: + m_writer->emit("2d"); + break; + case SLANG_TEXTURE_3D: + m_writer->emit("3d"); + break; + case SLANG_TEXTURE_CUBE: + m_writer->emit("cube"); + break; + case SLANG_TEXTURE_BUFFER: + m_writer->emit("_buffer"); + break; + default: + SLANG_DIAGNOSE_UNEXPECTED(getSink(), SourceLoc(), "unhandled resource shape"); + break; } if (texType->isMultisample()) @@ -123,15 +135,21 @@ void MetalSourceEmitter::_emitHLSLTextureType(IRTextureTypeBase* texType) switch (texType->getAccess()) { - case SLANG_RESOURCE_ACCESS_READ: m_writer->emit("access::sample"); break; + case SLANG_RESOURCE_ACCESS_READ: + m_writer->emit("access::sample"); + break; - case SLANG_RESOURCE_ACCESS_WRITE: m_writer->emit("access::write"); break; + case SLANG_RESOURCE_ACCESS_WRITE: + m_writer->emit("access::write"); + break; case SLANG_RESOURCE_ACCESS_READ_WRITE: case SLANG_RESOURCE_ACCESS_APPEND: case SLANG_RESOURCE_ACCESS_CONSUME: case SLANG_RESOURCE_ACCESS_FEEDBACK: - case SLANG_RESOURCE_ACCESS_RASTER_ORDERED: m_writer->emit("access::read_write"); break; + case SLANG_RESOURCE_ACCESS_RASTER_ORDERED: + m_writer->emit("access::read_write"); + break; default: SLANG_DIAGNOSE_UNEXPECTED(getSink(), SourceLoc(), "unhandled resource access mode"); break; @@ -181,8 +199,12 @@ void MetalSourceEmitter::emitFuncParamLayoutImpl(IRInst* param) m_writer->emit(")]]"); } break; - case LayoutResourceKind::VaryingInput: m_writer->emit(" [[stage_in]]"); break; - case LayoutResourceKind::MetalPayload: m_writer->emit(" [[payload]]"); break; + case LayoutResourceKind::VaryingInput: + m_writer->emit(" [[stage_in]]"); + break; + case LayoutResourceKind::MetalPayload: + m_writer->emit(" [[payload]]"); + break; } } if (!maybeEmitSystemSemantic(param)) @@ -207,12 +229,23 @@ void MetalSourceEmitter::emitEntryPointAttributesImpl( switch (stage) { - case Stage::Fragment: m_writer->emit("[[fragment]] "); break; - case Stage::Vertex: m_writer->emit("[[vertex]] "); break; - case Stage::Compute: m_writer->emit("[[kernel]] "); break; - case Stage::Mesh: m_writer->emit("[[mesh]] "); break; - case Stage::Amplification: m_writer->emit("[[object]] "); break; - default: SLANG_ABORT_COMPILATION("unsupported stage."); + case Stage::Fragment: + m_writer->emit("[[fragment]] "); + break; + case Stage::Vertex: + m_writer->emit("[[vertex]] "); + break; + case Stage::Compute: + m_writer->emit("[[kernel]] "); + break; + case Stage::Mesh: + m_writer->emit("[[mesh]] "); + break; + case Stage::Amplification: + m_writer->emit("[[object]] "); + break; + default: + SLANG_ABORT_COMPILATION("unsupported stage."); } switch (stage) @@ -225,7 +258,8 @@ void MetalSourceEmitter::emitEntryPointAttributesImpl( } break; } - default: break; + default: + break; } } @@ -246,8 +280,12 @@ void MetalSourceEmitter::emitMemoryOrderOperand(IRInst* inst) auto memoryOrder = (IRMemoryOrder)getIntVal(inst); switch (memoryOrder) { - case kIRMemoryOrder_Relaxed: m_writer->emit("memory_order_relaxed"); break; - default: m_writer->emit("memory_order_seq_cst"); break; + case kIRMemoryOrder_Relaxed: + m_writer->emit("memory_order_relaxed"); + break; + default: + m_writer->emit("memory_order_seq_cst"); + break; } } @@ -375,7 +413,9 @@ bool MetalSourceEmitter::tryEmitInstStmtImpl(IRInst* inst) }; switch (inst->getOp()) { - case kIROp_discard: m_writer->emit("discard_fragment();\n"); return true; + case kIROp_discard: + m_writer->emit("discard_fragment();\n"); + return true; case kIROp_MetalAtomicCast: { auto oldValName = getName(inst); @@ -870,7 +910,8 @@ bool MetalSourceEmitter::tryEmitInstExprImpl(IRInst* inst, const EmitOpInfo& inO } return true; } - default: break; + default: + break; } // Not handled return false; @@ -980,12 +1021,14 @@ void MetalSourceEmitter::emitSimpleValueImpl(IRInst* inst) m_writer->emit("(-1.0 / 0.0)"); return; } - default: break; + default: + break; } break; } - default: break; + default: + break; } Super::emitSimpleValueImpl(inst); @@ -1013,13 +1056,27 @@ void MetalSourceEmitter::emitSimpleTypeImpl(IRType* type) m_writer->emit(getDefaultBuiltinTypeName(type->getOp())); return; } - case kIROp_Int64Type: m_writer->emit("long"); return; - case kIROp_UInt64Type: m_writer->emit("ulong"); return; - case kIROp_Int16Type: m_writer->emit("short"); return; - case kIROp_UInt16Type: m_writer->emit("ushort"); return; - case kIROp_IntPtrType: m_writer->emit("long"); return; - case kIROp_UIntPtrType: m_writer->emit("ulong"); return; - case kIROp_StructType: m_writer->emit(getName(type)); return; + case kIROp_Int64Type: + m_writer->emit("long"); + return; + case kIROp_UInt64Type: + m_writer->emit("ulong"); + return; + case kIROp_Int16Type: + m_writer->emit("short"); + return; + case kIROp_UInt16Type: + m_writer->emit("ushort"); + return; + case kIROp_IntPtrType: + m_writer->emit("long"); + return; + case kIROp_UIntPtrType: + m_writer->emit("ulong"); + return; + case kIROp_StructType: + m_writer->emit(getName(type)); + return; case kIROp_VectorType: { @@ -1120,7 +1177,8 @@ void MetalSourceEmitter::emitSimpleTypeImpl(IRType* type) m_writer->emit(">"); return; } - default: break; + default: + break; } if (auto texType = as<IRTextureType>(type)) @@ -1158,7 +1216,9 @@ void MetalSourceEmitter::emitSimpleTypeImpl(IRType* type) case kIROp_RaytracingAccelerationStructureType: m_writer->emit("acceleration_structure<instancing>"); break; - default: SLANG_DIAGNOSE_UNEXPECTED(getSink(), SourceLoc(), "unhandled buffer type"); break; + default: + SLANG_DIAGNOSE_UNEXPECTED(getSink(), SourceLoc(), "unhandled buffer type"); + break; } return; } @@ -1175,9 +1235,15 @@ void MetalSourceEmitter::emitSimpleTypeImpl(IRType* type) m_writer->emit(", metal::topology::"); switch (meshType->getTopology()->getValue()) { - case 1: m_writer->emit("point"); break; - case 2: m_writer->emit("line"); break; - case 3: m_writer->emit("triangle"); break; + case 1: + m_writer->emit("point"); + break; + case 2: + m_writer->emit("line"); + break; + case 3: + m_writer->emit("triangle"); + break; } m_writer->emit(">"); return; @@ -1228,7 +1294,9 @@ void MetalSourceEmitter::_emitType(IRType* type, DeclaratorInfo* declarator) emitSimpleType(type); emitDeclarator(declarator); break; - default: Super::_emitType(type, declarator); break; + default: + Super::_emitType(type, declarator); + break; } } @@ -1350,7 +1418,8 @@ static UnownedStringSlice _getInterpolationModifierText(IRInterpolationMode mode switch (mode) { case IRInterpolationMode::PerVertex: - case IRInterpolationMode::NoInterpolation: return UnownedStringSlice::fromLiteral("[[flat]]"); + case IRInterpolationMode::NoInterpolation: + return UnownedStringSlice::fromLiteral("[[flat]]"); case IRInterpolationMode::NoPerspective: return UnownedStringSlice::fromLiteral("[[center_no_perspective]]"); case IRInterpolationMode::Linear: @@ -1359,7 +1428,8 @@ static UnownedStringSlice _getInterpolationModifierText(IRInterpolationMode mode return UnownedStringSlice::fromLiteral("[[sample_perspective]]"); case IRInterpolationMode::Centroid: return UnownedStringSlice::fromLiteral("[[center_perspective]]"); - default: return UnownedStringSlice(); + default: + return UnownedStringSlice(); } } @@ -1410,12 +1480,23 @@ void MetalSourceEmitter::emitRateQualifiersAndAddressSpaceImpl( switch (addressSpace) { - case AddressSpace::GroupShared: m_writer->emit("threadgroup "); break; - case AddressSpace::Uniform: m_writer->emit("constant "); break; - case AddressSpace::Global: m_writer->emit("device "); break; - case AddressSpace::ThreadLocal: m_writer->emit("thread "); break; - case AddressSpace::MetalObjectData: m_writer->emit("object_data "); break; - default: break; + case AddressSpace::GroupShared: + m_writer->emit("threadgroup "); + break; + case AddressSpace::Uniform: + m_writer->emit("constant "); + break; + case AddressSpace::Global: + m_writer->emit("device "); + break; + case AddressSpace::ThreadLocal: + m_writer->emit("thread "); + break; + case AddressSpace::MetalObjectData: + m_writer->emit("object_data "); + break; + default: + break; } } diff --git a/source/slang/slang-emit-precedence.cpp b/source/slang/slang-emit-precedence.cpp index b5270b812..989b669fc 100644 --- a/source/slang/slang-emit-precedence.cpp +++ b/source/slang/slang-emit-precedence.cpp @@ -19,33 +19,55 @@ EmitOp getEmitOpForOp(IROp op) { switch (op) { - case kIROp_Add: return EmitOp::Add; - case kIROp_Sub: return EmitOp::Sub; - case kIROp_Mul: return EmitOp::Mul; - case kIROp_Div: return EmitOp::Div; - case kIROp_IRem: return EmitOp::Rem; - case kIROp_FRem: return EmitOp::Rem; - - case kIROp_Lsh: return EmitOp::Lsh; - case kIROp_Rsh: return EmitOp::Rsh; - - case kIROp_Eql: return EmitOp::Eql; - case kIROp_Neq: return EmitOp::Neq; - case kIROp_Greater: return EmitOp::Greater; - case kIROp_Less: return EmitOp::Less; - case kIROp_Geq: return EmitOp::Geq; - case kIROp_Leq: return EmitOp::Leq; - - case kIROp_BitXor: return EmitOp::BitXor; - case kIROp_BitOr: return EmitOp::BitOr; - case kIROp_BitAnd: return EmitOp::BitAnd; - - case kIROp_And: return EmitOp::And; - case kIROp_Or: return EmitOp::Or; - - case kIROp_Not: return EmitOp::Not; - case kIROp_Neg: return EmitOp::Neg; - case kIROp_BitNot: return EmitOp::BitNot; + case kIROp_Add: + return EmitOp::Add; + case kIROp_Sub: + return EmitOp::Sub; + case kIROp_Mul: + return EmitOp::Mul; + case kIROp_Div: + return EmitOp::Div; + case kIROp_IRem: + return EmitOp::Rem; + case kIROp_FRem: + return EmitOp::Rem; + + case kIROp_Lsh: + return EmitOp::Lsh; + case kIROp_Rsh: + return EmitOp::Rsh; + + case kIROp_Eql: + return EmitOp::Eql; + case kIROp_Neq: + return EmitOp::Neq; + case kIROp_Greater: + return EmitOp::Greater; + case kIROp_Less: + return EmitOp::Less; + case kIROp_Geq: + return EmitOp::Geq; + case kIROp_Leq: + return EmitOp::Leq; + + case kIROp_BitXor: + return EmitOp::BitXor; + case kIROp_BitOr: + return EmitOp::BitOr; + case kIROp_BitAnd: + return EmitOp::BitAnd; + + case kIROp_And: + return EmitOp::And; + case kIROp_Or: + return EmitOp::Or; + + case kIROp_Not: + return EmitOp::Not; + case kIROp_Neg: + return EmitOp::Neg; + case kIROp_BitNot: + return EmitOp::BitNot; } return EmitOp::None; diff --git a/source/slang/slang-emit-source-writer.cpp b/source/slang/slang-emit-source-writer.cpp index 016da0417..c4cc3d406 100644 --- a/source/slang/slang-emit-source-writer.cpp +++ b/source/slang/slang-emit-source-writer.cpp @@ -420,10 +420,12 @@ void SourceWriter::_emitLineDirectiveIfNeeded(const HumaneSourceLoc& sourceLocat switch (mode) { case LineDirectiveMode::SourceMap: - case LineDirectiveMode::None: return; + case LineDirectiveMode::None: + return; case LineDirectiveMode::Default: - default: break; + default: + break; } // Ignore invalid source locations @@ -533,7 +535,9 @@ void SourceWriter::_emitLineDirective(const HumaneSourceLoc& sourceLocation) // // TODO: should probably canonicalize paths to not use backslash // somewhere else in the compilation pipeline... - case '\\': emitRawText("/"); break; + case '\\': + emitRawText("/"); + break; } } emitRawText("\""); diff --git a/source/slang/slang-emit-spirv.cpp b/source/slang/slang-emit-spirv.cpp index 30c03e98c..04ddee990 100644 --- a/source/slang/slang-emit-spirv.cpp +++ b/source/slang/slang-emit-spirv.cpp @@ -1270,30 +1270,50 @@ struct SPIRVEmitContext : public SourceEmitterBase, public SPIRVEmitSharedContex SLANG_EXHAUSTIVE_SWITCH_BEGIN switch (addrSpace) { - case AddressSpace::Generic: return SpvStorageClassMax; - case AddressSpace::ThreadLocal: return SpvStorageClassPrivate; - case AddressSpace::GroupShared: return SpvStorageClassWorkgroup; - case AddressSpace::Uniform: return SpvStorageClassUniform; - case AddressSpace::Input: return SpvStorageClassInput; - case AddressSpace::Output: return SpvStorageClassOutput; - case AddressSpace::TaskPayloadWorkgroup: return SpvStorageClassTaskPayloadWorkgroupEXT; - case AddressSpace::Function: return SpvStorageClassFunction; - case AddressSpace::StorageBuffer: return SpvStorageClassStorageBuffer; - case AddressSpace::PushConstant: return SpvStorageClassPushConstant; - case AddressSpace::RayPayloadKHR: return SpvStorageClassRayPayloadKHR; - case AddressSpace::IncomingRayPayload: return SpvStorageClassIncomingRayPayloadKHR; - case AddressSpace::CallableDataKHR: return SpvStorageClassCallableDataKHR; - case AddressSpace::IncomingCallableData: return SpvStorageClassIncomingCallableDataKHR; - case AddressSpace::HitObjectAttribute: return SpvStorageClassHitObjectAttributeNV; - case AddressSpace::HitAttribute: return SpvStorageClassHitAttributeKHR; - case AddressSpace::ShaderRecordBuffer: return SpvStorageClassShaderRecordBufferKHR; - case AddressSpace::UniformConstant: return SpvStorageClassUniformConstant; - case AddressSpace::Image: return SpvStorageClassImage; - case AddressSpace::UserPointer: return SpvStorageClassPhysicalStorageBuffer; + case AddressSpace::Generic: + return SpvStorageClassMax; + case AddressSpace::ThreadLocal: + return SpvStorageClassPrivate; + case AddressSpace::GroupShared: + return SpvStorageClassWorkgroup; + case AddressSpace::Uniform: + return SpvStorageClassUniform; + case AddressSpace::Input: + return SpvStorageClassInput; + case AddressSpace::Output: + return SpvStorageClassOutput; + case AddressSpace::TaskPayloadWorkgroup: + return SpvStorageClassTaskPayloadWorkgroupEXT; + case AddressSpace::Function: + return SpvStorageClassFunction; + case AddressSpace::StorageBuffer: + return SpvStorageClassStorageBuffer; + case AddressSpace::PushConstant: + return SpvStorageClassPushConstant; + case AddressSpace::RayPayloadKHR: + return SpvStorageClassRayPayloadKHR; + case AddressSpace::IncomingRayPayload: + return SpvStorageClassIncomingRayPayloadKHR; + case AddressSpace::CallableDataKHR: + return SpvStorageClassCallableDataKHR; + case AddressSpace::IncomingCallableData: + return SpvStorageClassIncomingCallableDataKHR; + case AddressSpace::HitObjectAttribute: + return SpvStorageClassHitObjectAttributeNV; + case AddressSpace::HitAttribute: + return SpvStorageClassHitAttributeKHR; + case AddressSpace::ShaderRecordBuffer: + return SpvStorageClassShaderRecordBufferKHR; + case AddressSpace::UniformConstant: + return SpvStorageClassUniformConstant; + case AddressSpace::Image: + return SpvStorageClassImage; + case AddressSpace::UserPointer: + return SpvStorageClassPhysicalStorageBuffer; case AddressSpace::Global: case AddressSpace::MetalObjectData: case AddressSpace::SpecializationConstant: - // msvc is limiting us from putting the UNEXPECTED macro here, so + // msvc is limiting us from putting the UNEXPECTED macro here, so // just fall out ; } @@ -1428,7 +1448,8 @@ struct SPIRVEmitContext : public SourceEmitterBase, public SPIRVEmitSharedContex // [3.32.6: Type-Declaration Instructions] // - case kIROp_VoidType: return emitOpTypeVoid(inst); + case kIROp_VoidType: + return emitOpTypeVoid(inst); case kIROp_BoolType: return emitOpTypeBool(inst); @@ -1646,9 +1667,11 @@ struct SPIRVEmitContext : public SourceEmitterBase, public SPIRVEmitSharedContex } case kIROp_SubpassInputType: return ensureSubpassInputType(inst, cast<IRSubpassInputType>(inst)); - case kIROp_TextureType: return ensureTextureType(inst, cast<IRTextureType>(inst)); + case kIROp_TextureType: + return ensureTextureType(inst, cast<IRTextureType>(inst)); case kIROp_SamplerStateType: - case kIROp_SamplerComparisonStateType: return emitOpTypeSampler(inst); + case kIROp_SamplerComparisonStateType: + return emitOpTypeSampler(inst); case kIROp_RaytracingAccelerationStructureType: requireSPIRVCapability(SpvCapabilityRayTracingKHR); @@ -1737,9 +1760,12 @@ struct SPIRVEmitContext : public SourceEmitterBase, public SPIRVEmitSharedContex return emitMakeMatrixFromScalar( getSection(SpvLogicalSectionID::ConstantsAndTypes), inst); - case kIROp_GlobalParam: return emitGlobalParam(as<IRGlobalParam>(inst)); - case kIROp_GlobalVar: return emitGlobalVar(as<IRGlobalVar>(inst)); - case kIROp_SPIRVAsmOperandBuiltinVar: return emitBuiltinVar(inst); + case kIROp_GlobalParam: + return emitGlobalParam(as<IRGlobalParam>(inst)); + case kIROp_GlobalVar: + return emitGlobalVar(as<IRGlobalVar>(inst)); + case kIROp_SPIRVAsmOperandBuiltinVar: + return emitBuiltinVar(inst); case kIROp_Var: return emitVar(getSection(SpvLogicalSectionID::GlobalVariables), inst); // ... @@ -1828,15 +1854,19 @@ struct SPIRVEmitContext : public SourceEmitterBase, public SPIRVEmitSharedContex } return result; } - case kIROp_GetStringHash: return emitGetStringHash(inst); - case kIROp_AttributedType: return ensureInst(as<IRAttributedType>(inst)->getBaseType()); - case kIROp_AllocateOpaqueHandle: return nullptr; + case kIROp_GetStringHash: + return emitGetStringHash(inst); + case kIROp_AttributedType: + return ensureInst(as<IRAttributedType>(inst)->getBaseType()); + case kIROp_AllocateOpaqueHandle: + return nullptr; case kIROp_HLSLTriangleStreamType: case kIROp_HLSLLineStreamType: case kIROp_HLSLPointStreamType: case kIROp_VerticesType: case kIROp_IndicesType: - case kIROp_PrimitivesType: return nullptr; + case kIROp_PrimitivesType: + return nullptr; default: { if (as<IRSPIRVAsmOperand>(inst)) @@ -1854,49 +1884,92 @@ struct SPIRVEmitContext : public SourceEmitterBase, public SPIRVEmitSharedContex type->hasFormat() ? (ImageFormat)type->getFormat() : ImageFormat::unknown; switch (imageFormat) { - case ImageFormat::unknown: return SpvImageFormatUnknown; - case ImageFormat::rgba32f: return SpvImageFormatRgba32f; - case ImageFormat::rgba16f: return SpvImageFormatRgba16f; - case ImageFormat::rg32f: return SpvImageFormatRg32f; - case ImageFormat::rg16f: return SpvImageFormatRg16f; - case ImageFormat::r11f_g11f_b10f: return SpvImageFormatR11fG11fB10f; - case ImageFormat::r32f: return SpvImageFormatR32f; - case ImageFormat::r16f: return SpvImageFormatR16f; - case ImageFormat::rgba16: return SpvImageFormatRgba16; - case ImageFormat::rgb10_a2: return SpvImageFormatRgb10A2; - case ImageFormat::rgba8: return SpvImageFormatRgba8; - case ImageFormat::rg16: return SpvImageFormatRg16; - case ImageFormat::rg8: return SpvImageFormatRg8; - case ImageFormat::r16: return SpvImageFormatR16; - case ImageFormat::r8: return SpvImageFormatR8; - case ImageFormat::rgba16_snorm: return SpvImageFormatRgba16Snorm; - case ImageFormat::rgba8_snorm: return SpvImageFormatRgba8Snorm; - case ImageFormat::rg16_snorm: return SpvImageFormatRg16Snorm; - case ImageFormat::rg8_snorm: return SpvImageFormatRg8Snorm; - case ImageFormat::r16_snorm: return SpvImageFormatR16Snorm; - case ImageFormat::r8_snorm: return SpvImageFormatR8Snorm; - case ImageFormat::rgba32i: return SpvImageFormatRgba32i; - case ImageFormat::rgba16i: return SpvImageFormatRgba16i; - case ImageFormat::rgba8i: return SpvImageFormatRgba8i; - case ImageFormat::rg32i: return SpvImageFormatRg32i; - case ImageFormat::rg16i: return SpvImageFormatRg16i; - case ImageFormat::rg8i: return SpvImageFormatRg8i; - case ImageFormat::r32i: return SpvImageFormatR32i; - case ImageFormat::r16i: return SpvImageFormatR16i; - case ImageFormat::r8i: return SpvImageFormatR8i; - case ImageFormat::rgba32ui: return SpvImageFormatRgba32ui; - case ImageFormat::rgba16ui: return SpvImageFormatRgba16ui; - case ImageFormat::rgb10_a2ui: return SpvImageFormatRgb10a2ui; - case ImageFormat::rgba8ui: return SpvImageFormatRgba8ui; - case ImageFormat::rg32ui: return SpvImageFormatRg32ui; - case ImageFormat::rg16ui: return SpvImageFormatRg16ui; - case ImageFormat::rg8ui: return SpvImageFormatRg8ui; - case ImageFormat::r32ui: return SpvImageFormatR32ui; - case ImageFormat::r16ui: return SpvImageFormatR16ui; - case ImageFormat::r8ui: return SpvImageFormatR8ui; - case ImageFormat::r64ui: return SpvImageFormatR64ui; - case ImageFormat::r64i: return SpvImageFormatR64i; - default: SLANG_UNIMPLEMENTED_X("unknown image format for spirv emit"); + case ImageFormat::unknown: + return SpvImageFormatUnknown; + case ImageFormat::rgba32f: + return SpvImageFormatRgba32f; + case ImageFormat::rgba16f: + return SpvImageFormatRgba16f; + case ImageFormat::rg32f: + return SpvImageFormatRg32f; + case ImageFormat::rg16f: + return SpvImageFormatRg16f; + case ImageFormat::r11f_g11f_b10f: + return SpvImageFormatR11fG11fB10f; + case ImageFormat::r32f: + return SpvImageFormatR32f; + case ImageFormat::r16f: + return SpvImageFormatR16f; + case ImageFormat::rgba16: + return SpvImageFormatRgba16; + case ImageFormat::rgb10_a2: + return SpvImageFormatRgb10A2; + case ImageFormat::rgba8: + return SpvImageFormatRgba8; + case ImageFormat::rg16: + return SpvImageFormatRg16; + case ImageFormat::rg8: + return SpvImageFormatRg8; + case ImageFormat::r16: + return SpvImageFormatR16; + case ImageFormat::r8: + return SpvImageFormatR8; + case ImageFormat::rgba16_snorm: + return SpvImageFormatRgba16Snorm; + case ImageFormat::rgba8_snorm: + return SpvImageFormatRgba8Snorm; + case ImageFormat::rg16_snorm: + return SpvImageFormatRg16Snorm; + case ImageFormat::rg8_snorm: + return SpvImageFormatRg8Snorm; + case ImageFormat::r16_snorm: + return SpvImageFormatR16Snorm; + case ImageFormat::r8_snorm: + return SpvImageFormatR8Snorm; + case ImageFormat::rgba32i: + return SpvImageFormatRgba32i; + case ImageFormat::rgba16i: + return SpvImageFormatRgba16i; + case ImageFormat::rgba8i: + return SpvImageFormatRgba8i; + case ImageFormat::rg32i: + return SpvImageFormatRg32i; + case ImageFormat::rg16i: + return SpvImageFormatRg16i; + case ImageFormat::rg8i: + return SpvImageFormatRg8i; + case ImageFormat::r32i: + return SpvImageFormatR32i; + case ImageFormat::r16i: + return SpvImageFormatR16i; + case ImageFormat::r8i: + return SpvImageFormatR8i; + case ImageFormat::rgba32ui: + return SpvImageFormatRgba32ui; + case ImageFormat::rgba16ui: + return SpvImageFormatRgba16ui; + case ImageFormat::rgb10_a2ui: + return SpvImageFormatRgb10a2ui; + case ImageFormat::rgba8ui: + return SpvImageFormatRgba8ui; + case ImageFormat::rg32ui: + return SpvImageFormatRg32ui; + case ImageFormat::rg16ui: + return SpvImageFormatRg16ui; + case ImageFormat::rg8ui: + return SpvImageFormatRg8ui; + case ImageFormat::r32ui: + return SpvImageFormatR32ui; + case ImageFormat::r16ui: + return SpvImageFormatR16ui; + case ImageFormat::r8ui: + return SpvImageFormatR8ui; + case ImageFormat::r64ui: + return SpvImageFormatR64ui; + case ImageFormat::r64i: + return SpvImageFormatR64i; + default: + SLANG_UNIMPLEMENTED_X("unknown image format for spirv emit"); } } @@ -1919,8 +1992,10 @@ struct SPIRVEmitContext : public SourceEmitterBase, public SPIRVEmitSharedContex { case SpvStorageClassUniformConstant: case SpvStorageClassUniform: - case SpvStorageClassStorageBuffer: return true; - default: return false; + case SpvStorageClassStorageBuffer: + return true; + default: + return false; } } @@ -1941,10 +2016,13 @@ struct SPIRVEmitContext : public SourceEmitterBase, public SPIRVEmitSharedContex case SpvImageFormatRgba32ui: case SpvImageFormatRgba16ui: case SpvImageFormatRgba8ui: - case SpvImageFormatR32ui: return SpvCapabilityShader; + case SpvImageFormatR32ui: + return SpvCapabilityShader; case SpvImageFormatR64ui: - case SpvImageFormatR64i: return SpvCapabilityInt64ImageEXT; - default: return SpvCapabilityStorageImageExtendedFormats; + case SpvImageFormatR64i: + return SpvCapabilityInt64ImageEXT; + default: + return SpvCapabilityStorageImageExtendedFormats; } } @@ -2048,11 +2126,21 @@ struct SPIRVEmitContext : public SourceEmitterBase, public SPIRVEmitSharedContex SpvDim dim = SpvDim1D; // Silence uninitialized warnings from msvc... switch (inst->GetBaseShape()) { - case SLANG_TEXTURE_1D: dim = SpvDim1D; break; - case SLANG_TEXTURE_2D: dim = SpvDim2D; break; - case SLANG_TEXTURE_3D: dim = SpvDim3D; break; - case SLANG_TEXTURE_CUBE: dim = SpvDimCube; break; - case SLANG_TEXTURE_BUFFER: dim = SpvDimBuffer; break; + case SLANG_TEXTURE_1D: + dim = SpvDim1D; + break; + case SLANG_TEXTURE_2D: + dim = SpvDim2D; + break; + case SLANG_TEXTURE_3D: + dim = SpvDim3D; + break; + case SLANG_TEXTURE_CUBE: + dim = SpvDimCube; + break; + case SLANG_TEXTURE_BUFFER: + dim = SpvDimBuffer; + break; } SpvWord arrayed = inst->isArray() ? ImageOpConstants::isArrayed : ImageOpConstants::notArrayed; @@ -2096,19 +2184,35 @@ struct SPIRVEmitContext : public SourceEmitterBase, public SPIRVEmitSharedContex case kIROp_UNormAttr: switch (vectorSize) { - case 1: format = SpvImageFormatR8; break; - case 2: format = SpvImageFormatRg8; break; - case 3: format = SpvImageFormatRgba8; break; - case 4: format = SpvImageFormatRgba8; break; + case 1: + format = SpvImageFormatR8; + break; + case 2: + format = SpvImageFormatRg8; + break; + case 3: + format = SpvImageFormatRgba8; + break; + case 4: + format = SpvImageFormatRgba8; + break; } break; case kIROp_SNormAttr: switch (vectorSize) { - case 1: format = SpvImageFormatR8Snorm; break; - case 2: format = SpvImageFormatRg8Snorm; break; - case 3: format = SpvImageFormatRgba8Snorm; break; - case 4: format = SpvImageFormatRgba8Snorm; break; + case 1: + format = SpvImageFormatR8Snorm; + break; + case 2: + format = SpvImageFormatRg8Snorm; + break; + case 3: + format = SpvImageFormatRgba8Snorm; + break; + case 4: + format = SpvImageFormatRgba8Snorm; + break; } break; } @@ -2138,7 +2242,8 @@ struct SPIRVEmitContext : public SourceEmitterBase, public SPIRVEmitSharedContex ms == ImageOpConstants::isMultisampled && arrayed == ImageOpConstants::isArrayed) requireSPIRVCapability(SpvCapabilityImageMSArray); break; - case SpvDim3D: break; + case SpvDim3D: + break; case SpvDimCube: // Requires shader also if (sampled == ImageOpConstants::readWriteImage && @@ -2236,7 +2341,8 @@ struct SPIRVEmitContext : public SourceEmitterBase, public SPIRVEmitSharedContex varInst, SpvDecorationNoPerspective); return true; - case IRInterpolationMode::Linear: return true; + case IRInterpolationMode::Linear: + return true; case IRInterpolationMode::Sample: emitOpDecorate( getSection(SpvLogicalSectionID::Annotations), @@ -2251,7 +2357,8 @@ struct SPIRVEmitContext : public SourceEmitterBase, public SPIRVEmitSharedContex varInst, SpvDecorationCentroid); return true; - default: return false; + default: + return false; } } void emitSystemVarDecoration(IRInst* var, SpvInst* varInst) @@ -2286,7 +2393,8 @@ struct SPIRVEmitContext : public SourceEmitterBase, public SPIRVEmitSharedContex UInt space = rr->getSpace(); switch (rr->getResourceKind()) { - case LayoutResourceKind::Uniform: break; + case LayoutResourceKind::Uniform: + break; case LayoutResourceKind::VaryingInput: emitOpDecorateLocation( @@ -2379,7 +2487,8 @@ struct SPIRVEmitContext : public SourceEmitterBase, public SPIRVEmitSharedContex SpvLiteralInteger::from32((int32_t)index)); } break; - default: break; + default: + break; } } if (needDefaultSetBindingDecoration && !hasExplicitSetBinding && !isDescirptorSetDecorated) @@ -2787,7 +2896,9 @@ struct SPIRVEmitContext : public SourceEmitterBase, public SPIRVEmitSharedContex { switch (inst->getOp()) { - case kIROp_Var: emitLocalInst(spvBlock, inst); break; + case kIROp_Var: + emitLocalInst(spvBlock, inst); + break; case kIROp_DebugVar: // Declare an ordinary local variable for debugDeclare association // of a debug variable. This variable is what we will actually write @@ -2960,7 +3071,9 @@ struct SPIRVEmitContext : public SourceEmitterBase, public SPIRVEmitSharedContex return emitIntConstant( IRIntegerValue{SpvMemorySemanticsSequentiallyConsistentMask}, builder.getUIntType()); - default: SLANG_UNEXPECTED("unhandled memory order"); UNREACHABLE_RETURN(nullptr); + default: + SLANG_UNEXPECTED("unhandled memory order"); + UNREACHABLE_RETURN(nullptr); } } @@ -2991,10 +3104,15 @@ struct SPIRVEmitContext : public SourceEmitterBase, public SPIRVEmitSharedContex return typeSelect(SpvOpAtomicSMin, SpvOpAtomicUMin, SpvOpAtomicFMinEXT); case kIROp_AtomicMax: return typeSelect(SpvOpAtomicSMax, SpvOpAtomicUMax, SpvOpAtomicFMaxEXT); - case kIROp_AtomicAnd: return SpvOpAtomicAnd; - case kIROp_AtomicOr: return SpvOpAtomicOr; - case kIROp_AtomicXor: return SpvOpAtomicXor; - default: SLANG_UNEXPECTED("unhandled atomic op"); UNREACHABLE_RETURN(SpvOpNop); + case kIROp_AtomicAnd: + return SpvOpAtomicAnd; + case kIROp_AtomicOr: + return SpvOpAtomicOr; + case kIROp_AtomicXor: + return SpvOpAtomicXor; + default: + SLANG_UNEXPECTED("unhandled atomic op"); + UNREACHABLE_RETURN(SpvOpNop); } } @@ -3062,7 +3180,9 @@ struct SPIRVEmitContext : public SourceEmitterBase, public SPIRVEmitSharedContex switch (typeOp) { case kIROp_UInt64Type: - case kIROp_Int64Type: requireSPIRVCapability(SpvCapabilityInt64Atomics); break; + case kIROp_Int64Type: + requireSPIRVCapability(SpvCapabilityInt64Atomics); + break; } } @@ -3122,11 +3242,14 @@ struct SPIRVEmitContext : public SourceEmitterBase, public SPIRVEmitSharedContex { switch (type->getOp()) { - case kIROp_UnsizedArrayType: return false; - case kIROp_ArrayType: return isLegalType(as<IRArrayType>(type)->getElementType()); + case kIROp_UnsizedArrayType: + return false; + case kIROp_ArrayType: + return isLegalType(as<IRArrayType>(type)->getElementType()); case kIROp_VectorType: case kIROp_StructType: - case kIROp_MatrixType: return true; + case kIROp_MatrixType: + return true; case kIROp_PtrType: return as<IRPtrTypeBase>(type)->getAddressSpace() == AddressSpace::UserPointer; default: @@ -3187,44 +3310,83 @@ struct SPIRVEmitContext : public SourceEmitterBase, public SPIRVEmitSharedContex case kIROp_Specialize: case kIROp_MissingReturn: case kIROp_StaticAssert: - case kIROp_Unmodified: break; - case kIROp_Var: result = emitVar(parent, inst); break; - case kIROp_Call: result = emitCall(parent, static_cast<IRCall*>(inst)); break; - case kIROp_FieldAddress: result = emitFieldAddress(parent, as<IRFieldAddress>(inst)); break; - case kIROp_FieldExtract: result = emitFieldExtract(parent, as<IRFieldExtract>(inst)); break; + case kIROp_Unmodified: + break; + case kIROp_Var: + result = emitVar(parent, inst); + break; + case kIROp_Call: + result = emitCall(parent, static_cast<IRCall*>(inst)); + break; + case kIROp_FieldAddress: + result = emitFieldAddress(parent, as<IRFieldAddress>(inst)); + break; + case kIROp_FieldExtract: + result = emitFieldExtract(parent, as<IRFieldExtract>(inst)); + break; case kIROp_GetElementPtr: result = emitGetElementPtr(parent, as<IRGetElementPtr>(inst)); break; - case kIROp_GetOffsetPtr: result = emitGetOffsetPtr(parent, inst); break; - case kIROp_GetElement: result = emitGetElement(parent, as<IRGetElement>(inst)); break; - case kIROp_MakeStruct: result = emitCompositeConstruct(parent, inst); break; - case kIROp_MakeArrayFromElement: result = emitMakeArrayFromElement(parent, inst); break; - case kIROp_MakeMatrixFromScalar: result = emitMakeMatrixFromScalar(parent, inst); break; - case kIROp_MakeMatrix: result = emitMakeMatrix(parent, inst); break; - case kIROp_Load: result = emitLoad(parent, as<IRLoad>(inst)); break; - case kIROp_Store: result = emitStore(parent, as<IRStore>(inst)); break; + case kIROp_GetOffsetPtr: + result = emitGetOffsetPtr(parent, inst); + break; + case kIROp_GetElement: + result = emitGetElement(parent, as<IRGetElement>(inst)); + break; + case kIROp_MakeStruct: + result = emitCompositeConstruct(parent, inst); + break; + case kIROp_MakeArrayFromElement: + result = emitMakeArrayFromElement(parent, inst); + break; + case kIROp_MakeMatrixFromScalar: + result = emitMakeMatrixFromScalar(parent, inst); + break; + case kIROp_MakeMatrix: + result = emitMakeMatrix(parent, inst); + break; + case kIROp_Load: + result = emitLoad(parent, as<IRLoad>(inst)); + break; + case kIROp_Store: + result = emitStore(parent, as<IRStore>(inst)); + break; case kIROp_SwizzledStore: result = emitSwizzledStore(parent, as<IRSwizzledStore>(inst)); break; - case kIROp_swizzleSet: result = emitSwizzleSet(parent, as<IRSwizzleSet>(inst)); break; + case kIROp_swizzleSet: + result = emitSwizzleSet(parent, as<IRSwizzleSet>(inst)); + break; case kIROp_RWStructuredBufferGetElementPtr: result = emitStructuredBufferGetElementPtr(parent, inst); break; case kIROp_StructuredBufferGetDimensions: result = emitStructuredBufferGetDimensions(parent, inst); break; - case kIROp_swizzle: result = emitSwizzle(parent, as<IRSwizzle>(inst)); break; - case kIROp_IntCast: result = emitIntCast(parent, as<IRIntCast>(inst)); break; - case kIROp_FloatCast: result = emitFloatCast(parent, as<IRFloatCast>(inst)); break; + case kIROp_swizzle: + result = emitSwizzle(parent, as<IRSwizzle>(inst)); + break; + case kIROp_IntCast: + result = emitIntCast(parent, as<IRIntCast>(inst)); + break; + case kIROp_FloatCast: + result = emitFloatCast(parent, as<IRFloatCast>(inst)); + break; case kIROp_CastIntToFloat: result = emitIntToFloatCast(parent, as<IRCastIntToFloat>(inst)); break; case kIROp_CastFloatToInt: result = emitFloatToIntCast(parent, as<IRCastFloatToInt>(inst)); break; - case kIROp_CastPtrToInt: result = emitCastPtrToInt(parent, inst); break; - case kIROp_CastPtrToBool: result = emitCastPtrToBool(parent, inst); break; - case kIROp_CastIntToPtr: result = emitCastIntToPtr(parent, inst); break; + case kIROp_CastPtrToInt: + result = emitCastPtrToInt(parent, inst); + break; + case kIROp_CastPtrToBool: + result = emitCastPtrToBool(parent, inst); + break; + case kIROp_CastIntToPtr: + result = emitCastIntToPtr(parent, inst); + break; case kIROp_PtrCast: case kIROp_BitCast: result = emitOpBitcast(parent, inst, inst->getDataType(), inst->getOperand(0)); @@ -3250,7 +3412,9 @@ struct SPIRVEmitContext : public SourceEmitterBase, public SPIRVEmitSharedContex case kIROp_Greater: case kIROp_Geq: case kIROp_Rsh: - case kIROp_Lsh: result = emitArithmetic(parent, inst); break; + case kIROp_Lsh: + result = emitArithmetic(parent, inst); + break; case kIROp_GlobalValueRef: { auto inner = ensureInst(inst->getOperand(0)); @@ -3432,11 +3596,15 @@ struct SPIRVEmitContext : public SourceEmitterBase, public SPIRVEmitSharedContex }); break; } - case kIROp_Unreachable: result = emitOpUnreachable(parent, inst); break; + case kIROp_Unreachable: + result = emitOpUnreachable(parent, inst); + break; case kIROp_conditionalBranch: SLANG_UNEXPECTED("Unstructured branching is not supported by SPIRV."); break; - case kIROp_MakeVector: result = emitConstruct(parent, inst); break; + case kIROp_MakeVector: + result = emitConstruct(parent, inst); + break; case kIROp_MakeVectorFromScalar: { const auto scalar = inst->getOperand(0); @@ -3447,7 +3615,9 @@ struct SPIRVEmitContext : public SourceEmitterBase, public SPIRVEmitSharedContex result = emitSplat(parent, inst, scalar, numElems->getValue()); } break; - case kIROp_MakeArray: result = emitConstruct(parent, inst); break; + case kIROp_MakeArray: + result = emitConstruct(parent, inst); + break; case kIROp_Select: result = emitInst( parent, @@ -3457,14 +3627,30 @@ struct SPIRVEmitContext : public SourceEmitterBase, public SPIRVEmitSharedContex kResultID, OperandsOf(inst)); break; - case kIROp_DebugLine: result = emitDebugLine(parent, as<IRDebugLine>(inst)); break; - case kIROp_DebugVar: result = emitDebugVarDeclaration(parent, as<IRDebugVar>(inst)); break; - case kIROp_DebugValue: result = emitDebugValue(parent, as<IRDebugValue>(inst)); break; - case kIROp_GetStringHash: result = emitGetStringHash(inst); break; - case kIROp_undefined: result = emitOpUndef(parent, inst, inst->getDataType()); break; - case kIROp_SPIRVAsm: result = emitSPIRVAsm(parent, as<IRSPIRVAsm>(inst)); break; - case kIROp_ImageLoad: result = emitImageLoad(parent, as<IRImageLoad>(inst)); break; - case kIROp_ImageStore: result = emitImageStore(parent, as<IRImageStore>(inst)); break; + case kIROp_DebugLine: + result = emitDebugLine(parent, as<IRDebugLine>(inst)); + break; + case kIROp_DebugVar: + result = emitDebugVarDeclaration(parent, as<IRDebugVar>(inst)); + break; + case kIROp_DebugValue: + result = emitDebugValue(parent, as<IRDebugValue>(inst)); + break; + case kIROp_GetStringHash: + result = emitGetStringHash(inst); + break; + case kIROp_undefined: + result = emitOpUndef(parent, inst, inst->getDataType()); + break; + case kIROp_SPIRVAsm: + result = emitSPIRVAsm(parent, as<IRSPIRVAsm>(inst)); + break; + case kIROp_ImageLoad: + result = emitImageLoad(parent, as<IRImageLoad>(inst)); + break; + case kIROp_ImageStore: + result = emitImageStore(parent, as<IRImageStore>(inst)); + break; case kIROp_ImageSubscript: result = emitImageSubscript(parent, as<IRImageSubscript>(inst)); break; @@ -3784,7 +3970,8 @@ struct SPIRVEmitContext : public SourceEmitterBase, public SPIRVEmitSharedContex kResultID, SpvLiteralBits::fromUnownedStringSlice(value)); } - default: return nullptr; + default: + return nullptr; } } @@ -3871,7 +4058,8 @@ struct SPIRVEmitContext : public SourceEmitterBase, public SPIRVEmitSharedContex { case kIROp_SwizzledStore: case kIROp_Store: - case kIROp_Call: return result; + case kIROp_Call: + return result; } } return SpvExecutionModeMax; @@ -3944,7 +4132,8 @@ struct SPIRVEmitContext : public SourceEmitterBase, public SPIRVEmitSharedContex switch (decoration->getOp()) { - default: break; + default: + break; // [3.32.2. Debug Instructions] // @@ -4017,14 +4206,18 @@ struct SPIRVEmitContext : public SourceEmitterBase, public SPIRVEmitSharedContex case SpvOpSpecConstant: case SpvOpSpecConstantFalse: case SpvOpSpecConstantTrue: - case SpvOpSpecConstantComposite: break; - default: params.add(spvGlobalInst); break; + case SpvOpSpecConstantComposite: + break; + default: + params.add(spvGlobalInst); + break; } } } break; } - default: break; + default: + break; } } emitOpEntryPoint(section, decoration, spvStage, dstID, name, params); @@ -4051,11 +4244,14 @@ struct SPIRVEmitContext : public SourceEmitterBase, public SPIRVEmitSharedContex getIRInstSpvID(entryPoint), SpvExecutionModeEarlyFragmentTests); break; - default: break; + default: + break; } } break; - case Stage::Geometry: requireSPIRVCapability(SpvCapabilityGeometry); break; + case Stage::Geometry: + requireSPIRVCapability(SpvCapabilityGeometry); + break; case Stage::Miss: case Stage::AnyHit: case Stage::ClosestHit: @@ -4094,8 +4290,11 @@ struct SPIRVEmitContext : public SourceEmitterBase, public SPIRVEmitSharedContex requireSPIRVExecutionMode(nullptr, getIRInstSpvID(entryPoint), mode); break; } - case Stage::Domain: requireSPIRVCapability(SpvCapabilityTessellation); break; - default: break; + case Stage::Domain: + requireSPIRVCapability(SpvCapabilityTessellation); + break; + default: + break; } } break; @@ -4205,7 +4404,8 @@ struct SPIRVEmitContext : public SourceEmitterBase, public SPIRVEmitSharedContex dstID, SpvExecutionModeOutputTriangleStrip); break; - default: SLANG_ASSERT(!"Unknown stream out type"); + default: + SLANG_ASSERT(!"Unknown stream out type"); } } break; @@ -4456,7 +4656,8 @@ struct SPIRVEmitContext : public SourceEmitterBase, public SPIRVEmitSharedContex { switch (decoration->getOp()) { - default: break; + default: + break; case kIROp_SemanticDecoration: { ensureExtensionDeclarationBeforeSpv14( @@ -4699,10 +4900,13 @@ struct SPIRVEmitContext : public SourceEmitterBase, public SPIRVEmitSharedContex { switch (stage) { - default: SLANG_UNEXPECTED("unhandled stage"); UNREACHABLE_RETURN((SpvExecutionModel)0); + default: + SLANG_UNEXPECTED("unhandled stage"); + UNREACHABLE_RETURN((SpvExecutionModel)0); #define CASE(STAGE, MODEL) \ - case Stage::STAGE: return SpvExecutionModel##MODEL + case Stage::STAGE: \ + return SpvExecutionModel##MODEL CASE(Vertex, Vertex); CASE(Hull, TessellationControl); @@ -4960,7 +5164,9 @@ struct SPIRVEmitContext : public SourceEmitterBase, public SPIRVEmitSharedContex case Stage::AnyHit: case Stage::ClosestHit: case Stage::Hull: - case Stage::Domain: needGeometryCapability = false; break; + case Stage::Domain: + needGeometryCapability = false; + break; } } } @@ -5200,8 +5406,10 @@ struct SPIRVEmitContext : public SourceEmitterBase, public SPIRVEmitSharedContex { case kIROp_Func: case kIROp_GlobalParam: - case kIROp_GlobalVar: return true; - default: return false; + case kIROp_GlobalVar: + return true; + default: + return false; } } @@ -5247,7 +5455,8 @@ struct SPIRVEmitContext : public SourceEmitterBase, public SPIRVEmitSharedContex case IRLoopControl::kIRLoopControl_Loop: loopControl = SpvLoopControlDontUnrollMask; break; - default: break; + default: + break; } } emitOpLoopMerge( @@ -5303,8 +5512,12 @@ struct SPIRVEmitContext : public SourceEmitterBase, public SPIRVEmitSharedContex UInt argStartIndex = 0; switch (branchInst->getOp()) { - case kIROp_unconditionalBranch: argStartIndex = 1; break; - case kIROp_loop: argStartIndex = 3; break; + case kIROp_unconditionalBranch: + argStartIndex = 1; + break; + case kIROp_loop: + argStartIndex = 3; + break; default: // A phi argument can only come from an unconditional branch inst. // Other uses are not relavent so we should skip. @@ -5455,11 +5668,21 @@ struct SPIRVEmitContext : public SourceEmitterBase, public SPIRVEmitSharedContex IRType* irType = nullptr; switch (type) { - case SpvSnippet::ASMType::Float: irType = builder.getType(kIROp_FloatType); break; - case SpvSnippet::ASMType::Half: irType = builder.getType(kIROp_HalfType); break; - case SpvSnippet::ASMType::Int: irType = builder.getIntType(); break; - case SpvSnippet::ASMType::UInt: irType = builder.getUIntType(); break; - case SpvSnippet::ASMType::UInt16: irType = builder.getType(kIROp_UInt16Type); break; + case SpvSnippet::ASMType::Float: + irType = builder.getType(kIROp_FloatType); + break; + case SpvSnippet::ASMType::Half: + irType = builder.getType(kIROp_HalfType); + break; + case SpvSnippet::ASMType::Int: + irType = builder.getIntType(); + break; + case SpvSnippet::ASMType::UInt: + irType = builder.getUIntType(); + break; + case SpvSnippet::ASMType::UInt16: + irType = builder.getType(kIROp_UInt16Type); + break; case SpvSnippet::ASMType::Float2: irType = builder.getVectorType( builder.getType(kIROp_FloatType), @@ -5470,7 +5693,8 @@ struct SPIRVEmitContext : public SourceEmitterBase, public SPIRVEmitSharedContex builder.getType(kIROp_UIntType), builder.getIntValue(builder.getIntType(), 2)); break; - default: SLANG_UNEXPECTED("unhandled case in emitSpvSnippetASMTypeOperand"); + default: + SLANG_UNEXPECTED("unhandled case in emitSpvSnippetASMTypeOperand"); } emitOperand(irType); } @@ -5491,12 +5715,16 @@ struct SPIRVEmitContext : public SourceEmitterBase, public SPIRVEmitSharedContex { switch (operand.type) { - case SpvSnippet::ASMOperandType::SpvWord: emitOperand(operand.content); break; + case SpvSnippet::ASMOperandType::SpvWord: + emitOperand(operand.content); + break; case SpvSnippet::ASMOperandType::ObjectReference: SLANG_ASSERT(operand.content < (SpvWord)context.argumentIds.getCount()); emitOperand(context.argumentIds[operand.content]); break; - case SpvSnippet::ASMOperandType::ResultId: emitOperand(kResultID); break; + case SpvSnippet::ASMOperandType::ResultId: + emitOperand(kResultID); + break; case SpvSnippet::ASMOperandType::ResultTypeId: { emitOperand(context.resultType); @@ -5548,11 +5776,14 @@ struct SPIRVEmitContext : public SourceEmitterBase, public SPIRVEmitSharedContex { switch (extractBaseType(context.irResultType)) { - case BaseType::Float: constant.type = SpvSnippet::ASMType::Float; break; + case BaseType::Float: + constant.type = SpvSnippet::ASMType::Float; + break; case BaseType::Double: constant.type = SpvSnippet::ASMType::Double; break; - default: break; + default: + break; } } SpvInst* spvConstant = maybeEmitSpvConstant(constant); @@ -6398,14 +6629,19 @@ struct SPIRVEmitContext : public SourceEmitterBase, public SPIRVEmitSharedContex switch (type->getOp()) { case kIROp_FloatType: - case kIROp_DoubleType: return true; + case kIROp_DoubleType: + return true; case kIROp_IntType: case kIROp_Int16Type: case kIROp_Int64Type: - case kIROp_Int8Type: return true; - case kIROp_VectorType: return isSignedType(as<IRVectorType>(type)->getElementType()); - case kIROp_MatrixType: return isSignedType(as<IRMatrixType>(type)->getElementType()); - default: return false; + case kIROp_Int8Type: + return true; + case kIROp_VectorType: + return isSignedType(as<IRVectorType>(type)->getElementType()); + case kIROp_MatrixType: + return isSignedType(as<IRMatrixType>(type)->getElementType()); + default: + return false; } } @@ -6415,10 +6651,14 @@ struct SPIRVEmitContext : public SourceEmitterBase, public SPIRVEmitSharedContex { case kIROp_FloatType: case kIROp_DoubleType: - case kIROp_HalfType: return true; - case kIROp_VectorType: return isFloatType(as<IRVectorType>(type)->getElementType()); - case kIROp_MatrixType: return isFloatType(as<IRMatrixType>(type)->getElementType()); - default: return false; + case kIROp_HalfType: + return true; + case kIROp_VectorType: + return isFloatType(as<IRVectorType>(type)->getElementType()); + case kIROp_MatrixType: + return isFloatType(as<IRMatrixType>(type)->getElementType()); + default: + return false; } } @@ -6438,22 +6678,37 @@ struct SPIRVEmitContext : public SourceEmitterBase, public SPIRVEmitSharedContex { case BaseType::Float: case BaseType::Double: - case BaseType::Half: isFloatingPoint = true; break; - case BaseType::Bool: isBool = true; break; - default: break; + case BaseType::Half: + isFloatingPoint = true; + break; + case BaseType::Bool: + isBool = true; + break; + default: + break; } SpvOp opCode = SpvOpUndef; bool isSigned = isSignedType(basicType); switch (op) { - case kIROp_Add: opCode = isFloatingPoint ? SpvOpFAdd : SpvOpIAdd; break; - case kIROp_Sub: opCode = isFloatingPoint ? SpvOpFSub : SpvOpISub; break; - case kIROp_Mul: opCode = isFloatingPoint ? SpvOpFMul : SpvOpIMul; break; + case kIROp_Add: + opCode = isFloatingPoint ? SpvOpFAdd : SpvOpIAdd; + break; + case kIROp_Sub: + opCode = isFloatingPoint ? SpvOpFSub : SpvOpISub; + break; + case kIROp_Mul: + opCode = isFloatingPoint ? SpvOpFMul : SpvOpIMul; + break; case kIROp_Div: opCode = isFloatingPoint ? SpvOpFDiv : isSigned ? SpvOpSDiv : SpvOpUDiv; break; - case kIROp_IRem: opCode = isSigned ? SpvOpSRem : SpvOpUMod; break; - case kIROp_FRem: opCode = SpvOpFRem; break; + case kIROp_IRem: + opCode = isSigned ? SpvOpSRem : SpvOpUMod; + break; + case kIROp_FRem: + opCode = SpvOpFRem; + break; case kIROp_Less: opCode = isFloatingPoint ? SpvOpFOrdLessThan : isSigned ? SpvOpSLessThan @@ -6482,10 +6737,18 @@ struct SPIRVEmitContext : public SourceEmitterBase, public SPIRVEmitSharedContex : isSigned ? SpvOpSGreaterThan : SpvOpUGreaterThan; break; - case kIROp_Neg: opCode = isFloatingPoint ? SpvOpFNegate : SpvOpSNegate; break; - case kIROp_And: opCode = SpvOpLogicalAnd; break; - case kIROp_Or: opCode = SpvOpLogicalOr; break; - case kIROp_Not: opCode = SpvOpLogicalNot; break; + case kIROp_Neg: + opCode = isFloatingPoint ? SpvOpFNegate : SpvOpSNegate; + break; + case kIROp_And: + opCode = SpvOpLogicalAnd; + break; + case kIROp_Or: + opCode = SpvOpLogicalOr; + break; + case kIROp_Not: + opCode = SpvOpLogicalNot; + break; case kIROp_BitAnd: if (isBool) opCode = SpvOpLogicalAnd; @@ -6513,8 +6776,12 @@ struct SPIRVEmitContext : public SourceEmitterBase, public SPIRVEmitSharedContex case kIROp_Rsh: opCode = isSigned ? SpvOpShiftRightArithmetic : SpvOpShiftRightLogical; break; - case kIROp_Lsh: opCode = SpvOpShiftLeftLogical; break; - default: SLANG_ASSERT(!"unknown arithmetic opcode"); break; + case kIROp_Lsh: + opCode = SpvOpShiftLeftLogical; + break; + default: + SLANG_ASSERT(!"unknown arithmetic opcode"); + break; } if (operandCount == 1) { @@ -7169,9 +7436,12 @@ struct SPIRVEmitContext : public SourceEmitterBase, public SPIRVEmitSharedContex default: switch (opcode) { - case SpvOpName: return getSection(SpvLogicalSectionID::DebugNames); - case SpvOpCapability: return getSection(SpvLogicalSectionID::Capabilities); - case SpvOpExtension: return getSection(SpvLogicalSectionID::Extensions); + case SpvOpName: + return getSection(SpvLogicalSectionID::DebugNames); + case SpvOpCapability: + return getSection(SpvLogicalSectionID::Capabilities); + case SpvOpExtension: + return getSection(SpvLogicalSectionID::Extensions); case SpvOpExecutionMode: case SpvOpExecutionModeId: return getSection(SpvLogicalSectionID::ExecutionModes); @@ -7181,7 +7451,8 @@ struct SPIRVEmitContext : public SourceEmitterBase, public SPIRVEmitSharedContex case SpvOpMemberDecorate: case SpvOpMemberDecorateString: return getSection(SpvLogicalSectionID::Annotations); - default: return defaultParent; + default: + return defaultParent; } } }; @@ -7211,7 +7482,8 @@ struct SPIRVEmitContext : public SourceEmitterBase, public SPIRVEmitSharedContex } case kIROp_StringLit: SLANG_UNIMPLEMENTED_X("String constants in SPIR-V emit"); - default: SLANG_UNREACHABLE("Unhandled case in emitSPIRVAsm"); + default: + SLANG_UNREACHABLE("Unhandled case in emitSPIRVAsm"); } emitOperand(constant); } @@ -7230,7 +7502,8 @@ struct SPIRVEmitContext : public SourceEmitterBase, public SPIRVEmitSharedContex emitOperand(SpvLiteralInteger::from32(uint32_t(i))); break; } - default: SLANG_UNREACHABLE("Unhandled case in emitSPIRVAsm"); + default: + SLANG_UNREACHABLE("Unhandled case in emitSPIRVAsm"); } } break; @@ -7309,7 +7582,8 @@ struct SPIRVEmitContext : public SourceEmitterBase, public SPIRVEmitSharedContex emitOperand(getNonSemanticDebugPrintfExtInst()); break; } - default: SLANG_UNREACHABLE("Unhandled case in emitSPIRVAsm"); + default: + SLANG_UNREACHABLE("Unhandled case in emitSPIRVAsm"); } }; @@ -7319,7 +7593,8 @@ struct SPIRVEmitContext : public SourceEmitterBase, public SPIRVEmitSharedContex { switch (operand->getOp()) { - case kIROp_SPIRVAsmOperandInst: return cast<IRType>(operand->getValue()); + case kIROp_SPIRVAsmOperandInst: + return cast<IRType>(operand->getValue()); case kIROp_SPIRVAsmOperandSampledType: { // Make a 4 vector of the component type @@ -7332,7 +7607,8 @@ struct SPIRVEmitContext : public SourceEmitterBase, public SPIRVEmitSharedContex case kIROp_SPIRVAsmOperandResult: case kIROp_SPIRVAsmOperandId: SLANG_UNEXPECTED("truncate should have been given slang types"); - default: SLANG_UNREACHABLE("Unhandled case in emitSPIRVAsm"); + default: + SLANG_UNREACHABLE("Unhandled case in emitSPIRVAsm"); } }; @@ -7473,7 +7749,8 @@ struct SPIRVEmitContext : public SourceEmitterBase, public SPIRVEmitSharedContex } continue; } - default: break; + default: + break; } const auto opParent = parentForOpCode(opcode, parent); const auto opInfo = m_grammarInfo->opInfos.lookup(opcode); diff --git a/source/slang/slang-emit-torch.cpp b/source/slang/slang-emit-torch.cpp index 2da2cf79c..61382961d 100644 --- a/source/slang/slang-emit-torch.cpp +++ b/source/slang/slang-emit-torch.cpp @@ -25,15 +25,33 @@ void emitTorchScalarTypeName(SourceWriter* m_writer, IRInst* type) switch (instType->getOp()) { - case kIROp_FloatType: m_writer->emit("kFloat32"); break; - case kIROp_HalfType: m_writer->emit("kFloat16"); break; - case kIROp_DoubleType: m_writer->emit("kFloat64"); break; - case kIROp_UInt8Type: m_writer->emit("kUInt8"); break; - case kIROp_Int8Type: m_writer->emit("kInt8"); break; - case kIROp_Int16Type: m_writer->emit("kInt16"); break; - case kIROp_IntType: m_writer->emit("kInt32"); break; - case kIROp_Int64Type: m_writer->emit("kInt64"); break; - case kIROp_BoolType: m_writer->emit("kBool"); break; + case kIROp_FloatType: + m_writer->emit("kFloat32"); + break; + case kIROp_HalfType: + m_writer->emit("kFloat16"); + break; + case kIROp_DoubleType: + m_writer->emit("kFloat64"); + break; + case kIROp_UInt8Type: + m_writer->emit("kUInt8"); + break; + case kIROp_Int8Type: + m_writer->emit("kInt8"); + break; + case kIROp_Int16Type: + m_writer->emit("kInt16"); + break; + case kIROp_IntType: + m_writer->emit("kInt32"); + break; + case kIROp_Int64Type: + m_writer->emit("kInt64"); + break; + case kIROp_BoolType: + m_writer->emit("kBool"); + break; default: SLANG_UNEXPECTED((std::string("unknown scalar type in allocTorchTensor: ") + std::string(getIROpInfo(type->getOp()).name)) @@ -46,7 +64,8 @@ bool TorchCppSourceEmitter::tryEmitInstStmtImpl(IRInst* inst) { switch (inst->getOp()) { - default: return false; + default: + return false; case kIROp_CudaKernelLaunch: { m_writer->emit("AT_CUDA_CHECK(cudaLaunchKernel("); @@ -173,7 +192,8 @@ SlangResult TorchCppSourceEmitter::calcTypeName( { switch (type->getOp()) { - default: return Super::calcTypeName(type, target, out); + default: + return Super::calcTypeName(type, target, out); case kIROp_TensorViewType: { out << "TensorView"; diff --git a/source/slang/slang-emit-wgsl.cpp b/source/slang/slang-emit-wgsl.cpp index d8ec01776..52ff790d7 100644 --- a/source/slang/slang-emit-wgsl.cpp +++ b/source/slang/slang-emit-wgsl.cpp @@ -114,8 +114,12 @@ void WGSLSourceEmitter::emitEntryPointAttributesImpl( switch (stage) { - case Stage::Fragment: m_writer->emit("@fragment\n"); break; - case Stage::Vertex: m_writer->emit("@vertex\n"); break; + case Stage::Fragment: + m_writer->emit("@fragment\n"); + break; + case Stage::Vertex: + m_writer->emit("@vertex\n"); + break; case Stage::Compute: { @@ -137,7 +141,8 @@ void WGSLSourceEmitter::emitEntryPointAttributesImpl( } break; - default: SLANG_ABORT_COMPILATION("unsupported stage."); + default: + SLANG_ABORT_COMPILATION("unsupported stage."); } } @@ -231,15 +236,25 @@ void WGSLSourceEmitter::emit(const AddressSpace addressSpace) { switch (addressSpace) { - case AddressSpace::Uniform: m_writer->emit("uniform"); break; + case AddressSpace::Uniform: + m_writer->emit("uniform"); + break; - case AddressSpace::StorageBuffer: m_writer->emit("storage"); break; + case AddressSpace::StorageBuffer: + m_writer->emit("storage"); + break; - case AddressSpace::Generic: m_writer->emit("function"); break; + case AddressSpace::Generic: + m_writer->emit("function"); + break; - case AddressSpace::ThreadLocal: m_writer->emit("private"); break; + case AddressSpace::ThreadLocal: + m_writer->emit("private"); + break; - case AddressSpace::GroupShared: m_writer->emit("workgroup"); break; + case AddressSpace::GroupShared: + m_writer->emit("workgroup"); + break; } } @@ -252,22 +267,38 @@ static const char* getWgslImageFormat(IRTextureTypeBase* type) type->hasFormat() ? (ImageFormat)type->getFormat() : ImageFormat::unknown; switch (imageFormat) { - case ImageFormat::rgba8: return "rgba8unorm"; - case ImageFormat::rgba8_snorm: return "rgba8snorm"; - case ImageFormat::rgba8ui: return "rgba8uint"; - case ImageFormat::rgba8i: return "rgba8sint"; - case ImageFormat::rgba16ui: return "rgba16uint"; - case ImageFormat::rgba16i: return "rgba16sint"; - case ImageFormat::rgba16f: return "rgba16float"; - case ImageFormat::r32ui: return "r32uint"; - case ImageFormat::r32i: return "r32sint"; - case ImageFormat::r32f: return "r32float"; - case ImageFormat::rg32ui: return "rg32uint"; - case ImageFormat::rg32i: return "rg32sint"; - case ImageFormat::rg32f: return "rg32float"; - case ImageFormat::rgba32ui: return "rgba32uint"; - case ImageFormat::rgba32i: return "rgba32sint"; - case ImageFormat::rgba32f: return "rgba32float"; + case ImageFormat::rgba8: + return "rgba8unorm"; + case ImageFormat::rgba8_snorm: + return "rgba8snorm"; + case ImageFormat::rgba8ui: + return "rgba8uint"; + case ImageFormat::rgba8i: + return "rgba8sint"; + case ImageFormat::rgba16ui: + return "rgba16uint"; + case ImageFormat::rgba16i: + return "rgba16sint"; + case ImageFormat::rgba16f: + return "rgba16float"; + case ImageFormat::r32ui: + return "r32uint"; + case ImageFormat::r32i: + return "r32sint"; + case ImageFormat::r32f: + return "r32float"; + case ImageFormat::rg32ui: + return "rg32uint"; + case ImageFormat::rg32i: + return "rg32sint"; + case ImageFormat::rg32f: + return "rg32float"; + case ImageFormat::rgba32ui: + return "rgba32uint"; + case ImageFormat::rgba32i: + return "rgba32sint"; + case ImageFormat::rgba32f: + return "rgba32float"; case ImageFormat::unknown: // Unlike SPIR-V, WGSL doesn't have a texel format for "unknown". return "rgba32float"; @@ -317,7 +348,9 @@ void WGSLSourceEmitter::emitSimpleTypeImpl(IRType* type) return; } - case kIROp_FloatType: m_writer->emit("f32"); break; + case kIROp_FloatType: + m_writer->emit("f32"); + break; case kIROp_DoubleType: // There is no "f64" type in WGSL SLANG_UNEXPECTED("'double' type emitted"); @@ -331,20 +364,34 @@ void WGSLSourceEmitter::emitSimpleTypeImpl(IRType* type) m_f16ExtensionEnabled = true; m_writer->emit("f16"); break; - case kIROp_BoolType: m_writer->emit("bool"); break; - case kIROp_IntType: m_writer->emit("i32"); break; - case kIROp_UIntType: m_writer->emit("u32"); break; + case kIROp_BoolType: + m_writer->emit("bool"); + break; + case kIROp_IntType: + m_writer->emit("i32"); + break; + case kIROp_UIntType: + m_writer->emit("u32"); + break; case kIROp_UInt64Type: { m_writer->emit(getDefaultBuiltinTypeName(type->getOp())); return; } case kIROp_Int16Type: - case kIROp_UInt16Type: SLANG_UNEXPECTED("16 bit integer value emitted"); return; + case kIROp_UInt16Type: + SLANG_UNEXPECTED("16 bit integer value emitted"); + return; case kIROp_Int64Type: - case kIROp_IntPtrType: m_writer->emit("i64"); return; - case kIROp_UIntPtrType: m_writer->emit("u64"); return; - case kIROp_StructType: m_writer->emit(getName(type)); return; + case kIROp_IntPtrType: + m_writer->emit("i64"); + return; + case kIROp_UIntPtrType: + m_writer->emit("u64"); + return; + case kIROp_StructType: + m_writer->emit(getName(type)); + return; case kIROp_VectorType: { @@ -406,8 +453,12 @@ void WGSLSourceEmitter::emitSimpleTypeImpl(IRType* type) switch (texType->getAccess()) { case SLANG_RESOURCE_ACCESS_WRITE: - case SLANG_RESOURCE_ACCESS_READ_WRITE: m_writer->emit("texture_storage"); break; - default: m_writer->emit("texture"); break; + case SLANG_RESOURCE_ACCESS_READ_WRITE: + m_writer->emit("texture_storage"); + break; + default: + m_writer->emit("texture"); + break; } if (texType->isShadow()) @@ -422,10 +473,18 @@ void WGSLSourceEmitter::emitSimpleTypeImpl(IRType* type) switch (texType->GetBaseShape()) { - case SLANG_TEXTURE_1D: m_writer->emit("_1d"); break; - case SLANG_TEXTURE_2D: m_writer->emit("_2d"); break; - case SLANG_TEXTURE_3D: m_writer->emit("_3d"); break; - case SLANG_TEXTURE_CUBE: m_writer->emit("_cube"); break; + case SLANG_TEXTURE_1D: + m_writer->emit("_1d"); + break; + case SLANG_TEXTURE_2D: + m_writer->emit("_2d"); + break; + case SLANG_TEXTURE_3D: + m_writer->emit("_3d"); + break; + case SLANG_TEXTURE_CUBE: + m_writer->emit("_cube"); + break; } if (texType->isArray()) @@ -467,7 +526,8 @@ void WGSLSourceEmitter::emitSimpleTypeImpl(IRType* type) m_writer->emit(">"); return; } - default: break; + default: + break; } } @@ -531,7 +591,9 @@ void WGSLSourceEmitter::emitVarKeywordImpl(IRType* type, IRInst* varDecl) { case kIROp_GlobalParam: case kIROp_GlobalVar: - case kIROp_Var: m_writer->emit("var"); break; + case kIROp_Var: + m_writer->emit("var"); + break; default: if (isStaticConst(varDecl)) m_writer->emit("const"); @@ -587,8 +649,12 @@ void WGSLSourceEmitter::_emitType(IRType* type, DeclaratorInfo* declarator) { case kIROp_ArrayType: case kIROp_AttributedType: - case kIROp_UnsizedArrayType: emitSimpleTypeAndDeclarator(type, declarator); break; - default: CLikeSourceEmitter::_emitType(type, declarator); break; + case kIROp_UnsizedArrayType: + emitSimpleTypeAndDeclarator(type, declarator); + break; + default: + CLikeSourceEmitter::_emitType(type, declarator); + break; } } @@ -665,7 +731,9 @@ void WGSLSourceEmitter::emitDeclaratorImpl(DeclaratorInfo* declarator) } break; - default: SLANG_DIAGNOSE_UNEXPECTED(getSink(), SourceLoc(), "unknown declarator flavor"); break; + default: + SLANG_DIAGNOSE_UNEXPECTED(getSink(), SourceLoc(), "unknown declarator flavor"); + break; } } @@ -838,7 +906,9 @@ void WGSLSourceEmitter::emitSimpleValueImpl(IRInst* inst) } break; - default: SLANG_UNIMPLEMENTED_X("val case for emit"); break; + default: + SLANG_UNIMPLEMENTED_X("val case for emit"); + break; } } @@ -851,7 +921,8 @@ bool WGSLSourceEmitter::tryEmitInstStmtImpl(IRInst* inst) { switch (inst->getOp()) { - default: return false; + default: + return false; case kIROp_AtomicLoad: { emitInstResultDecl(inst); diff --git a/source/slang/slang-emit.cpp b/source/slang/slang-emit.cpp index c84f89028..c23195f7c 100644 --- a/source/slang/slang-emit.cpp +++ b/source/slang/slang-emit.cpp @@ -325,8 +325,12 @@ void calcRequiredLoweringPassSet( { switch (inst->getOp()) { - case kIROp_ResultType: result.resultType = true; break; - case kIROp_OptionalType: result.optionalType = true; break; + case kIROp_ResultType: + result.resultType = true; + break; + case kIROp_OptionalType: + result.optionalType = true; + break; case kIROp_TextureType: if (!isKhronosTarget(codeGenContext->getTargetReq())) { @@ -354,20 +358,28 @@ void calcRequiredLoweringPassSet( result.existentialTypeLayout = true; break; case kIROp_GetRegisterIndex: - case kIROp_GetRegisterSpace: result.bindingQuery = true; break; + case kIROp_GetRegisterSpace: + result.bindingQuery = true; + break; case kIROp_BackwardDifferentiate: case kIROp_ForwardDifferentiate: - case kIROp_MakeDifferentialPairUserCode: result.autodiff = true; break; + case kIROp_MakeDifferentialPairUserCode: + result.autodiff = true; + break; case kIROp_VerticesType: case kIROp_IndicesType: - case kIROp_PrimitivesType: result.meshOutput = true; break; + case kIROp_PrimitivesType: + result.meshOutput = true; + break; case kIROp_CreateExistentialObject: case kIROp_MakeExistential: case kIROp_ExtractExistentialType: case kIROp_ExtractExistentialValue: case kIROp_ExtractExistentialWitnessTable: case kIROp_WrapExistential: - case kIROp_LookupWitness: result.generics = true; break; + case kIROp_LookupWitness: + result.generics = true; + break; case kIROp_Specialize: { auto specInst = as<IRSpecialize>(inst); @@ -375,27 +387,41 @@ void calcRequiredLoweringPassSet( result.generics = true; } break; - case kIROp_Reinterpret: result.reinterpret = true; break; - case kIROp_BitCast: result.bitcast = true; break; - case kIROp_AutoPyBindCudaDecoration: result.derivativePyBindWrapper = true; break; + case kIROp_Reinterpret: + result.reinterpret = true; + break; + case kIROp_BitCast: + result.bitcast = true; + break; + case kIROp_AutoPyBindCudaDecoration: + result.derivativePyBindWrapper = true; + break; case kIROp_Param: if (as<IRFuncType>(inst->getDataType())) result.higherOrderFunc = true; break; case kIROp_GlobalInputDecoration: case kIROp_GlobalOutputDecoration: - case kIROp_GetWorkGroupSize: result.glslGlobalVar = true; break; + case kIROp_GetWorkGroupSize: + result.glslGlobalVar = true; + break; case kIROp_BindExistentialSlotsDecoration: result.bindExistential = true; result.generics = true; result.existentialTypeLayout = true; break; - case kIROp_GLSLShaderStorageBufferType: result.glslSSBO = true; break; + case kIROp_GLSLShaderStorageBufferType: + result.glslSSBO = true; + break; case kIROp_ByteAddressBufferLoad: case kIROp_ByteAddressBufferStore: case kIROp_HLSLRWByteAddressBufferType: - case kIROp_HLSLByteAddressBufferType: result.byteAddressBuffer = true; break; - case kIROp_DynamicResourceType: result.dynamicResource = true; break; + case kIROp_HLSLByteAddressBufferType: + result.byteAddressBuffer = true; + break; + case kIROp_DynamicResourceType: + result.dynamicResource = true; + break; } if (!result.generics || !result.existentialTypeLayout) { @@ -616,8 +642,10 @@ Result linkAndOptimizeIR( CollectEntryPointUniformParamsOptions passOptions; switch (target) { - case CodeGenTarget::HostCPPSource: break; - case CodeGenTarget::CUDASource: collectOptiXEntryPointUniformParams(irModule); + case CodeGenTarget::HostCPPSource: + break; + case CodeGenTarget::CUDASource: + collectOptiXEntryPointUniformParams(irModule); #if 0 dumpIRIfEnabled(codeGenContext, irModule, "OPTIX ENTRY POINT UNIFORMS COLLECTED"); #endif @@ -627,7 +655,8 @@ Result linkAndOptimizeIR( case CodeGenTarget::CPPSource: passOptions.alwaysCreateCollectedParam = true; [[fallthrough]]; - default: collectEntryPointUniformParams(irModule, passOptions); + default: + collectEntryPointUniformParams(irModule, passOptions); #if 0 dumpIRIfEnabled(codeGenContext, irModule, "ENTRY POINT UNIFORMS COLLECTED"); #endif @@ -638,7 +667,8 @@ Result linkAndOptimizeIR( switch (target) { - default: moveEntryPointUniformParamsToGlobalScope(irModule); + default: + moveEntryPointUniformParamsToGlobalScope(irModule); #if 0 dumpIRIfEnabled(codeGenContext, irModule, "ENTRY POINT UNIFORMS MOVED"); #endif @@ -646,7 +676,8 @@ Result linkAndOptimizeIR( break; case CodeGenTarget::HostCPPSource: case CodeGenTarget::CPPSource: - case CodeGenTarget::CUDASource: break; + case CodeGenTarget::CUDASource: + break; } if (requiredLoweringPassSet.optionalType) @@ -655,9 +686,12 @@ Result linkAndOptimizeIR( switch (target) { case CodeGenTarget::CUDASource: - case CodeGenTarget::PyTorchCppBinding: break; + case CodeGenTarget::PyTorchCppBinding: + break; - default: removeTorchAndCUDAEntryPoints(irModule); break; + default: + removeTorchAndCUDAEntryPoints(irModule); + break; } switch (target) @@ -670,7 +704,8 @@ Result linkAndOptimizeIR( generateDllExportFuncs(irModule, sink); break; } - default: break; + default: + break; } // Lower `Result<T,E>` types into ordinary struct types. @@ -724,7 +759,8 @@ Result linkAndOptimizeIR( generateDerivativeWrappers(irModule, sink); break; } - default: break; + default: + break; } if (requiredLoweringPassSet.autodiff) @@ -833,7 +869,8 @@ Result linkAndOptimizeIR( removeTorchKernels(irModule); handleAutoBindNames(irModule); break; - default: break; + default: + break; } if (codeGenContext->removeAvailableInDownstreamIR) @@ -1089,7 +1126,8 @@ Result linkAndOptimizeIR( } break; - default: break; + default: + break; } // For all targets, we translate load/store operations @@ -1107,7 +1145,8 @@ Result linkAndOptimizeIR( // switch (target) { - default: break; + default: + break; case CodeGenTarget::GLSL: case CodeGenTarget::SPIRV: @@ -1182,7 +1221,8 @@ Result linkAndOptimizeIR( } break; - default: break; + default: + break; } legalizeByteAddressBufferOps( @@ -1211,14 +1251,17 @@ Result linkAndOptimizeIR( } break; - default: break; + default: + break; } switch (target) { case CodeGenTarget::GLSL: case CodeGenTarget::SPIRV: - case CodeGenTarget::WGSL: resolveTextureFormat(irModule); break; + case CodeGenTarget::WGSL: + resolveTextureFormat(irModule); + break; } // For GLSL only, we will need to perform "legalization" of @@ -1285,7 +1328,8 @@ Result linkAndOptimizeIR( } break; - default: break; + default: + break; } // Legalize non struct parameters that are expected to be structs for HLSL. @@ -1309,7 +1353,8 @@ Result linkAndOptimizeIR( legalizeImageSubscript(targetRequest, irModule, sink); } break; - default: break; + default: + break; } // Legalize constant buffer loads. @@ -1323,13 +1368,17 @@ Result linkAndOptimizeIR( legalizeDispatchMeshPayloadForGLSL(irModule); } break; - default: break; + default: + break; } switch (target) { - default: break; - case CodeGenTarget::GLSL: moveGlobalVarInitializationToEntryPoints(irModule); break; + default: + break; + case CodeGenTarget::GLSL: + moveGlobalVarInitializationToEntryPoints(irModule); + break; // For SPIR-V to SROA across 2 entry-points a value must not be a global case CodeGenTarget::SPIRV: case CodeGenTarget::SPIRVAssembly: @@ -1675,10 +1724,13 @@ SlangResult CodeGenContext::emitEntryPointsSourceFromIR(ComPtr<IArtifact>& outAr sourceEmitter = new WGSLSourceEmitter(desc); break; } - default: break; + default: + break; } break; - case CodeGenTarget::PyTorchCppBinding: sourceEmitter = new TorchCppSourceEmitter(desc); break; + case CodeGenTarget::PyTorchCppBinding: + sourceEmitter = new TorchCppSourceEmitter(desc); + break; } if (!sourceEmitter) @@ -1700,7 +1752,8 @@ SlangResult CodeGenContext::emitEntryPointsSourceFromIR(ComPtr<IArtifact>& outAr switch (sourceLanguage) { - default: break; + default: + break; case SourceLanguage::CPP: case SourceLanguage::C: @@ -1758,7 +1811,9 @@ SlangResult CodeGenContext::emitEntryPointsSourceFromIR(ComPtr<IArtifact>& outAr switch (target) { - case CodeGenTarget::PyTorchCppBinding: sourceWriter.emit(get_slang_torch_prelude()); break; + case CodeGenTarget::PyTorchCppBinding: + sourceWriter.emit(get_slang_torch_prelude()); + break; default: if (isHeterogeneousTarget(target)) { @@ -1903,7 +1958,9 @@ SlangResult emitSPIRVForEntryPointsDirectly( downstreamOptions.optimizationLevel = DownstreamCompileOptions::OptimizationLevel::Maximal; break; - default: SLANG_ASSERT(!"Unhandled optimization level"); break; + default: + SLANG_ASSERT(!"Unhandled optimization level"); + break; } auto downstreamStartTime = std::chrono::high_resolution_clock::now(); if (SLANG_SUCCEEDED(compiler->compile(downstreamOptions, optimizedArtifact.writeRef()))) diff --git a/source/slang/slang-hlsl-to-vulkan-layout-options.cpp b/source/slang/slang-hlsl-to-vulkan-layout-options.cpp index 915ff7a74..ff93cfa0d 100644 --- a/source/slang/slang-hlsl-to-vulkan-layout-options.cpp +++ b/source/slang/slang-hlsl-to-vulkan-layout-options.cpp @@ -163,9 +163,12 @@ HLSLToVulkanLayoutOptions::Binding HLSLToVulkanLayoutOptions::inferBinding( { return Kind::ConstantBuffer; } - case ParameterCategory::ShaderResource: return Kind::ShaderResource; - case ParameterCategory::UnorderedAccess: return Kind::UnorderedAccess; - case ParameterCategory::SamplerState: return Kind::Sampler; + case ParameterCategory::ShaderResource: + return Kind::ShaderResource; + case ParameterCategory::UnorderedAccess: + return Kind::UnorderedAccess; + case ParameterCategory::SamplerState: + return Kind::Sampler; default: { diff --git a/source/slang/slang-intrinsic-expand.cpp b/source/slang/slang-intrinsic-expand.cpp index 17a7170f3..1f1511e15 100644 --- a/source/slang/slang-intrinsic-expand.cpp +++ b/source/slang/slang-intrinsic-expand.cpp @@ -75,21 +75,36 @@ static BaseType _getBaseTypeFromScalarType(SlangScalarType type) { switch (type) { - case SLANG_SCALAR_TYPE_INT32: return BaseType::Int; - case SLANG_SCALAR_TYPE_UINT32: return BaseType::UInt; - case SLANG_SCALAR_TYPE_INT16: return BaseType::Int16; - case SLANG_SCALAR_TYPE_UINT16: return BaseType::UInt16; - case SLANG_SCALAR_TYPE_INT64: return BaseType::Int64; - case SLANG_SCALAR_TYPE_INTPTR: return BaseType::IntPtr; - case SLANG_SCALAR_TYPE_UINT64: return BaseType::UInt64; - case SLANG_SCALAR_TYPE_UINTPTR: return BaseType::UIntPtr; - case SLANG_SCALAR_TYPE_INT8: return BaseType::Int8; - case SLANG_SCALAR_TYPE_UINT8: return BaseType::UInt8; - case SLANG_SCALAR_TYPE_FLOAT16: return BaseType::Half; - case SLANG_SCALAR_TYPE_FLOAT32: return BaseType::Float; - case SLANG_SCALAR_TYPE_FLOAT64: return BaseType::Double; - case SLANG_SCALAR_TYPE_BOOL: return BaseType::Bool; - default: return BaseType::Void; + case SLANG_SCALAR_TYPE_INT32: + return BaseType::Int; + case SLANG_SCALAR_TYPE_UINT32: + return BaseType::UInt; + case SLANG_SCALAR_TYPE_INT16: + return BaseType::Int16; + case SLANG_SCALAR_TYPE_UINT16: + return BaseType::UInt16; + case SLANG_SCALAR_TYPE_INT64: + return BaseType::Int64; + case SLANG_SCALAR_TYPE_INTPTR: + return BaseType::IntPtr; + case SLANG_SCALAR_TYPE_UINT64: + return BaseType::UInt64; + case SLANG_SCALAR_TYPE_UINTPTR: + return BaseType::UIntPtr; + case SLANG_SCALAR_TYPE_INT8: + return BaseType::Int8; + case SLANG_SCALAR_TYPE_UINT8: + return BaseType::UInt8; + case SLANG_SCALAR_TYPE_FLOAT16: + return BaseType::Half; + case SLANG_SCALAR_TYPE_FLOAT32: + return BaseType::Float; + case SLANG_SCALAR_TYPE_FLOAT64: + return BaseType::Double; + case SLANG_SCALAR_TYPE_BOOL: + return BaseType::Bool; + default: + return BaseType::Void; } } @@ -459,7 +474,8 @@ const char* IntrinsicExpandContext::_emitSpecial(const char* cursor) } break; } - default: break; + default: + break; } } @@ -676,7 +692,9 @@ const char* IntrinsicExpandContext::_emitSpecial(const char* cursor) switch (argType->getOp()) { #define CASE(OP, STR) \ - case kIROp_##OP: str = #STR; break + case kIROp_##OP: \ + str = #STR; \ + break CASE(Int8Type, I8); CASE(Int16Type, I16); @@ -692,7 +710,9 @@ const char* IntrinsicExpandContext::_emitSpecial(const char* cursor) #undef CASE - default: SLANG_UNEXPECTED("unexpected type in intrinsic definition"); break; + default: + SLANG_UNEXPECTED("unexpected type in intrinsic definition"); + break; } m_writer->emit(str); } @@ -777,7 +797,9 @@ const char* IntrinsicExpandContext::_emitSpecial(const char* cursor) switch (arg->getDataType()->getOp()) { case kIROp_TypeKind: - case kIROp_TypeType: m_emitter->emitType((IRType*)arg); break; + case kIROp_TypeType: + m_emitter->emitType((IRType*)arg); + break; default: m_emitter->emitOperand( m_intrinsicInst->getOperand((UInt)(1 + argIndex)), @@ -789,7 +811,9 @@ const char* IntrinsicExpandContext::_emitSpecial(const char* cursor) cursor++; break; } - default: SLANG_UNEXPECTED("bad format in intrinsic definition"); break; + default: + SLANG_UNEXPECTED("bad format in intrinsic definition"); + break; } // Return the cursor position. Will be next character after characters processed diff --git a/source/slang/slang-ir-addr-inst-elimination.cpp b/source/slang/slang-ir-addr-inst-elimination.cpp index a8ccd5eb4..8dcecf285 100644 --- a/source/slang/slang-ir-addr-inst-elimination.cpp +++ b/source/slang/slang-ir-addr-inst-elimination.cpp @@ -22,7 +22,8 @@ struct AddressInstEliminationContext { switch (addr->getOp()) { - default: return builder.emitLoad(addr); + default: + return builder.emitLoad(addr); case kIROp_GetElementPtr: case kIROp_FieldAddress: { @@ -44,7 +45,9 @@ struct AddressInstEliminationContext { switch (inst->getOp()) { - default: accessChain.add(inst); goto endLoop; + default: + accessChain.add(inst); + goto endLoop; case kIROp_GetElementPtr: case kIROp_FieldAddress: accessChain.add(inst->getOperand(1)); @@ -158,13 +161,20 @@ struct AddressInstEliminationContext switch (use->getUser()->getOp()) { - case kIROp_Load: transformLoadAddr(transformBuilder, use); break; - case kIROp_Store: transformStoreAddr(transformBuilder, use); break; - case kIROp_Call: transformCallAddr(transformBuilder, use); break; + case kIROp_Load: + transformLoadAddr(transformBuilder, use); + break; + case kIROp_Store: + transformStoreAddr(transformBuilder, use); + break; + case kIROp_Call: + transformCallAddr(transformBuilder, use); + break; case kIROp_GetElementPtr: case kIROp_FieldAddress: case kIROp_Unmodified: - case kIROp_DebugValue: break; + case kIROp_DebugValue: + break; default: sink->diagnose( use->getUser()->sourceLoc, diff --git a/source/slang/slang-ir-address-analysis.cpp b/source/slang/slang-ir-address-analysis.cpp index 1d61eb1d0..a2518b127 100644 --- a/source/slang/slang-ir-address-analysis.cpp +++ b/source/slang/slang-ir-address-analysis.cpp @@ -119,8 +119,10 @@ AddressAccessInfo analyzeAddressUse(IRDominatorTree* dom, IRGlobalValueWithCode* switch (inst->getOp()) { case kIROp_GetElementPtr: - case kIROp_FieldAddress: return true; - default: return false; + case kIROp_FieldAddress: + return true; + default: + return false; } }); diff --git a/source/slang/slang-ir-any-value-marshalling.cpp b/source/slang/slang-ir-any-value-marshalling.cpp index b51ab4608..163c5a808 100644 --- a/source/slang/slang-ir-any-value-marshalling.cpp +++ b/source/slang/slang-ir-any-value-marshalling.cpp @@ -354,7 +354,8 @@ struct AnyValueMarshallingContext #endif SLANG_UNIMPLEMENTED_X("AnyValue type packing for non 32-bit elements"); break; - default: SLANG_UNREACHABLE("unknown basic type"); + default: + SLANG_UNREACHABLE("unknown basic type"); } } @@ -546,7 +547,8 @@ struct AnyValueMarshallingContext case kIROp_UInt8Type: SLANG_UNIMPLEMENTED_X("AnyValue type packing for non 32-bit elements"); break; - default: SLANG_UNREACHABLE("unknown basic type"); + default: + SLANG_UNREACHABLE("unknown basic type"); } } @@ -728,15 +730,19 @@ SlangInt _getAnyValueSizeRaw(IRType* type, SlangInt offset) case kIROp_IntType: case kIROp_FloatType: case kIROp_UIntType: - case kIROp_BoolType: return alignUp(offset, 4) + 4; + case kIROp_BoolType: + return alignUp(offset, 4) + 4; case kIROp_UInt64Type: case kIROp_Int64Type: - case kIROp_DoubleType: return -1; + case kIROp_DoubleType: + return -1; case kIROp_Int16Type: case kIROp_UInt16Type: - case kIROp_HalfType: return alignUp(offset, 2) + 2; + case kIROp_HalfType: + return alignUp(offset, 2) + 2; case kIROp_UInt8Type: - case kIROp_Int8Type: return -1; + case kIROp_Int8Type: + return -1; case kIROp_VectorType: { auto vectorType = static_cast<IRVectorType*>(type); diff --git a/source/slang/slang-ir-augment-make-existential.cpp b/source/slang/slang-ir-augment-make-existential.cpp index 23f4cf174..c2f816e49 100644 --- a/source/slang/slang-ir-augment-make-existential.cpp +++ b/source/slang/slang-ir-augment-make-existential.cpp @@ -45,8 +45,11 @@ struct AugmentMakeExistentialContext { switch (inst->getOp()) { - case kIROp_MakeExistential: processMakeExistential((IRMakeExistential*)inst); break; - default: break; + case kIROp_MakeExistential: + processMakeExistential((IRMakeExistential*)inst); + break; + default: + break; } } diff --git a/source/slang/slang-ir-autodiff-cfg-norm.cpp b/source/slang/slang-ir-autodiff-cfg-norm.cpp index 220af3438..08a6c84e7 100644 --- a/source/slang/slang-ir-autodiff-cfg-norm.cpp +++ b/source/slang/slang-ir-autodiff-cfg-norm.cpp @@ -699,7 +699,8 @@ struct CFGNormalizationPass return info.breakBlock; } - default: break; + default: + break; } SLANG_UNEXPECTED("Unhandled control-flow inst"); diff --git a/source/slang/slang-ir-autodiff-fwd.cpp b/source/slang/slang-ir-autodiff-fwd.cpp index c45e0b9bc..84003cf5b 100644 --- a/source/slang/slang-ir-autodiff-fwd.cpp +++ b/source/slang/slang-ir-autodiff-fwd.cpp @@ -592,7 +592,8 @@ static bool _isDifferentiableFunc(IRInst* func) case kIROp_ForwardDifferentiableDecoration: case kIROp_BackwardDerivativeDecoration: case kIROp_BackwardDifferentiableDecoration: - case kIROp_UserDefinedBackwardDerivativeDecoration: return true; + case kIROp_UserDefinedBackwardDerivativeDecoration: + return true; } } return false; @@ -1000,8 +1001,10 @@ InstPair ForwardDiffTranscriber::transcribeConst(IRBuilder*, IRInst* origInst) switch (origInst->getOp()) { case kIROp_FloatLit: - case kIROp_IntLit: return InstPair(origInst, nullptr); - case kIROp_VoidLit: return InstPair(origInst, origInst); + case kIROp_IntLit: + return InstPair(origInst, nullptr); + case kIROp_VoidLit: + return InstPair(origInst, origInst); } getSink()->diagnose( @@ -1869,20 +1872,26 @@ InstPair ForwardDiffTranscriber::transcribeInstImpl(IRBuilder* builder, IRInst* // Handle common SSA-style operations switch (origInst->getOp()) { - case kIROp_Param: return transcribeParam(builder, as<IRParam>(origInst)); + case kIROp_Param: + return transcribeParam(builder, as<IRParam>(origInst)); - case kIROp_Var: return transcribeVar(builder, as<IRVar>(origInst)); + case kIROp_Var: + return transcribeVar(builder, as<IRVar>(origInst)); - case kIROp_Load: return transcribeLoad(builder, as<IRLoad>(origInst)); + case kIROp_Load: + return transcribeLoad(builder, as<IRLoad>(origInst)); - case kIROp_Store: return transcribeStore(builder, as<IRStore>(origInst)); + case kIROp_Store: + return transcribeStore(builder, as<IRStore>(origInst)); - case kIROp_Return: return transcribeReturn(builder, as<IRReturn>(origInst)); + case kIROp_Return: + return transcribeReturn(builder, as<IRReturn>(origInst)); case kIROp_Add: case kIROp_Mul: case kIROp_Sub: - case kIROp_Div: return transcribeBinaryArith(builder, origInst); + case kIROp_Div: + return transcribeBinaryArith(builder, origInst); case kIROp_Less: case kIROp_Greater: @@ -1891,9 +1900,11 @@ InstPair ForwardDiffTranscriber::transcribeInstImpl(IRBuilder* builder, IRInst* case kIROp_Geq: case kIROp_Leq: case kIROp_Eql: - case kIROp_Neq: return transcribeBinaryLogic(builder, origInst); + case kIROp_Neq: + return transcribeBinaryLogic(builder, origInst); - case kIROp_Select: return transcribeSelect(builder, origInst); + case kIROp_Select: + return transcribeSelect(builder, origInst); case kIROp_MakeVector: case kIROp_MakeMatrix: @@ -1905,40 +1916,54 @@ InstPair ForwardDiffTranscriber::transcribeInstImpl(IRBuilder* builder, IRInst* case kIROp_MakeArray: case kIROp_MakeArrayFromElement: case kIROp_MakeTuple: - case kIROp_MakeValuePack: return transcribeConstruct(builder, origInst); - case kIROp_MakeStruct: return transcribeMakeStruct(builder, origInst); + case kIROp_MakeValuePack: + return transcribeConstruct(builder, origInst); + case kIROp_MakeStruct: + return transcribeMakeStruct(builder, origInst); case kIROp_LookupWitness: return transcribeLookupInterfaceMethod(builder, as<IRLookupWitnessMethod>(origInst)); - case kIROp_Call: return transcribeCall(builder, as<IRCall>(origInst)); + case kIROp_Call: + return transcribeCall(builder, as<IRCall>(origInst)); - case kIROp_swizzle: return transcribeSwizzle(builder, as<IRSwizzle>(origInst)); + case kIROp_swizzle: + return transcribeSwizzle(builder, as<IRSwizzle>(origInst)); - case kIROp_Neg: return transcribeByPassthrough(builder, origInst); + case kIROp_Neg: + return transcribeByPassthrough(builder, origInst); - case kIROp_UpdateElement: return transcribeUpdateElement(builder, origInst); + case kIROp_UpdateElement: + return transcribeUpdateElement(builder, origInst); case kIROp_unconditionalBranch: - case kIROp_loop: return transcribeControlFlow(builder, origInst); + case kIROp_loop: + return transcribeControlFlow(builder, origInst); case kIROp_FloatLit: case kIROp_IntLit: - case kIROp_VoidLit: return transcribeConst(builder, origInst); + case kIROp_VoidLit: + return transcribeConst(builder, origInst); - case kIROp_Specialize: return transcribeSpecialize(builder, as<IRSpecialize>(origInst)); + case kIROp_Specialize: + return transcribeSpecialize(builder, as<IRSpecialize>(origInst)); case kIROp_FieldExtract: - case kIROp_FieldAddress: return transcribeFieldExtract(builder, origInst); + case kIROp_FieldAddress: + return transcribeFieldExtract(builder, origInst); case kIROp_GetElement: - case kIROp_GetElementPtr: return transcribeGetElement(builder, origInst); + case kIROp_GetElementPtr: + return transcribeGetElement(builder, origInst); - case kIROp_GetTupleElement: return transcribeGetTupleElement(builder, origInst); + case kIROp_GetTupleElement: + return transcribeGetTupleElement(builder, origInst); - case kIROp_ifElse: return transcribeIfElse(builder, as<IRIfElse>(origInst)); + case kIROp_ifElse: + return transcribeIfElse(builder, as<IRIfElse>(origInst)); - case kIROp_Switch: return transcribeSwitch(builder, as<IRSwitch>(origInst)); + case kIROp_Switch: + return transcribeSwitch(builder, as<IRSwitch>(origInst)); case kIROp_MakeDifferentialPairUserCode: return transcribeMakeDifferentialPair( @@ -1949,9 +1974,11 @@ InstPair ForwardDiffTranscriber::transcribeInstImpl(IRBuilder* builder, IRInst* case kIROp_DifferentialPairGetDifferentialUserCode: return transcribeDifferentialPairGetElement(builder, origInst); - case kIROp_ExtractExistentialValue: return transcribeSingleOperandInst(builder, origInst); + case kIROp_ExtractExistentialValue: + return transcribeSingleOperandInst(builder, origInst); - case kIROp_PackAnyValue: return transcribeSingleOperandInst(builder, origInst); + case kIROp_PackAnyValue: + return transcribeSingleOperandInst(builder, origInst); case kIROp_MakeExistential: return transcribeMakeExistential(builder, as<IRMakeExistential>(origInst)); @@ -1973,11 +2000,14 @@ InstPair ForwardDiffTranscriber::transcribeInstImpl(IRBuilder* builder, IRInst* case kIROp_ExtractExistentialWitnessTable: return transcribeExtractExistentialWitnessTable(builder, origInst); - case kIROp_WrapExistential: return transcribeWrapExistential(builder, origInst); + case kIROp_WrapExistential: + return transcribeWrapExistential(builder, origInst); - case kIROp_DefaultConstruct: return transcribeDefaultConstruct(builder, origInst); + case kIROp_DefaultConstruct: + return transcribeDefaultConstruct(builder, origInst); - case kIROp_undefined: return transcribeUndefined(builder, origInst); + case kIROp_undefined: + return transcribeUndefined(builder, origInst); case kIROp_Reinterpret: return transcribeReinterpret(builder, origInst); @@ -2057,9 +2087,11 @@ InstPair ForwardDiffTranscriber::transcribeInstImpl(IRBuilder* builder, IRInst* // used by other differentiable instructions. Therefore, we'll create another // existential object but with a dzero() for it's value. // - case kIROp_CreateExistentialObject: return transcribeNonDiffInst(builder, origInst); + case kIROp_CreateExistentialObject: + return transcribeNonDiffInst(builder, origInst); - case kIROp_StructKey: return InstPair(origInst, nullptr); + case kIROp_StructKey: + return InstPair(origInst, nullptr); case kIROp_Unreachable: { diff --git a/source/slang/slang-ir-autodiff-pairs.cpp b/source/slang/slang-ir-autodiff-pairs.cpp index 9a4196d67..a49a2f762 100644 --- a/source/slang/slang-ir-autodiff-pairs.cpp +++ b/source/slang/slang-ir-autodiff-pairs.cpp @@ -110,12 +110,17 @@ struct DiffPairLoweringPass : InstPassBase case kIROp_DifferentialPairGetDifferentialUserCode: case kIROp_DifferentialPairGetPrimalUserCode: case kIROp_DifferentialPtrPairGetDifferential: - case kIROp_DifferentialPtrPairGetPrimal: lowerPairAccess(builder, inst); break; + case kIROp_DifferentialPtrPairGetPrimal: + lowerPairAccess(builder, inst); + break; case kIROp_MakeDifferentialPairUserCode: - case kIROp_MakeDifferentialPtrPair: lowerMakePair(builder, inst); break; + case kIROp_MakeDifferentialPtrPair: + lowerMakePair(builder, inst); + break; - default: break; + default: + break; } }); @@ -222,13 +227,16 @@ struct DifferentialPairUserCodeTranscribePass : public InstPassBase switch (inst->getOp()) { case kIROp_DifferentialPairGetDifferential: - case kIROp_DifferentialPairGetPrimal: rewritePairAccess(builder, inst); break; + case kIROp_DifferentialPairGetPrimal: + rewritePairAccess(builder, inst); + break; case kIROp_MakeDifferentialPair: rewriteMakePair(builder, as<IRMakeDifferentialPair>(inst)); break; - default: break; + default: + break; } }); diff --git a/source/slang/slang-ir-autodiff-primal-hoist.cpp b/source/slang/slang-ir-autodiff-primal-hoist.cpp index 0e412be02..a3f6079ac 100644 --- a/source/slang/slang-ir-autodiff-primal-hoist.cpp +++ b/source/slang/slang-ir-autodiff-primal-hoist.cpp @@ -232,7 +232,8 @@ static Dictionary<IRBlock*, IRBlock*> createPrimalRecomputeBlocks( newTerminator = builder.emitBranch(as<IRUnconditionalBranch>(terminator)->getTargetBlock()); break; - default: SLANG_UNREACHABLE("terminator type"); + default: + SLANG_UNREACHABLE("terminator type"); } // Modify jump targets in newTerminator to point to the right recompute block or @@ -852,11 +853,13 @@ void AutodiffCheckpointPolicyBase::collectInductionValues(IRGlobalValueWithCode* switch (impRes.e) { // This wasn't an induction variable - case ImplicationResult::Falsified: break; + case ImplicationResult::Falsified: + break; // The loop doesn't loop (because in every case the break flag is // true) - case ImplicationResult::AntecedentHolds: break; + case ImplicationResult::AntecedentHolds: + break; case ImplicationResult::ConsequentHolds: { @@ -1580,7 +1583,8 @@ RefPtr<HoistedPrimalsInfo> ensurePrimalAvailability( switch (inst->getOp()) { case kIROp_GetSequentialID: - case kIROp_ExtractExistentialValue: return true; + case kIROp_ExtractExistentialValue: + return true; } return false; @@ -2057,9 +2061,11 @@ static CheckpointPreference getCheckpointPreference(IRInst* callee) { switch (decor->getOp()) { - case kIROp_PreferCheckpointDecoration: return CheckpointPreference::PreferCheckpoint; + case kIROp_PreferCheckpointDecoration: + return CheckpointPreference::PreferCheckpoint; case kIROp_PreferRecomputeDecoration: - case kIROp_TargetIntrinsicDecoration: return CheckpointPreference::PreferRecompute; + case kIROp_TargetIntrinsicDecoration: + return CheckpointPreference::PreferRecompute; } } return CheckpointPreference::None; @@ -2131,7 +2137,8 @@ static bool shouldStoreInst(IRInst* inst) case kIROp_Specialize: case kIROp_LookupWitness: case kIROp_Param: - case kIROp_DetachDerivative: return false; + case kIROp_DetachDerivative: + return false; // Never store these op codes because they are trivial to compute. case kIROp_Add: @@ -2156,7 +2163,8 @@ static bool shouldStoreInst(IRInst* inst) case kIROp_BitXor: case kIROp_Lsh: case kIROp_Rsh: - case kIROp_Select: return false; + case kIROp_Select: + return false; case kIROp_GetElement: case kIROp_FieldExtract: @@ -2166,7 +2174,8 @@ static bool shouldStoreInst(IRInst* inst) case kIROp_GetOptionalValue: case kIROp_MatrixReshape: case kIROp_VectorReshape: - case kIROp_GetTupleElement: return false; + case kIROp_GetTupleElement: + return false; case kIROp_Load: // In general, don't store loads, because: @@ -2205,7 +2214,8 @@ static bool shouldStoreInst(IRInst* inst) break; } - default: break; + default: + break; } if (as<IRType>(inst)) diff --git a/source/slang/slang-ir-autodiff-primal-hoist.h b/source/slang/slang-ir-autodiff-primal-hoist.h index 45892ba42..13e2ca078 100644 --- a/source/slang/slang-ir-autodiff-primal-hoist.h +++ b/source/slang/slang-ir-autodiff-primal-hoist.h @@ -162,12 +162,18 @@ struct HoistResult { switch (mode) { - case Mode::Store: instToStore = target; break; - case Mode::Recompute: instToRecompute = target; break; + case Mode::Store: + instToStore = target; + break; + case Mode::Recompute: + instToRecompute = target; + break; case Mode::Invert: SLANG_UNEXPECTED("Wrong constructor for HoistResult::Mode::Invert"); break; - default: SLANG_UNEXPECTED("Unhandled hoist mode"); break; + default: + SLANG_UNEXPECTED("Unhandled hoist mode"); + break; } } diff --git a/source/slang/slang-ir-autodiff-rev.cpp b/source/slang/slang-ir-autodiff-rev.cpp index 6ec23768e..f0ac428c7 100644 --- a/source/slang/slang-ir-autodiff-rev.cpp +++ b/source/slang/slang-ir-autodiff-rev.cpp @@ -243,14 +243,17 @@ InstPair BackwardDiffTranscriberBase::transcribeInstImpl(IRBuilder* builder, IRI { switch (origInst->getOp()) { - case kIROp_Param: return transcribeParam(builder, as<IRParam>(origInst)); + case kIROp_Param: + return transcribeParam(builder, as<IRParam>(origInst)); - case kIROp_Return: return transcribeReturn(builder, as<IRReturn>(origInst)); + case kIROp_Return: + return transcribeReturn(builder, as<IRReturn>(origInst)); case kIROp_LookupWitness: return transcribeLookupInterfaceMethod(builder, as<IRLookupWitnessMethod>(origInst)); - case kIROp_Specialize: return transcribeSpecialize(builder, as<IRSpecialize>(origInst)); + case kIROp_Specialize: + return transcribeSpecialize(builder, as<IRSpecialize>(origInst)); case kIROp_MakeTuple: case kIROp_FloatLit: @@ -261,9 +264,11 @@ InstPair BackwardDiffTranscriberBase::transcribeInstImpl(IRBuilder* builder, IRI case kIROp_ExtractExistentialValue: case kIROp_WrapExistential: case kIROp_MakeExistential: - case kIROp_MakeExistentialWithRTTI: return transcribeNonDiffInst(builder, origInst); + case kIROp_MakeExistentialWithRTTI: + return transcribeNonDiffInst(builder, origInst); - case kIROp_StructKey: return InstPair(origInst, nullptr); + case kIROp_StructKey: + return InstPair(origInst, nullptr); } return InstPair(nullptr, nullptr); diff --git a/source/slang/slang-ir-autodiff-transcriber-base.cpp b/source/slang/slang-ir-autodiff-transcriber-base.cpp index 8fdedb42e..ada35689c 100644 --- a/source/slang/slang-ir-autodiff-transcriber-base.cpp +++ b/source/slang/slang-ir-autodiff-transcriber-base.cpp @@ -405,8 +405,10 @@ bool AutoDiffTranscriberBase::isExistentialType(IRType* type) { case kIROp_ExtractExistentialType: case kIROp_InterfaceType: - case kIROp_AssociatedType: return true; - default: return false; + case kIROp_AssociatedType: + return true; + default: + return false; } } @@ -416,7 +418,9 @@ void AutoDiffTranscriberBase::copyOriginalDecorations(IRInst* origFunc, IRInst* { switch (decor->getOp()) { - case kIROp_ForceInlineDecoration: cloneDecoration(decor, diffFunc); break; + case kIROp_ForceInlineDecoration: + cloneDecoration(decor, diffFunc); + break; } } } @@ -942,8 +946,10 @@ static void _markGenericChildrenWithoutRelaventUse( // its transcription. switch (inst->getOp()) { - case kIROp_Return: continue; - default: break; + case kIROp_Return: + continue; + default: + break; } bool hasRelaventUse = false; @@ -958,7 +964,8 @@ static void _markGenericChildrenWithoutRelaventUse( case kIROp_BackwardDerivativePrimalContextDecoration: case kIROp_BackwardDerivativePrimalDecoration: case kIROp_BackwardDerivativePropagateDecoration: - case kIROp_PrimalSubstituteDecoration: break; + case kIROp_PrimalSubstituteDecoration: + break; default: if (!outInstsToSkip.contains(use->getUser())) { @@ -1165,11 +1172,14 @@ InstPair AutoDiffTranscriberBase::transcribeInst(IRBuilder* builder, IRInst* ori // Handle instructions with children switch (origInst->getOp()) { - case kIROp_Func: return transcribeFuncHeader(builder, as<IRFunc>(origInst)); + case kIROp_Func: + return transcribeFuncHeader(builder, as<IRFunc>(origInst)); - case kIROp_Block: return transcribeBlock(builder, as<IRBlock>(origInst)); + case kIROp_Block: + return transcribeBlock(builder, as<IRBlock>(origInst)); - case kIROp_Generic: return transcribeGeneric(builder, as<IRGeneric>(origInst)); + case kIROp_Generic: + return transcribeGeneric(builder, as<IRGeneric>(origInst)); } // At this point we should not see any global insts that are differentiable. diff --git a/source/slang/slang-ir-autodiff-transpose.h b/source/slang/slang-ir-autodiff-transpose.h index 7e4de5955..c84fd778c 100644 --- a/source/slang/slang-ir-autodiff-transpose.h +++ b/source/slang/slang-ir-autodiff-transpose.h @@ -184,7 +184,8 @@ struct DiffTransposePass auto terminator = currentBlock->getTerminator(); switch (terminator->getOp()) { - case kIROp_Return: return RegionEntryPoint(revBlockMap[currentBlock], nullptr); + case kIROp_Return: + return RegionEntryPoint(revBlockMap[currentBlock], nullptr); case kIROp_unconditionalBranch: { @@ -853,7 +854,9 @@ struct DiffTransposePass case kIROp_ForwardDifferentiate: case kIROp_BackwardDifferentiate: case kIROp_BackwardDifferentiatePrimal: - case kIROp_BackwardDifferentiatePropagate: typeInsts.add(child); break; + case kIROp_BackwardDifferentiatePropagate: + typeInsts.add(child); + break; } } @@ -995,8 +998,10 @@ struct DiffTransposePass { switch (inst->getOp()) { - case kIROp_ForwardDifferentiate: return; - default: break; + case kIROp_ForwardDifferentiate: + return; + default: + break; } // Look for gradient entries for this inst. @@ -1349,13 +1354,18 @@ struct DiffTransposePass switch (terminatorInst->getOp()) { case kIROp_unconditionalBranch: - case kIROp_Return: return nullptr; + case kIROp_Return: + return nullptr; - case kIROp_ifElse: return as<IRIfElse>(terminatorInst)->getAfterBlock(); - case kIROp_Switch: return as<IRSwitch>(terminatorInst)->getBreakLabel(); - case kIROp_loop: return as<IRLoop>(terminatorInst)->getBreakBlock(); + case kIROp_ifElse: + return as<IRIfElse>(terminatorInst)->getAfterBlock(); + case kIROp_Switch: + return as<IRSwitch>(terminatorInst)->getBreakLabel(); + case kIROp_loop: + return as<IRLoop>(terminatorInst)->getBreakBlock(); - default: SLANG_UNIMPLEMENTED_X("Unhandled terminator inst when building after-block map"); + default: + SLANG_UNIMPLEMENTED_X("Unhandled terminator inst when building after-block map"); } } @@ -1438,13 +1448,17 @@ struct DiffTransposePass case kIROp_Mul: case kIROp_Sub: case kIROp_Div: - case kIROp_Neg: return transposeArithmetic(builder, fwdInst, revValue); + case kIROp_Neg: + return transposeArithmetic(builder, fwdInst, revValue); - case kIROp_Select: return transposeSelect(builder, fwdInst, revValue); + case kIROp_Select: + return transposeSelect(builder, fwdInst, revValue); - case kIROp_Call: return transposeCall(builder, as<IRCall>(fwdInst), revValue); + case kIROp_Call: + return transposeCall(builder, as<IRCall>(fwdInst), revValue); - case kIROp_swizzle: return transposeSwizzle(builder, as<IRSwizzle>(fwdInst), revValue); + case kIROp_swizzle: + return transposeSwizzle(builder, as<IRSwizzle>(fwdInst), revValue); case kIROp_FieldExtract: return transposeFieldExtract(builder, as<IRFieldExtract>(fwdInst), revValue); @@ -1452,11 +1466,14 @@ struct DiffTransposePass case kIROp_GetElement: return transposeGetElement(builder, as<IRGetElement>(fwdInst), revValue); - case kIROp_Return: return transposeReturn(builder, as<IRReturn>(fwdInst), revValue); + case kIROp_Return: + return transposeReturn(builder, as<IRReturn>(fwdInst), revValue); - case kIROp_Store: return transposeStore(builder, as<IRStore>(fwdInst), revValue); + case kIROp_Store: + return transposeStore(builder, as<IRStore>(fwdInst), revValue); - case kIROp_Load: return transposeLoad(builder, as<IRLoad>(fwdInst), revValue); + case kIROp_Load: + return transposeLoad(builder, as<IRLoad>(fwdInst), revValue); case kIROp_MakeDifferentialPair: return transposeMakePair(builder, as<IRMakeDifferentialPair>(fwdInst), revValue); @@ -1485,32 +1502,43 @@ struct DiffTransposePass as<IRDifferentialPairGetDifferentialUserCode>(fwdInst), revValue); - case kIROp_MakeVector: return transposeMakeVector(builder, fwdInst, revValue); + case kIROp_MakeVector: + return transposeMakeVector(builder, fwdInst, revValue); case kIROp_MakeVectorFromScalar: return transposeMakeVectorFromScalar(builder, fwdInst, revValue); case kIROp_MakeMatrixFromScalar: return transposeMakeMatrixFromScalar(builder, fwdInst, revValue); - case kIROp_MakeMatrix: return transposeMakeMatrix(builder, fwdInst, revValue); - case kIROp_MatrixReshape: return transposeMatrixReshape(builder, fwdInst, revValue); - case kIROp_MakeStruct: return transposeMakeStruct(builder, fwdInst, revValue); - case kIROp_MakeArray: return transposeMakeArray(builder, fwdInst, revValue); + case kIROp_MakeMatrix: + return transposeMakeMatrix(builder, fwdInst, revValue); + case kIROp_MatrixReshape: + return transposeMatrixReshape(builder, fwdInst, revValue); + case kIROp_MakeStruct: + return transposeMakeStruct(builder, fwdInst, revValue); + case kIROp_MakeArray: + return transposeMakeArray(builder, fwdInst, revValue); case kIROp_MakeTuple: - case kIROp_MakeValuePack: return transposeMakeTuple(builder, fwdInst, revValue); + case kIROp_MakeValuePack: + return transposeMakeTuple(builder, fwdInst, revValue); case kIROp_MakeArrayFromElement: return transposeMakeArrayFromElement(builder, fwdInst, revValue); - case kIROp_UpdateElement: return transposeUpdateElement(builder, fwdInst, revValue); + case kIROp_UpdateElement: + return transposeUpdateElement(builder, fwdInst, revValue); - case kIROp_FloatCast: return transposeFloatCast(builder, fwdInst, revValue); + case kIROp_FloatCast: + return transposeFloatCast(builder, fwdInst, revValue); - case kIROp_MakeExistential: return transposeMakeExistential(builder, fwdInst, revValue); + case kIROp_MakeExistential: + return transposeMakeExistential(builder, fwdInst, revValue); case kIROp_ExtractExistentialValue: return transposeExtractExistentialValue(builder, fwdInst, revValue); - case kIROp_Reinterpret: return transposeReinterpret(builder, fwdInst, revValue); + case kIROp_Reinterpret: + return transposeReinterpret(builder, fwdInst, revValue); - case kIROp_PackAnyValue: return transposePackAnyValue(builder, fwdInst, revValue); + case kIROp_PackAnyValue: + return transposePackAnyValue(builder, fwdInst, revValue); case kIROp_LoadReverseGradient: case kIROp_ReverseGradientDiffPairRef: @@ -1530,7 +1558,8 @@ struct DiffTransposePass return TranspositionResult(); } - default: SLANG_ASSERT_FAILURE("Unhandled instruction"); + default: + SLANG_ASSERT_FAILURE("Unhandled instruction"); } } @@ -2081,8 +2110,10 @@ struct DiffTransposePass switch (type->getOp()) { case kIROp_ExtractExistentialType: - case kIROp_LookupWitness: return true; - default: return false; + case kIROp_LookupWitness: + return true; + default: + return false; } }; @@ -2430,7 +2461,8 @@ struct DiffTransposePass } } - default: SLANG_ASSERT_FAILURE("Unhandled arithmetic"); + default: + SLANG_ASSERT_FAILURE("Unhandled arithmetic"); } } @@ -2641,7 +2673,8 @@ struct DiffTransposePass aggPrimalType, gradients); - default: SLANG_ASSERT_FAILURE("Unhandled gradient flavor for materialization"); + default: + SLANG_ASSERT_FAILURE("Unhandled gradient flavor for materialization"); } } diff --git a/source/slang/slang-ir-autodiff-unzip.cpp b/source/slang/slang-ir-autodiff-unzip.cpp index d6ed1ed62..9ee2cb4d2 100644 --- a/source/slang/slang-ir-autodiff-unzip.cpp +++ b/source/slang/slang-ir-autodiff-unzip.cpp @@ -129,7 +129,8 @@ struct ExtractPrimalFuncContext auto primal = insertIntoReturnBlock(builder, inst->getOperand(0)); return builder.emitMakeDifferentialPair(inst->getDataType(), primal, diff); } - default: SLANG_UNREACHABLE("unknown case of mixed inst."); + default: + SLANG_UNREACHABLE("unknown case of mixed inst."); } } @@ -308,10 +309,12 @@ bool isIntermediateContextType(IRInst* type) { switch (type->getOp()) { - case kIROp_BackwardDiffIntermediateContextType: return true; + case kIROp_BackwardDiffIntermediateContextType: + return true; case kIROp_AttributedType: return isIntermediateContextType(as<IRAttributedType>(type)->getBaseType()); - case kIROp_Specialize: return isIntermediateContextType(as<IRSpecialize>(type)->getBase()); + case kIROp_Specialize: + return isIntermediateContextType(as<IRSpecialize>(type)->getBase()); default: if (as<IRPtrTypeBase>(type)) return isIntermediateContextType(as<IRPtrTypeBase>(type)->getValueType()); diff --git a/source/slang/slang-ir-autodiff-unzip.h b/source/slang/slang-ir-autodiff-unzip.h index 161d216fa..31c4dbf91 100644 --- a/source/slang/slang-ir-autodiff-unzip.h +++ b/source/slang/slang-ir-autodiff-unzip.h @@ -675,9 +675,11 @@ struct DiffUnzipPass diffCaseArgs.getBuffer())); } - case kIROp_loop: return splitLoop(primalBuilder, diffBuilder, as<IRLoop>(branchInst)); + case kIROp_loop: + return splitLoop(primalBuilder, diffBuilder, as<IRLoop>(branchInst)); - default: SLANG_UNEXPECTED("Unhandled instruction"); + default: + SLANG_UNEXPECTED("Unhandled instruction"); } } @@ -685,29 +687,36 @@ struct DiffUnzipPass { switch (inst->getOp()) { - case kIROp_Call: return splitCall(primalBuilder, diffBuilder, as<IRCall>(inst)); + case kIROp_Call: + return splitCall(primalBuilder, diffBuilder, as<IRCall>(inst)); - case kIROp_Var: return splitVar(primalBuilder, diffBuilder, as<IRVar>(inst)); + case kIROp_Var: + return splitVar(primalBuilder, diffBuilder, as<IRVar>(inst)); case kIROp_MakeDifferentialPair: return splitMakePair(primalBuilder, diffBuilder, as<IRMakeDifferentialPair>(inst)); - case kIROp_Load: return splitLoad(primalBuilder, diffBuilder, as<IRLoad>(inst)); + case kIROp_Load: + return splitLoad(primalBuilder, diffBuilder, as<IRLoad>(inst)); - case kIROp_Store: return splitStore(primalBuilder, diffBuilder, as<IRStore>(inst)); + case kIROp_Store: + return splitStore(primalBuilder, diffBuilder, as<IRStore>(inst)); - case kIROp_Return: return splitReturn(primalBuilder, diffBuilder, as<IRReturn>(inst)); + case kIROp_Return: + return splitReturn(primalBuilder, diffBuilder, as<IRReturn>(inst)); case kIROp_unconditionalBranch: case kIROp_conditionalBranch: case kIROp_ifElse: case kIROp_Switch: - case kIROp_loop: return splitControlFlow(primalBuilder, diffBuilder, inst); + case kIROp_loop: + return splitControlFlow(primalBuilder, diffBuilder, inst); case kIROp_Unreachable: return InstPair(primalBuilder->emitUnreachable(), diffBuilder->emitUnreachable()); - default: SLANG_ASSERT_FAILURE("Unhandled mixed diff inst"); + default: + SLANG_ASSERT_FAILURE("Unhandled mixed diff inst"); } } diff --git a/source/slang/slang-ir-autodiff.cpp b/source/slang/slang-ir-autodiff.cpp index c9ae66a33..cb37b6242 100644 --- a/source/slang/slang-ir-autodiff.cpp +++ b/source/slang/slang-ir-autodiff.cpp @@ -20,7 +20,8 @@ bool isBackwardDifferentiableFunc(IRInst* func) switch (decorations->getOp()) { case kIROp_BackwardDifferentiableDecoration: - case kIROp_UserDefinedBackwardDerivativeDecoration: return true; + case kIROp_UserDefinedBackwardDerivativeDecoration: + return true; } } return false; @@ -303,8 +304,10 @@ IRInst* DifferentialPairTypeBuilder::_createDiffPairType(IRType* origBaseType, I { case kIROp_LookupWitness: case kIROp_Specialize: - case kIROp_Param: return nullptr; - default: break; + case kIROp_Param: + return nullptr; + default: + break; } IRBuilder builder(sharedContext->moduleInst); @@ -1054,7 +1057,8 @@ IRType* DifferentiableTypeConformanceContext::differentiateType( diffTypeList.getBuffer()); } - default: return (IRType*)getDifferentialForType(builder, (IRType*)primalType); + default: + return (IRType*)getDifferentialForType(builder, (IRType*)primalType); } } @@ -1593,8 +1597,11 @@ void stripDerivativeDecorations(IRInst* inst) case kIROp_BackwardDerivativePropagateDecoration: case kIROp_BackwardDerivativePrimalDecoration: case kIROp_UserDefinedBackwardDerivativeDecoration: - case kIROp_AutoDiffOriginalValueDecoration: decor->removeAndDeallocate(); break; - default: break; + case kIROp_AutoDiffOriginalValueDecoration: + decor->removeAndDeallocate(); + break; + default: + break; } decor = next; } @@ -1629,13 +1636,16 @@ void stripAutoDiffDecorationsFromChildren(IRInst* parent) case kIROp_AutoDiffOriginalValueDecoration: case kIROp_UserDefinedBackwardDerivativeDecoration: case kIROp_IntermediateContextFieldDifferentialTypeDecoration: - case kIROp_CheckpointIntermediateDecoration: decor->removeAndDeallocate(); break; + case kIROp_CheckpointIntermediateDecoration: + decor->removeAndDeallocate(); + break; case kIROp_AutoDiffBuiltinDecoration: // Remove the builtin decoration, and also remove any export/keep-alive // decorations. shouldRemoveKeepAliveDecorations = true; decor->removeAndDeallocate(); - default: break; + default: + break; } decor = next; } @@ -1649,7 +1659,9 @@ void stripAutoDiffDecorationsFromChildren(IRInst* parent) { case kIROp_ExportDecoration: case kIROp_HLSLExportDecoration: - case kIROp_KeepAliveDecoration: decor->removeAndDeallocate(); break; + case kIROp_KeepAliveDecoration: + decor->removeAndDeallocate(); + break; } decor = next; } @@ -1682,8 +1694,11 @@ void stripTempDecorations(IRInst* inst) case kIROp_BackwardDerivativePrimalReturnDecoration: case kIROp_BackwardDerivativePrimalContextDecoration: case kIROp_PrimalValueStructKeyDecoration: - case kIROp_PrimalElementTypeDecoration: decor->removeAndDeallocate(); break; - default: break; + case kIROp_PrimalElementTypeDecoration: + decor->removeAndDeallocate(); + break; + default: + break; } decor = next; } @@ -1767,9 +1782,12 @@ bool canTypeBeStored(IRInst* type) case kIROp_FloatType: case kIROp_VectorType: case kIROp_MatrixType: - case kIROp_BackwardDiffIntermediateContextType: return true; - case kIROp_AttributedType: return canTypeBeStored(type->getOperand(0)); - default: return false; + case kIROp_BackwardDiffIntermediateContextType: + return true; + case kIROp_AttributedType: + return canTypeBeStored(type->getOperand(0)); + default: + return false; } } @@ -1882,7 +1900,8 @@ struct AutoDiffPass : public InstPassBase } } break; - default: break; + default: + break; } }); result |= changed; @@ -1932,7 +1951,8 @@ struct AutoDiffPass : public InstPassBase contextTypes, sortedSet, findGenericReturnVal(as<IRGeneric>(t))); - default: return true; + default: + return true; } } @@ -2344,7 +2364,9 @@ struct AutoDiffPass : public InstPassBase if (!isTypeFullyDifferentiated(type->getOperand(i))) return false; [[fallthrough]]; - default: fullyDifferentiatedInsts.add(type); return true; + default: + fullyDifferentiatedInsts.add(type); + return true; } } @@ -2365,7 +2387,8 @@ struct AutoDiffPass : public InstPassBase case kIROp_BackwardDifferentiate: case kIROp_BackwardDifferentiatePrimal: case kIROp_BackwardDifferentiatePropagate: - case kIROp_BackwardDiffIntermediateContextType: return false; + case kIROp_BackwardDiffIntermediateContextType: + return false; } if (ii->getDataType() && !isTypeFullyDifferentiated(ii->getDataType())) return false; @@ -2416,7 +2439,9 @@ struct AutoDiffPass : public InstPassBase } autoDiffWorkList.add(inst); break; - default: autoDiffWorkList.add(inst->getOperand(0)); break; + default: + autoDiffWorkList.add(inst->getOperand(0)); + break; } break; case kIROp_PrimalSubstitute: @@ -2468,7 +2493,8 @@ struct AutoDiffPass : public InstPassBase diffFunc = backwardTranscriber.transcribe(&subBuilder, baseFunc); } break; - default: break; + default: + break; } if (diffFunc) @@ -2513,7 +2539,8 @@ struct AutoDiffPass : public InstPassBase case FuncBodyTranscriptionTaskType::BackwardPropagate: backwardPropagateTranscriber.transcribeFunc(builder, primalFunc, diffFunc); break; - default: break; + default: + break; } autodiffCleanupList.add(diffFunc); @@ -2851,7 +2878,8 @@ UIndex addPhiOutputArg( } break; - default: SLANG_UNEXPECTED("Unexpected branch-type for phi replacement"); + default: + SLANG_UNEXPECTED("Unexpected branch-type for phi replacement"); } branchInst->removeAndDeallocate(); @@ -2867,8 +2895,10 @@ bool isDifferentialOrRecomputeBlock(IRBlock* block) switch (decor->getOp()) { case kIROp_DifferentialInstDecoration: - case kIROp_RecomputeBlockDecoration: return true; - default: break; + case kIROp_RecomputeBlockDecoration: + return true; + default: + break; } } return false; diff --git a/source/slang/slang-ir-autodiff.h b/source/slang/slang-ir-autodiff.h index 789fff77d..2b03f3923 100644 --- a/source/slang/slang-ir-autodiff.h +++ b/source/slang/slang-ir-autodiff.h @@ -363,12 +363,15 @@ struct DifferentiableTypeConformanceContext case kIROp_HalfType: case kIROp_DoubleType: case kIROp_DifferentialPairType: - case kIROp_DifferentialPairUserCodeType: return true; + case kIROp_DifferentialPairUserCodeType: + return true; case kIROp_VectorType: case kIROp_ArrayType: case kIROp_PtrType: case kIROp_OutType: - case kIROp_InOutType: origType = (IRType*)origType->getOperand(0); continue; + case kIROp_InOutType: + origType = (IRType*)origType->getOperand(0); + continue; default: return lookUpConformanceForType(origType, DiffConformanceKind::Value) != nullptr; } @@ -386,8 +389,11 @@ struct DifferentiableTypeConformanceContext case kIROp_ArrayType: case kIROp_PtrType: case kIROp_OutType: - case kIROp_InOutType: origType = (IRType*)origType->getOperand(0); continue; - default: return lookUpConformanceForType(origType, DiffConformanceKind::Ptr) != nullptr; + case kIROp_InOutType: + origType = (IRType*)origType->getOperand(0); + continue; + default: + return lookUpConformanceForType(origType, DiffConformanceKind::Ptr) != nullptr; } } return false; diff --git a/source/slang/slang-ir-byte-address-legalize.cpp b/source/slang/slang-ir-byte-address-legalize.cpp index f94423e59..617c8c7c4 100644 --- a/source/slang/slang-ir-byte-address-legalize.cpp +++ b/source/slang/slang-ir-byte-address-legalize.cpp @@ -59,11 +59,17 @@ struct ByteAddressBufferLegalizationContext { switch (inst->getOp()) { - case kIROp_ByteAddressBufferLoad: processLoad(inst); break; + case kIROp_ByteAddressBufferLoad: + processLoad(inst); + break; - case kIROp_ByteAddressBufferStore: processStore(inst); break; + case kIROp_ByteAddressBufferStore: + processStore(inst); + break; - case kIROp_GetEquivalentStructuredBuffer: processGetEquivalentStructuredBuffer(inst); break; + case kIROp_GetEquivalentStructuredBuffer: + processGetEquivalentStructuredBuffer(inst); + break; } for (IRInst* child : inst->getModifiableChildren()) @@ -759,18 +765,30 @@ struct ByteAddressBufferLegalizationContext IRInst* mask = nullptr; switch (sizeAlignment.size) { - case 1: mask = m_builder.getIntValue(m_builder.getUIntType(), 0xFF); break; - case 2: mask = m_builder.getIntValue(m_builder.getUIntType(), 0xFFFF); break; - default: SLANG_ASSERT(!"Unexpected size"); break; + case 1: + mask = m_builder.getIntValue(m_builder.getUIntType(), 0xFF); + break; + case 2: + mask = m_builder.getIntValue(m_builder.getUIntType(), 0xFFFF); + break; + default: + SLANG_ASSERT(!"Unexpected size"); + break; } auto shift = m_builder.emitShr(m_builder.getUIntType(), val, shiftAmount); auto masked = m_builder.emitBitAnd(m_builder.getUIntType(), shift, mask); IRInst* casted = nullptr; switch (sizeAlignment.size) { - case 1: casted = m_builder.emitCast(m_builder.getUInt8Type(), masked); break; - case 2: casted = m_builder.emitCast(m_builder.getUInt16Type(), masked); break; - default: SLANG_ASSERT(!"Unexpected size"); break; + case 1: + casted = m_builder.emitCast(m_builder.getUInt8Type(), masked); + break; + case 2: + casted = m_builder.emitCast(m_builder.getUInt16Type(), masked); + break; + default: + SLANG_ASSERT(!"Unexpected size"); + break; } return m_builder.emitBitCast(type, casted); } @@ -831,13 +849,16 @@ struct ByteAddressBufferLegalizationContext // return BaseType::UInt; case kIROp_Int8Type: - case kIROp_UInt8Type: return BaseType::UInt8; + case kIROp_UInt8Type: + return BaseType::UInt8; case kIROp_Int16Type: case kIROp_UInt16Type: - case kIROp_HalfType: return BaseType::UInt16; + case kIROp_HalfType: + return BaseType::UInt16; case kIROp_Int64Type: case kIROp_UInt64Type: - case kIROp_DoubleType: return BaseType::UInt64; + case kIROp_DoubleType: + return BaseType::UInt64; case kIROp_IntPtrType: case kIROp_UIntPtrType: case kIROp_RawPointerType: @@ -976,7 +997,8 @@ struct ByteAddressBufferLegalizationContext dest, as<IRMemoryQualifierSetDecoration>(decoration)->getMemoryQualifierBit()); break; - default: break; + default: + break; } } } @@ -1064,7 +1086,8 @@ struct ByteAddressBufferLegalizationContext arrayType->getElementCount()); } - default: return nullptr; + default: + return nullptr; } } @@ -1411,9 +1434,15 @@ struct ByteAddressBufferLegalizationContext IRInst* mask = nullptr; switch (sizeAlignment.size) { - case 1: mask = m_builder.getIntValue(m_builder.getUIntType(), 0xFF); break; - case 2: mask = m_builder.getIntValue(m_builder.getUIntType(), 0xFFFF); break; - default: SLANG_ASSERT(!"Unexpected size"); return SLANG_FAIL; + case 1: + mask = m_builder.getIntValue(m_builder.getUIntType(), 0xFF); + break; + case 2: + mask = m_builder.getIntValue(m_builder.getUIntType(), 0xFFFF); + break; + default: + SLANG_ASSERT(!"Unexpected size"); + return SLANG_FAIL; } mask = m_builder.emitShl(m_builder.getUIntType(), mask, shiftAmount); mask = m_builder.emitBitNot(m_builder.getUIntType(), mask); diff --git a/source/slang/slang-ir-call-graph.cpp b/source/slang/slang-ir-call-graph.cpp index ee14c9809..47b18be2e 100644 --- a/source/slang/slang-ir-call-graph.cpp +++ b/source/slang/slang-ir-call-graph.cpp @@ -57,7 +57,9 @@ void buildEntryPointReferenceGraph( switch (inst->getOp()) { case kIROp_GlobalParam: - case kIROp_SPIRVAsmOperandBuiltinVar: registerEntryPointReference(entryPoint, inst); break; + case kIROp_SPIRVAsmOperandBuiltinVar: + registerEntryPointReference(entryPoint, inst); + break; case kIROp_Block: case kIROp_SPIRVAsm: for (auto child : inst->getChildren()) @@ -85,7 +87,9 @@ void buildEntryPointReferenceGraph( { case kIROp_GlobalParam: case kIROp_GlobalVar: - case kIROp_SPIRVAsmOperandBuiltinVar: addToWorkList({entryPoint, operand}); break; + case kIROp_SPIRVAsmOperandBuiltinVar: + addToWorkList({entryPoint, operand}); + break; } } }; diff --git a/source/slang/slang-ir-check-differentiability.cpp b/source/slang/slang-ir-check-differentiability.cpp index 2a1194ebe..d18c47689 100644 --- a/source/slang/slang-ir-check-differentiability.cpp +++ b/source/slang/slang-ir-check-differentiability.cpp @@ -34,7 +34,8 @@ public: switch (decorations->getOp()) { case kIROp_ForwardDifferentiableDecoration: - case kIROp_BackwardDifferentiableDecoration: return true; + case kIROp_BackwardDifferentiableDecoration: + return true; } } return false; @@ -63,8 +64,10 @@ public: break; case kIROp_UserDefinedBackwardDerivativeDecoration: case kIROp_BackwardDerivativeDecoration: - case kIROp_BackwardDifferentiableDecoration: return true; - default: break; + case kIROp_BackwardDifferentiableDecoration: + return true; + default: + break; } } return false; @@ -94,7 +97,8 @@ public: ->findDecoration<IRUserDefinedBackwardDerivativeDecoration>()) return isDifferentiableFunc(bwdDerivative->getBackwardDerivativeFunc(), level); return isDifferentiableFunc(func->getOperand(0), level); - default: break; + default: + break; } func = getResolvedInstForDecorations(func); @@ -175,7 +179,8 @@ public: switch (addr->getOp()) { case kIROp_Var: - case kIROp_Param: return isDifferentiableType(diffTypeContext, addr->getDataType()); + case kIROp_Param: + return isDifferentiableType(diffTypeContext, addr->getDataType()); case kIROp_FieldAddress: if (!as<IRFieldAddress>(addr)->getField() || as<IRFieldAddress>(addr) @@ -191,7 +196,8 @@ public: return false; addr = as<IRGetElementPtr>(addr)->getBase(); break; - default: return false; + default: + return false; } } return false; @@ -203,7 +209,8 @@ public: { switch (inst->getOp()) { - case kIROp_DetachDerivative: return false; + case kIROp_DetachDerivative: + return false; case kIROp_Call: { auto call = as<IRCall>(inst); @@ -211,7 +218,8 @@ public: call->getCallee(), CheckDifferentiabilityPassContext::DifferentiableLevel::Forward); } - default: return isDifferentiableType(diffTypeContext, inst->getDataType()); + default: + return isDifferentiableType(diffTypeContext, inst->getDataType()); } } @@ -308,7 +316,8 @@ public: { switch (inst->getOp()) { - case kIROp_FloatLit: return true; + case kIROp_FloatLit: + return true; case kIROp_Call: return shouldTreatCallAsDifferentiable(inst) || isDifferentiableFunc(as<IRCall>(inst)->getCallee(), requiredDiffLevel) && @@ -340,7 +349,8 @@ public: { switch (inst->getOp()) { - case kIROp_DetachDerivative: return false; + case kIROp_DetachDerivative: + return false; case kIROp_Call: if (shouldTreatCallAsDifferentiable(inst)) return false; @@ -449,7 +459,8 @@ public: } } break; - default: break; + default: + break; } } } diff --git a/source/slang/slang-ir-check-unsupported-inst.cpp b/source/slang/slang-ir-check-unsupported-inst.cpp index ba59a9b7b..ea9e7cc64 100644 --- a/source/slang/slang-ir-check-unsupported-inst.cpp +++ b/source/slang/slang-ir-check-unsupported-inst.cpp @@ -96,7 +96,8 @@ void checkUnsupportedInst(TargetRequest* target, IRModule* module, DiagnosticSin checkUnsupportedInst(target, innerFunc, sink); break; } - default: break; + default: + break; } } } diff --git a/source/slang/slang-ir-cleanup-void.cpp b/source/slang/slang-ir-cleanup-void.cpp index 6c21bd03a..3a776fc4f 100644 --- a/source/slang/slang-ir-cleanup-void.cpp +++ b/source/slang/slang-ir-cleanup-void.cpp @@ -136,7 +136,8 @@ struct CleanUpVoidContext ii->removeAndDeallocate(); } break; - default: break; + default: + break; } // If inst has void type, all uses of it should be replaced with void val. diff --git a/source/slang/slang-ir-collect-global-uniforms.cpp b/source/slang/slang-ir-collect-global-uniforms.cpp index c3c1e0cfe..cd03a61ef 100644 --- a/source/slang/slang-ir-collect-global-uniforms.cpp +++ b/source/slang/slang-ir-collect-global-uniforms.cpp @@ -54,10 +54,13 @@ struct CollectGlobalUniformParametersContext { switch (key->getOp()) { - case kIROp_GlobalParam: return cast<IRGlobalParam>(key); + case kIROp_GlobalParam: + return cast<IRGlobalParam>(key); case kIROp_MakeExistential: - case kIROp_WrapExistential: return as<IRGlobalParam>(key->getOperand(0)); - default: return nullptr; + case kIROp_WrapExistential: + return as<IRGlobalParam>(key->getOperand(0)); + default: + return nullptr; } } diff --git a/source/slang/slang-ir-com-interface.cpp b/source/slang/slang-ir-com-interface.cpp index ed4c4a17a..3efe78009 100644 --- a/source/slang/slang-ir-com-interface.cpp +++ b/source/slang/slang-ir-com-interface.cpp @@ -33,7 +33,8 @@ static bool _canReplace(IRUse* use) // If it's a pointer type it could be because it is a global. break; } - default: break; + default: + break; } return true; } diff --git a/source/slang/slang-ir-composite-reg-to-mem.cpp b/source/slang/slang-ir-composite-reg-to-mem.cpp index 9e68e443d..e88de3d11 100644 --- a/source/slang/slang-ir-composite-reg-to-mem.cpp +++ b/source/slang/slang-ir-composite-reg-to-mem.cpp @@ -184,7 +184,8 @@ void convertCompositeTypeParametersToPointers(IRFunc* func) initialStore = builder.emitStore(tempVar, inst); break; } - default: break; + default: + break; } if (!tempVar) diff --git a/source/slang/slang-ir-constexpr.cpp b/source/slang/slang-ir-constexpr.cpp index d558518ba..6c297fd30 100644 --- a/source/slang/slang-ir-constexpr.cpp +++ b/source/slang/slang-ir-constexpr.cpp @@ -58,9 +58,11 @@ bool isConstExpr(IRInst* value) case kIROp_Func: case kIROp_StructKey: case kIROp_WitnessTable: - case kIROp_Generic: return true; + case kIROp_Generic: + return true; - default: break; + default: + break; } if (isConstExpr(value->getFullType())) @@ -143,7 +145,8 @@ bool opCanBeConstExpr(IROp op) // TODO: more cases return true; - default: return false; + default: + return false; } } @@ -234,7 +237,8 @@ bool maybeMarkConstExprBackwardPass(PropagateConstExprContext* context, IRInst* } break; - default: break; + default: + break; } } } @@ -633,7 +637,8 @@ void propagateConstExpr(IRModule* module, DiagnosticSink* sink) switch (gv->getOp()) { - default: break; + default: + break; case kIROp_Generic: { @@ -662,7 +667,8 @@ void propagateConstExpr(IRModule* module, DiagnosticSink* sink) { switch (ii->getOp()) { - default: break; + default: + break; case kIROp_Func: case kIROp_GlobalVar: diff --git a/source/slang/slang-ir-dce.cpp b/source/slang/slang-ir-dce.cpp index 9c82715d4..5e1f2eb21 100644 --- a/source/slang/slang-ir-dce.cpp +++ b/source/slang/slang-ir-dce.cpp @@ -582,8 +582,11 @@ bool shouldInstBeLiveIfParentIsLive(IRInst* inst, IRDeadCodeEliminationOptions o { switch (decor->getOp()) { - case kIROp_ExportDecoration: return true; - case kIROp_ImportDecoration: isImported = true; break; + case kIROp_ExportDecoration: + return true; + case kIROp_ImportDecoration: + isImported = true; + break; } } for (auto decor : innerInst->getDecorations()) @@ -592,7 +595,9 @@ bool shouldInstBeLiveIfParentIsLive(IRInst* inst, IRDeadCodeEliminationOptions o { case kIROp_ForwardDerivativeDecoration: case kIROp_UserDefinedBackwardDerivativeDecoration: - case kIROp_PrimalSubstituteDecoration: shouldKeptAliveIfImported = true; break; + case kIROp_PrimalSubstituteDecoration: + shouldKeptAliveIfImported = true; + break; } } if (isImported && shouldKeptAliveIfImported) @@ -643,10 +648,13 @@ bool shouldInstBeLiveIfParentIsLive(IRInst* inst, IRDeadCodeEliminationOptions o // this problem. // case kIROp_StructField: - case kIROp_WitnessTableEntry: return true; + case kIROp_WitnessTableEntry: + return true; - case kIROp_GlobalParam: return options.keepGlobalParamsAlive; - default: break; + case kIROp_GlobalParam: + return options.keepGlobalParamsAlive; + default: + break; } // If none of the explicit cases above matched, then we will consider @@ -673,7 +681,8 @@ bool isWeakReferenceOperand(IRInst* inst, UInt operandIndex) // Ignore all operands of SpecializationDictionaryItem. // This inst is used as a cache and shouldn't hold anything alive. return true; - default: break; + default: + break; } return false; } diff --git a/source/slang/slang-ir-dll-export.cpp b/source/slang/slang-ir-dll-export.cpp index a78889bed..c525934fe 100644 --- a/source/slang/slang-ir-dll-export.cpp +++ b/source/slang/slang-ir-dll-export.cpp @@ -48,7 +48,8 @@ struct DllExportContext candidates.add(Candidate{as<IRFunc>(childFunc), dllExportDecoration}); } break; - default: break; + default: + break; } } diff --git a/source/slang/slang-ir-dll-import.cpp b/source/slang/slang-ir-dll-import.cpp index 8ee5f271a..59fb937f4 100644 --- a/source/slang/slang-ir-dll-import.cpp +++ b/source/slang/slang-ir-dll-import.cpp @@ -198,7 +198,8 @@ struct DllImportContext processFunc(as<IRFunc>(childFunc), dllImportDecoration); } break; - default: break; + default: + break; } } } diff --git a/source/slang/slang-ir-eliminate-multilevel-break.cpp b/source/slang/slang-ir-eliminate-multilevel-break.cpp index 864170330..a54d1b46d 100644 --- a/source/slang/slang-ir-eliminate-multilevel-break.cpp +++ b/source/slang/slang-ir-eliminate-multilevel-break.cpp @@ -31,9 +31,12 @@ struct EliminateMultiLevelBreakContext { switch (headerInst->getOp()) { - case kIROp_loop: return as<IRLoop>(headerInst)->getBreakBlock(); - case kIROp_Switch: return as<IRSwitch>(headerInst)->getBreakLabel(); - default: SLANG_UNREACHABLE("Unknown breakable inst"); + case kIROp_loop: + return as<IRLoop>(headerInst)->getBreakBlock(); + case kIROp_Switch: + return as<IRSwitch>(headerInst)->getBreakLabel(); + default: + SLANG_UNREACHABLE("Unknown breakable inst"); } } @@ -47,7 +50,8 @@ struct EliminateMultiLevelBreakContext case kIROp_Switch: builder->replaceOperand(&(as<IRSwitch>(headerInst)->breakLabel), block); break; - default: SLANG_UNREACHABLE("Unknown breakable inst"); + default: + SLANG_UNREACHABLE("Unknown breakable inst"); } } @@ -115,7 +119,8 @@ struct EliminateMultiLevelBreakContext } continue; } - default: break; + default: + break; } for (auto succ : block->getSuccessors()) { @@ -149,7 +154,8 @@ struct EliminateMultiLevelBreakContext regions.add(regionInfo); } break; - default: break; + default: + break; } } for (auto& l : regions) diff --git a/source/slang/slang-ir-eliminate-phis.cpp b/source/slang/slang-ir-eliminate-phis.cpp index 5fbe07997..1ea1673f4 100644 --- a/source/slang/slang-ir-eliminate-phis.cpp +++ b/source/slang/slang-ir-eliminate-phis.cpp @@ -99,10 +99,12 @@ struct PhiEliminationContext { switch (inst->getOp()) { - default: continue; + default: + continue; case kIROp_Func: - case kIROp_GlobalVar: break; + case kIROp_GlobalVar: + break; } auto code = (IRGlobalValueWithCode*)inst; @@ -157,7 +159,8 @@ struct PhiEliminationContext switch (inst->getOp()) { - case kIROp_Param: continue; + case kIROp_Param: + continue; case kIROp_UpdateElement: { auto updateInst = as<IRUpdateElement>(inst); @@ -179,7 +182,8 @@ struct PhiEliminationContext builder.emitStore(elementAddr, updateInst->getElementValue()); } break; - default: break; + default: + break; } } } @@ -967,8 +971,10 @@ struct PhiEliminationContext switch (addr->getOp()) { case kIROp_Var: - case kIROp_Param: break; - default: return false; + case kIROp_Param: + break; + default: + return false; } for (auto inst = load; inst; inst = inst->getNextInst()) { diff --git a/source/slang/slang-ir-entry-point-uniforms.cpp b/source/slang/slang-ir-entry-point-uniforms.cpp index dbb44c381..0dfdc2d8e 100644 --- a/source/slang/slang-ir-entry-point-uniforms.cpp +++ b/source/slang/slang-ir-entry-point-uniforms.cpp @@ -126,7 +126,8 @@ bool isVaryingResourceKind(LayoutResourceKind kind) // Ray-tracing shader input/output: case LayoutResourceKind::CallablePayload: case LayoutResourceKind::HitAttributes: - case LayoutResourceKind::RayPayload: return true; + case LayoutResourceKind::RayPayload: + return true; } } diff --git a/source/slang/slang-ir-explicit-global-context.cpp b/source/slang/slang-ir-explicit-global-context.cpp index df8c3186c..d891263cd 100644 --- a/source/slang/slang-ir-explicit-global-context.cpp +++ b/source/slang/slang-ir-explicit-global-context.cpp @@ -91,8 +91,10 @@ struct IntroduceExplicitGlobalContextPass case kIROp_VulkanCallablePayloadDecoration: case kIROp_VulkanCallablePayloadInDecoration: case kIROp_VulkanHitObjectAttributesDecoration: - case kIROp_VulkanHitAttributesDecoration: return false; - default: continue; + case kIROp_VulkanHitAttributesDecoration: + return false; + default: + continue; }; } } diff --git a/source/slang/slang-ir-extract-value-from-type.cpp b/source/slang/slang-ir-extract-value-from-type.cpp index 8f7d4ac04..919274863 100644 --- a/source/slang/slang-ir-extract-value-from-type.cpp +++ b/source/slang/slang-ir-extract-value-from-type.cpp @@ -238,11 +238,20 @@ IRInst* extractMultiByteValueAtOffset( uint32_t bitMask = 0; switch (size) { - case 1: bitMask = 0xFF; break; - case 2: bitMask = 0xFFFFF; break; - case 3: bitMask = 0xFFFFFF; break; - case 4: bitMask = 0xFFFFFFFF; break; - default: break; + case 1: + bitMask = 0xFF; + break; + case 2: + bitMask = 0xFFFFF; + break; + case 3: + bitMask = 0xFFFFFF; + break; + case 4: + bitMask = 0xFFFFFFFF; + break; + default: + break; } if (leaf.valueSize != size) { diff --git a/source/slang/slang-ir-generics-lowering-context.cpp b/source/slang/slang-ir-generics-lowering-context.cpp index e02b54ecc..097fa58b8 100644 --- a/source/slang/slang-ir-generics-lowering-context.cpp +++ b/source/slang/slang-ir-generics-lowering-context.cpp @@ -16,7 +16,8 @@ bool isPolymorphicType(IRInst* typeInst) case kIROp_ThisType: case kIROp_AssociatedType: case kIROp_InterfaceType: - case kIROp_LookupWitness: return true; + case kIROp_LookupWitness: + return true; case kIROp_Specialize: { for (UInt i = 0; i < typeInst->getOperandCount(); i++) @@ -26,7 +27,8 @@ bool isPolymorphicType(IRInst* typeInst) } return false; } - default: break; + default: + break; } if (auto ptrType = as<IRPtrTypeBase>(typeInst)) { @@ -42,8 +44,10 @@ bool isTypeValue(IRInst* typeInst) switch (typeInst->getOp()) { case kIROp_TypeType: - case kIROp_TypeKind: return true; - default: return false; + case kIROp_TypeKind: + return true; + default: + return false; } } return false; diff --git a/source/slang/slang-ir-glsl-legalize.cpp b/source/slang/slang-ir-glsl-legalize.cpp index 80a4270e5..3f3f2dbe0 100644 --- a/source/slang/slang-ir-glsl-legalize.cpp +++ b/source/slang/slang-ir-glsl-legalize.cpp @@ -222,7 +222,8 @@ static void leafAddressesImpl(List<IRInst*>& ret, const ScalarizedVal& v) switch (v.flavor) { case ScalarizedVal::Flavor::none: - case ScalarizedVal::Flavor::value: break; + case ScalarizedVal::Flavor::value: + break; case ScalarizedVal::Flavor::address: { @@ -630,7 +631,9 @@ GLSLSystemValueInfo* getGLSLSystemValueInfo( switch (context->getStage()) { - default: name = "gl_PrimitiveID"; break; + default: + name = "gl_PrimitiveID"; + break; case Stage::Geometry: // GLSL makes a confusing design choice here. @@ -662,9 +665,13 @@ GLSLSystemValueInfo* getGLSLSystemValueInfo( switch (context->getStage()) { - case Stage::Geometry: context->requireGLSLVersion(ProfileVersion::GLSL_150); break; + case Stage::Geometry: + context->requireGLSLVersion(ProfileVersion::GLSL_150); + break; - case Stage::Fragment: context->requireGLSLVersion(ProfileVersion::GLSL_430); break; + case Stage::Fragment: + context->requireGLSLVersion(ProfileVersion::GLSL_430); + break; default: context->requireGLSLVersion(ProfileVersion::GLSL_450); @@ -924,7 +931,8 @@ void createVarLayoutForLegalizedGlobalParam( case GLSLSystemValueKind::PositionInput: builder->addGLPositionInputDecoration(globalParam); break; - default: break; + default: + break; } } } @@ -1603,10 +1611,17 @@ ScalarizedVal createGLSLGlobalVaryingsImpl( switch (type->getOp()) { using F = GlobalVaryingDeclarator::Flavor; - case kIROp_VerticesType: arrayDeclarator.flavor = F::meshOutputVertices; break; - case kIROp_IndicesType: arrayDeclarator.flavor = F::meshOutputIndices; break; - case kIROp_PrimitivesType: arrayDeclarator.flavor = F::meshOutputPrimitives; break; - default: SLANG_UNEXPECTED("Unhandled mesh output type"); + case kIROp_VerticesType: + arrayDeclarator.flavor = F::meshOutputVertices; + break; + case kIROp_IndicesType: + arrayDeclarator.flavor = F::meshOutputIndices; + break; + case kIROp_PrimitivesType: + arrayDeclarator.flavor = F::meshOutputPrimitives; + break; + default: + SLANG_UNEXPECTED("Unhandled mesh output type"); } arrayDeclarator.elementCount = meshOutputType->getMaxElementCount(); arrayDeclarator.next = declarator; @@ -1862,7 +1877,9 @@ ScalarizedVal extractField( return es[fieldIndex].val; } - default: SLANG_UNEXPECTED("unimplemented"); UNREACHABLE_RETURN(ScalarizedVal()); + default: + SLANG_UNEXPECTED("unimplemented"); + UNREACHABLE_RETURN(ScalarizedVal()); } } @@ -1926,7 +1943,9 @@ ScalarizedVal adaptType( return adaptType(builder, element, toType, fromType); } break; - default: SLANG_UNEXPECTED("unimplemented"); UNREACHABLE_RETURN(ScalarizedVal()); + default: + SLANG_UNEXPECTED("unimplemented"); + UNREACHABLE_RETURN(ScalarizedVal()); } } @@ -2001,7 +2020,9 @@ void assign( break; } - default: SLANG_UNEXPECTED("unimplemented"); break; + default: + SLANG_UNEXPECTED("unimplemented"); + break; } break; } @@ -2101,7 +2122,9 @@ ScalarizedVal getSubscriptVal( return ScalarizedVal::typeAdapter(resultAdapter); } - default: SLANG_UNEXPECTED("unimplemented"); UNREACHABLE_RETURN(ScalarizedVal()); + default: + SLANG_UNEXPECTED("unimplemented"); + UNREACHABLE_RETURN(ScalarizedVal()); } } @@ -2180,7 +2203,8 @@ IRInst* materializeValue(IRBuilder* builder, ScalarizedVal const& val) { switch (val.flavor) { - case ScalarizedVal::Flavor::value: return val.irValue; + case ScalarizedVal::Flavor::value: + return val.irValue; case ScalarizedVal::Flavor::address: { @@ -2219,7 +2243,9 @@ IRInst* materializeValue(IRBuilder* builder, ScalarizedVal const& val) } break; - default: SLANG_UNEXPECTED("unimplemented"); break; + default: + SLANG_UNEXPECTED("unimplemented"); + break; } } @@ -2372,7 +2398,8 @@ static void legalizeMeshOutputParam( break; case ScalarizedVal::Flavor::value: case ScalarizedVal::Flavor::address: - case ScalarizedVal::Flavor::typeAdapter: break; + case ScalarizedVal::Flavor::typeAdapter: + break; } // @@ -2698,8 +2725,11 @@ IRInst* getOrCreatePerVertexInputArray(GLSLLegalizationContext* context, IRInst* { switch (decoration->getOp()) { - case kIROp_InterpolationModeDecoration: continue; - default: cloneDecoration(decoration, arrayInst); break; + case kIROp_InterpolationModeDecoration: + continue; + default: + cloneDecoration(decoration, arrayInst); + break; } } return arrayInst; @@ -2992,7 +3022,8 @@ void legalizeEntryPointParameterForGLSL( // switch (stage) { - default: break; + default: + break; case Stage::AnyHit: case Stage::Callable: @@ -3064,9 +3095,11 @@ void legalizeEntryPointParameterForGLSL( switch (terminatorInst->getOp()) { - default: continue; + default: + continue; - case kIROp_Return: break; + case kIROp_Return: + break; } // We dont' re-use `builder` here because we don't want to @@ -3163,7 +3196,8 @@ void legalizeEntryPointParameterForGLSL( } break; } - default: break; + default: + break; } continue; } @@ -3301,7 +3335,8 @@ void assignRayPayloadHitObjectAttributeLocations(IRModule* module) decor->setOperand(0, location); hitObjectAttributeCounter++; goto assignRayPayloadHitObjectAttributeLocations_end; - default: break; + default: + break; } } assignRayPayloadHitObjectAttributeLocations_end:; @@ -3592,14 +3627,29 @@ void decorateModuleWithSPIRVVersion(IRModule* module, SemanticVersion spirvVersi { switch (spirvVersion.m_minor) { - case 0: atom = CapabilityName::_spirv_1_0; break; - case 1: atom = CapabilityName::_spirv_1_1; break; - case 2: atom = CapabilityName::_spirv_1_2; break; - case 3: atom = CapabilityName::_spirv_1_3; break; - case 4: atom = CapabilityName::_spirv_1_4; break; - case 5: atom = CapabilityName::_spirv_1_5; break; - case 6: atom = CapabilityName::_spirv_1_6; break; - default: SLANG_UNEXPECTED("Unknown SPIRV version"); + case 0: + atom = CapabilityName::_spirv_1_0; + break; + case 1: + atom = CapabilityName::_spirv_1_1; + break; + case 2: + atom = CapabilityName::_spirv_1_2; + break; + case 3: + atom = CapabilityName::_spirv_1_3; + break; + case 4: + atom = CapabilityName::_spirv_1_4; + break; + case 5: + atom = CapabilityName::_spirv_1_5; + break; + case 6: + atom = CapabilityName::_spirv_1_6; + break; + default: + SLANG_UNEXPECTED("Unknown SPIRV version"); } break; } diff --git a/source/slang/slang-ir-glsl-liveness.cpp b/source/slang/slang-ir-glsl-liveness.cpp index 953e4e8ff..626313b38 100644 --- a/source/slang/slang-ir-glsl-liveness.cpp +++ b/source/slang/slang-ir-glsl-liveness.cpp @@ -39,9 +39,12 @@ struct GLSLLivenessContext { switch (op) { - case kIROp_LiveRangeStart: return Kind::Start; - case kIROp_LiveRangeEnd: return Kind::End; - default: break; + case kIROp_LiveRangeStart: + return Kind::Start; + case kIROp_LiveRangeEnd: + return Kind::End; + default: + break; } SLANG_UNREACHABLE("Invalid op"); } diff --git a/source/slang/slang-ir-init-local-var.cpp b/source/slang/slang-ir-init-local-var.cpp index 73120075b..2910fa05a 100644 --- a/source/slang/slang-ir-init-local-var.cpp +++ b/source/slang/slang-ir-init-local-var.cpp @@ -32,7 +32,8 @@ void initializeLocalVariables(IRModule* module, IRGlobalValueWithCode* func) initialized = true; break; case kIROp_GetElementPtr: - case kIROp_FieldAddress: continue; + case kIROp_FieldAddress: + continue; default: if (userSet.contains(nextInst)) { diff --git a/source/slang/slang-ir-inline.cpp b/source/slang/slang-ir-inline.cpp index 1490446d5..73cf6eb39 100644 --- a/source/slang/slang-ir-inline.cpp +++ b/source/slang/slang-ir-inline.cpp @@ -256,7 +256,8 @@ struct InliningPassBase { switch (decor->getOp()) { - case kIROp_IntrinsicOpDecoration: return true; + case kIROp_IntrinsicOpDecoration: + return true; } } @@ -766,7 +767,8 @@ struct TypeInliningPass : InliningPassBase { return true; } - default: break; + default: + break; } return false; @@ -885,10 +887,15 @@ struct PreAutoDiffForceInliningPass : InliningPassBase switch (decor->getOp()) { case kIROp_UnsafeForceInlineEarlyDecoration: - case kIROp_IntrinsicOpDecoration: return true; - case kIROp_ForceInlineDecoration: hasForceInline = true; break; + case kIROp_IntrinsicOpDecoration: + return true; + case kIROp_ForceInlineDecoration: + hasForceInline = true; + break; case kIROp_UserDefinedBackwardDerivativeDecoration: - case kIROp_ForwardDerivativeDecoration: hasUserDefinedDerivative = true; break; + case kIROp_ForwardDerivativeDecoration: + hasUserDefinedDerivative = true; + break; } } if (!hasForceInline || hasUserDefinedDerivative) @@ -908,10 +915,14 @@ struct PreAutoDiffForceInliningPass : InliningPassBase case kIROp_ForwardDifferentiate: case kIROp_BackwardDifferentiate: case kIROp_BackwardDifferentiatePrimal: - case kIROp_BackwardDifferentiatePropagate: canInline = false; goto end; + case kIROp_BackwardDifferentiatePropagate: + canInline = false; + goto end; // Also avoid inlining functions with inline-asm instructions. - case kIROp_SPIRVAsm: canInline = false; goto end; + case kIROp_SPIRVAsm: + canInline = false; + goto end; } } } @@ -1008,11 +1019,15 @@ struct IntrinsicFunctionInliningPass : InliningPassBase switch (inst->getOp()) { case kIROp_SPIRVAsmOperandInst: - case kIROp_SPIRVAsm: hasSpvAsm = true; continue; + case kIROp_SPIRVAsm: + hasSpvAsm = true; + continue; case kIROp_Load: case kIROp_swizzle: - case kIROp_Store: continue; - default: return false; + case kIROp_Store: + continue; + default: + return false; } } return hasSpvAsm; diff --git a/source/slang/slang-ir-insert-debug-value-store.cpp b/source/slang/slang-ir-insert-debug-value-store.cpp index 338ee128c..b5486e891 100644 --- a/source/slang/slang-ir-insert-debug-value-store.cpp +++ b/source/slang/slang-ir-insert-debug-value-store.cpp @@ -16,8 +16,10 @@ struct DebugValueStoreContext switch (inst->getOp()) { case kIROp_TypeKind: - case kIROp_TypeType: return true; - default: return false; + case kIROp_TypeType: + return true; + default: + return false; } } bool isDebuggableType(IRType* type) @@ -28,7 +30,8 @@ struct DebugValueStoreContext bool debuggable = false; switch (type->getOp()) { - case kIROp_VoidType: break; + case kIROp_VoidType: + break; case kIROp_StructType: { auto structType = static_cast<IRStructType*>(type); @@ -53,7 +56,9 @@ struct DebugValueStoreContext } case kIROp_VectorType: case kIROp_MatrixType: - case kIROp_PtrType: debuggable = true; break; + case kIROp_PtrType: + debuggable = true; + break; case kIROp_Param: // Assume generic parameters are debuggable. debuggable = true; diff --git a/source/slang/slang-ir-inst-pass-base.h b/source/slang/slang-ir-inst-pass-base.h index 304d34527..5ce73f617 100644 --- a/source/slang/slang-ir-inst-pass-base.h +++ b/source/slang/slang-ir-inst-pass-base.h @@ -136,8 +136,10 @@ public: { case kIROp_GenericSpecializationDictionary: case kIROp_ExistentialFuncSpecializationDictionary: - case kIROp_ExistentialTypeSpecializationDictionary: continue; - default: break; + case kIROp_ExistentialTypeSpecializationDictionary: + continue; + default: + break; } SLANG_ASSERT(child); if (shouldInstBeLiveIfParentIsLive(child, IRDeadCodeEliminationOptions())) diff --git a/source/slang/slang-ir-layout.cpp b/source/slang/slang-ir-layout.cpp index fb887ab73..52810cb2e 100644 --- a/source/slang/slang-ir-layout.cpp +++ b/source/slang/slang-ir-layout.cpp @@ -95,7 +95,9 @@ static Result _calcSizeAndAlignment( case CodeGenTarget::HostCPPSource: case CodeGenTarget::HostHostCallable: case CodeGenTarget::HostExecutable: - case CodeGenTarget::HostSharedLibrary: kPointerSize = (int)sizeof(void*); break; + case CodeGenTarget::HostSharedLibrary: + kPointerSize = (int)sizeof(void*); + break; } switch (type->getOp()) @@ -360,7 +362,8 @@ static Result _calcSizeAndAlignment( attributedType->getBaseType(), outSizeAndAlignment); } - default: break; + default: + break; } if (as<IRResourceTypeBase>(type) || as<IRSamplerStateTypeBase>(type)) { @@ -650,11 +653,16 @@ IRTypeLayoutRules* IRTypeLayoutRules::get(IRTypeLayoutRuleName name) { switch (name) { - case IRTypeLayoutRuleName::Std430: return getStd430(); - case IRTypeLayoutRuleName::Std140: return getStd140(); - case IRTypeLayoutRuleName::Natural: return getNatural(); - case IRTypeLayoutRuleName::D3DConstantBuffer: return getConstantBuffer(); - default: return nullptr; + case IRTypeLayoutRuleName::Std430: + return getStd430(); + case IRTypeLayoutRuleName::Std140: + return getStd140(); + case IRTypeLayoutRuleName::Natural: + return getNatural(); + case IRTypeLayoutRuleName::D3DConstantBuffer: + return getConstantBuffer(); + default: + return nullptr; } } diff --git a/source/slang/slang-ir-legalize-image-subscript.cpp b/source/slang/slang-ir-legalize-image-subscript.cpp index 74702a646..e4b3a2ad5 100644 --- a/source/slang/slang-ir-legalize-image-subscript.cpp +++ b/source/slang/slang-ir-legalize-image-subscript.cpp @@ -173,7 +173,8 @@ void legalizeStore( } } break; - default: break; + default: + break; } } void legalizeImageSubscript(TargetRequest* target, IRModule* module, DiagnosticSink* sink) diff --git a/source/slang/slang-ir-legalize-types.cpp b/source/slang/slang-ir-legalize-types.cpp index 9a10a1901..2af3c4c09 100644 --- a/source/slang/slang-ir-legalize-types.cpp +++ b/source/slang/slang-ir-legalize-types.cpp @@ -208,11 +208,16 @@ struct LegalCallBuilder switch (val.flavor) { - case LegalVal::Flavor::none: break; + case LegalVal::Flavor::none: + break; - case LegalVal::Flavor::simple: m_args.add(val.getSimple()); break; + case LegalVal::Flavor::simple: + m_args.add(val.getSimple()); + break; - case LegalVal::Flavor::implicitDeref: addArg(val.getImplicitDeref()); break; + case LegalVal::Flavor::implicitDeref: + addArg(val.getImplicitDeref()); + break; case LegalVal::Flavor::pair: { @@ -232,7 +237,9 @@ struct LegalCallBuilder } break; - default: SLANG_UNEXPECTED("uhandled val flavor"); break; + default: + SLANG_UNEXPECTED("uhandled val flavor"); + break; } } @@ -385,7 +392,8 @@ private: // The remaining cases are a straightforward structural recursion // on top of the base case above. - case LegalType::Flavor::none: return LegalVal(); + case LegalType::Flavor::none: + return LegalVal(); case LegalVal::Flavor::implicitDeref: return LegalVal::implicitDeref(_addOutArg(resultType.getImplicitDeref()->valueType)); @@ -486,7 +494,9 @@ struct LegalReturnBuilder builder->emitReturn(); break; - case LegalVal::Flavor::implicitDeref: returnVal(val.getImplicitDeref()); break; + case LegalVal::Flavor::implicitDeref: + returnVal(val.getImplicitDeref()); + break; case LegalVal::Flavor::pair: { @@ -629,9 +639,12 @@ private: // The remaining cases are just a straightforward recursion // over the structure of the `val`. - case LegalVal::Flavor::none: break; + case LegalVal::Flavor::none: + break; - case LegalVal::Flavor::implicitDeref: _writeResultParam(val.getImplicitDeref()); break; + case LegalVal::Flavor::implicitDeref: + _writeResultParam(val.getImplicitDeref()); + break; case LegalVal::Flavor::pair: { @@ -678,7 +691,9 @@ static void _addVal(ShortList<IRInst*>& rs, const LegalVal& legalVal) { switch (legalVal.flavor) { - case LegalVal::Flavor::simple: rs.add(legalVal.getSimple()); break; + case LegalVal::Flavor::simple: + rs.add(legalVal.getSimple()); + break; case LegalVal::Flavor::tuple: for (auto element : legalVal.getTuple()->elements) _addVal(rs, element.val); @@ -687,8 +702,10 @@ static void _addVal(ShortList<IRInst*>& rs, const LegalVal& legalVal) _addVal(rs, legalVal.getPair()->ordinaryVal); _addVal(rs, legalVal.getPair()->specialVal); break; - case LegalVal::Flavor::none: break; - default: SLANG_UNEXPECTED("unhandled legalized val flavor"); + case LegalVal::Flavor::none: + break; + default: + SLANG_UNEXPECTED("unhandled legalized val flavor"); } } @@ -702,8 +719,11 @@ static LegalVal legalizeUnconditionalBranch( { switch (arg.flavor) { - case LegalVal::Flavor::none: break; - case LegalVal::Flavor::simple: newArgs.add(arg.getSimple()); break; + case LegalVal::Flavor::none: + break; + case LegalVal::Flavor::simple: + newArgs.add(arg.getSimple()); + break; case LegalVal::Flavor::pair: _addVal(newArgs, arg.getPair()->ordinaryVal); _addVal(newArgs, arg.getPair()->specialVal); @@ -714,7 +734,8 @@ static LegalVal legalizeUnconditionalBranch( _addVal(newArgs, element.val); } break; - default: SLANG_UNIMPLEMENTED_X("Unknown legalized val flavor."); + default: + SLANG_UNIMPLEMENTED_X("Unknown legalized val flavor."); } } context->builder->emitIntrinsicInst( @@ -729,7 +750,8 @@ static LegalVal legalizeLoad(IRTypeLegalizationContext* context, LegalVal legalP { switch (legalPtrVal.flavor) { - case LegalVal::Flavor::none: return LegalVal(); + case LegalVal::Flavor::none: + return LegalVal(); case LegalVal::Flavor::simple: { @@ -771,7 +793,9 @@ static LegalVal legalizeLoad(IRTypeLegalizationContext* context, LegalVal legalP } break; - default: SLANG_UNEXPECTED("unhandled case"); break; + default: + SLANG_UNEXPECTED("unhandled case"); + break; } } @@ -782,10 +806,16 @@ static LegalVal legalizePrintf(IRTypeLegalizationContext* context, ArrayView<Leg { switch (arg.flavor) { - case LegalVal::Flavor::none: break; - case LegalVal::Flavor::simple: legalArgs.add(arg.getSimple()); break; - case LegalVal::Flavor::pair: legalArgs.add(arg.getPair()->ordinaryVal.getSimple()); break; - default: SLANG_UNIMPLEMENTED_X("Unknown legalized val flavor for printf operand"); + case LegalVal::Flavor::none: + break; + case LegalVal::Flavor::simple: + legalArgs.add(arg.getSimple()); + break; + case LegalVal::Flavor::pair: + legalArgs.add(arg.getPair()->ordinaryVal.getSimple()); + break; + default: + SLANG_UNIMPLEMENTED_X("Unknown legalized val flavor for printf operand"); } } return LegalVal::simple(context->builder->emitIntrinsicInst( @@ -815,7 +845,8 @@ static LegalVal legalizeDebugVar( copyNameHintAndDebugDecorations(legalVal, originalInst); return LegalVal::simple(legalVal); } - case LegalType::Flavor::none: return LegalVal(); + case LegalType::Flavor::none: + return LegalVal(); case LegalType::Flavor::pair: { auto pairType = type.getPair(); @@ -833,7 +864,8 @@ static LegalVal legalizeDebugVar( } return LegalVal(); } - default: return LegalVal(); + default: + return LegalVal(); } } @@ -849,7 +881,8 @@ static LegalVal legalizeDebugValue( case LegalType::Flavor::simple: return LegalVal::simple( context->builder->emitDebugValue(debugVar.getSimple(), debugValue.getSimple())); - case LegalType::Flavor::none: return LegalVal(); + case LegalType::Flavor::none: + return LegalVal(); case LegalType::Flavor::pair: { auto ordinaryVal = legalizeDebugValue( @@ -870,7 +903,8 @@ static LegalVal legalizeDebugValue( } return LegalVal(); } - default: return LegalVal(); + default: + return LegalVal(); } } @@ -881,7 +915,8 @@ static LegalVal legalizeStore( { switch (legalPtrVal.flavor) { - case LegalVal::Flavor::none: return LegalVal(); + case LegalVal::Flavor::none: + return LegalVal(); case LegalVal::Flavor::simple: { @@ -936,7 +971,9 @@ static LegalVal legalizeStore( } break; - default: SLANG_UNEXPECTED("unhandled case"); break; + default: + SLANG_UNEXPECTED("unhandled case"); + break; } } @@ -953,7 +990,8 @@ static LegalVal legalizeFieldExtract( switch (legalStructOperand.flavor) { - case LegalVal::Flavor::none: return LegalVal(); + case LegalVal::Flavor::none: + return LegalVal(); case LegalVal::Flavor::simple: return LegalVal::simple( @@ -1027,7 +1065,9 @@ static LegalVal legalizeFieldExtract( UNREACHABLE_RETURN(LegalVal()); } - default: SLANG_UNEXPECTED("unhandled"); UNREACHABLE_RETURN(LegalVal()); + default: + SLANG_UNEXPECTED("unhandled"); + UNREACHABLE_RETURN(LegalVal()); } } @@ -1065,7 +1105,8 @@ static LegalVal unwrapBufferValue( UNREACHABLE_RETURN(LegalVal()); break; - case LegalElementWrapping::Flavor::none: return LegalVal(); + case LegalElementWrapping::Flavor::none: + return LegalVal(); case LegalElementWrapping::Flavor::simple: { @@ -1156,12 +1197,14 @@ static LegalType getPointedToType(IRTypeLegalizationContext* context, LegalType { switch (type.flavor) { - case LegalType::Flavor::none: return LegalType(); + case LegalType::Flavor::none: + return LegalType(); case LegalType::Flavor::simple: return LegalType::simple(getPointedToType(context, type.getSimple())); - case LegalType::Flavor::implicitDeref: return type.getImplicitDeref()->valueType; + case LegalType::Flavor::implicitDeref: + return type.getImplicitDeref()->valueType; case LegalType::Flavor::pair: { @@ -1203,7 +1246,8 @@ static LegalVal legalizeFieldAddress( switch (legalPtrOperand.flavor) { - case LegalVal::Flavor::none: return LegalVal(); + case LegalVal::Flavor::none: + return LegalVal(); case LegalVal::Flavor::simple: switch (type.flavor) @@ -1304,7 +1348,9 @@ static LegalVal legalizeFieldAddress( legalizeFieldExtract(context, valueType, implicitDerefVal, fieldKey)); } - default: SLANG_UNEXPECTED("unhandled"); UNREACHABLE_RETURN(LegalVal()); + default: + SLANG_UNEXPECTED("unhandled"); + UNREACHABLE_RETURN(LegalVal()); } } @@ -1331,7 +1377,8 @@ static LegalVal legalizeGetElement( switch (legalPtrOperand.flavor) { - case LegalVal::Flavor::none: return LegalVal(); + case LegalVal::Flavor::none: + return LegalVal(); case LegalVal::Flavor::simple: return LegalVal::simple(builder->emitElementExtract( @@ -1397,7 +1444,9 @@ static LegalVal legalizeGetElement( return LegalVal::tuple(resTupleInfo); } - default: SLANG_UNEXPECTED("unhandled"); UNREACHABLE_RETURN(LegalVal()); + default: + SLANG_UNEXPECTED("unhandled"); + UNREACHABLE_RETURN(LegalVal()); } } @@ -1424,7 +1473,8 @@ static LegalVal legalizeGetElementPtr( switch (legalPtrOperand.flavor) { - case LegalVal::Flavor::none: return LegalVal(); + case LegalVal::Flavor::none: + return LegalVal(); case LegalVal::Flavor::simple: return LegalVal::simple(builder->emitElementAddress( @@ -1509,7 +1559,9 @@ static LegalVal legalizeGetElementPtr( legalizeGetElement(context, valueType, implicitDerefVal, indexOperand)); } - default: SLANG_UNEXPECTED("unhandled"); UNREACHABLE_RETURN(LegalVal()); + default: + SLANG_UNEXPECTED("unhandled"); + UNREACHABLE_RETURN(LegalVal()); } } @@ -1536,7 +1588,8 @@ static LegalVal legalizeMakeStruct( switch (legalType.flavor) { - case LegalType::Flavor::none: return LegalVal(); + case LegalType::Flavor::none: + return LegalVal(); case LegalType::Flavor::simple: { @@ -1636,7 +1689,9 @@ static LegalVal legalizeMakeStruct( return LegalVal::tuple(resTupleInfo); } - default: SLANG_UNEXPECTED("unhandled"); UNREACHABLE_RETURN(LegalVal()); + default: + SLANG_UNEXPECTED("unhandled"); + UNREACHABLE_RETURN(LegalVal()); } } @@ -1651,7 +1706,8 @@ static LegalVal legalizeMakeArray( switch (legalType.flavor) { - case LegalType::Flavor::none: return LegalVal(); + case LegalType::Flavor::none: + return LegalVal(); case LegalType::Flavor::simple: { @@ -1805,7 +1861,9 @@ static LegalVal legalizeMakeArray( return LegalVal::tuple(resTupleInfo); } - default: SLANG_UNEXPECTED("unhandled"); UNREACHABLE_RETURN(LegalVal()); + default: + SLANG_UNEXPECTED("unhandled"); + UNREACHABLE_RETURN(LegalVal()); } } @@ -1815,7 +1873,8 @@ static LegalVal legalizeDefaultConstruct(IRTypeLegalizationContext* context, Leg switch (legalType.flavor) { - case LegalType::Flavor::none: return LegalVal(); + case LegalType::Flavor::none: + return LegalVal(); case LegalType::Flavor::simple: { @@ -1853,7 +1912,9 @@ static LegalVal legalizeDefaultConstruct(IRTypeLegalizationContext* context, Leg return LegalVal::tuple(resTupleInfo); } - default: SLANG_UNEXPECTED("unhandled"); UNREACHABLE_RETURN(LegalVal()); + default: + SLANG_UNEXPECTED("unhandled"); + UNREACHABLE_RETURN(LegalVal()); } } @@ -1863,7 +1924,8 @@ static LegalVal coerceToLegalType(IRTypeLegalizationContext* context, LegalType { switch (type.flavor) { - case LegalType::Flavor::none: return LegalVal(); + case LegalType::Flavor::none: + return LegalVal(); case LegalType::Flavor::simple: { if (val.flavor != LegalVal::Flavor::simple) @@ -1978,7 +2040,8 @@ static LegalVal coerceToLegalType(IRTypeLegalizationContext* context, LegalType UNREACHABLE_RETURN(LegalVal()); } } - default: return val; + default: + return val; } } @@ -1991,26 +2054,44 @@ static LegalVal legalizeInst( LegalVal result = LegalVal(); switch (inst->getOp()) { - case kIROp_Load: result = legalizeLoad(context, args[0]); break; + case kIROp_Load: + result = legalizeLoad(context, args[0]); + break; - case kIROp_GetValueFromBoundInterface: result = args[0]; break; + case kIROp_GetValueFromBoundInterface: + result = args[0]; + break; - case kIROp_FieldAddress: result = legalizeFieldAddress(context, type, args[0], args[1]); break; + case kIROp_FieldAddress: + result = legalizeFieldAddress(context, type, args[0], args[1]); + break; - case kIROp_FieldExtract: result = legalizeFieldExtract(context, type, args[0], args[1]); break; + case kIROp_FieldExtract: + result = legalizeFieldExtract(context, type, args[0], args[1]); + break; - case kIROp_GetElement: result = legalizeGetElement(context, type, args[0], args[1]); break; + case kIROp_GetElement: + result = legalizeGetElement(context, type, args[0], args[1]); + break; case kIROp_GetElementPtr: result = legalizeGetElementPtr(context, type, args[0], args[1]); break; - case kIROp_Store: result = legalizeStore(context, args[0], args[1]); break; + case kIROp_Store: + result = legalizeStore(context, args[0], args[1]); + break; - case kIROp_Call: result = legalizeCall(context, (IRCall*)inst); break; - case kIROp_Return: result = legalizeRetVal(context, args[0], (IRReturn*)inst); break; + case kIROp_Call: + result = legalizeCall(context, (IRCall*)inst); + break; + case kIROp_Return: + result = legalizeRetVal(context, args[0], (IRReturn*)inst); + break; - case kIROp_DebugVar: result = legalizeDebugVar(context, type, (IRDebugVar*)inst); break; + case kIROp_DebugVar: + result = legalizeDebugVar(context, type, (IRDebugVar*)inst); + break; case kIROp_DebugValue: result = legalizeDebugValue(context, args[0], args[1], (IRDebugValue*)inst); break; @@ -2027,13 +2108,18 @@ static LegalVal legalizeInst( inst->getOperandCount(), inst->getOp()); break; - case kIROp_DefaultConstruct: result = legalizeDefaultConstruct(context, type); break; + case kIROp_DefaultConstruct: + result = legalizeDefaultConstruct(context, type); + break; case kIROp_unconditionalBranch: case kIROp_loop: result = legalizeUnconditionalBranch(context, args, (IRUnconditionalBranch*)inst); break; - case kIROp_Printf: result = legalizePrintf(context, args); break; - case kIROp_undefined: return LegalVal(); + case kIROp_Printf: + result = legalizePrintf(context, args); + break; + case kIROp_undefined: + return LegalVal(); case kIROp_GpuForeach: // This case should only happen when compiling for a target that does not support // GpuForeach @@ -2178,23 +2264,30 @@ static LegalVal legalizeInst(IRTypeLegalizationContext* context, IRInst* inst) // Special-case certain operations switch (inst->getOp()) { - case kIROp_Var: return legalizeLocalVar(context, cast<IRVar>(inst)); + case kIROp_Var: + return legalizeLocalVar(context, cast<IRVar>(inst)); - case kIROp_Param: return legalizeParam(context, cast<IRParam>(inst)); + case kIROp_Param: + return legalizeParam(context, cast<IRParam>(inst)); case kIROp_WitnessTable: // Just skip these. break; - case kIROp_Func: return legalizeFunc(context, cast<IRFunc>(inst)); + case kIROp_Func: + return legalizeFunc(context, cast<IRFunc>(inst)); - case kIROp_GlobalVar: return legalizeGlobalVar(context, cast<IRGlobalVar>(inst)); + case kIROp_GlobalVar: + return legalizeGlobalVar(context, cast<IRGlobalVar>(inst)); - case kIROp_GlobalParam: return legalizeGlobalParam(context, cast<IRGlobalParam>(inst)); + case kIROp_GlobalParam: + return legalizeGlobalParam(context, cast<IRGlobalParam>(inst)); - case kIROp_Block: return LegalVal::simple(inst); + case kIROp_Block: + return LegalVal::simple(inst); - default: break; + default: + break; } if (as<IRAttr>(inst)) @@ -2454,9 +2547,12 @@ private: switch (t.flavor) { - case LegalType::Flavor::none: break; + case LegalType::Flavor::none: + break; - case LegalType::Flavor::simple: m_paramTypes.add(t.getSimple()); break; + case LegalType::Flavor::simple: + m_paramTypes.add(t.getSimple()); + break; case LegalType::Flavor::implicitDeref: { @@ -2478,7 +2574,8 @@ private: _addParam(elem.type); } break; - default: SLANG_UNEXPECTED("unknown legalized type flavor"); + default: + SLANG_UNEXPECTED("unknown legalized type flavor"); } } @@ -2544,7 +2641,8 @@ private: } break; - default: SLANG_UNEXPECTED("unknown legalized type flavor"); + default: + SLANG_UNEXPECTED("unknown legalized type flavor"); } } @@ -2564,7 +2662,8 @@ private: // The remaining cases are all simple recursion on the // structure of `t`. - case LegalType::Flavor::none: break; + case LegalType::Flavor::none: + break; case LegalType::Flavor::implicitDeref: { @@ -2588,7 +2687,8 @@ private: } } break; - default: SLANG_UNEXPECTED("unknown legalized type flavor"); + default: + SLANG_UNEXPECTED("unknown legalized type flavor"); } } }; @@ -2607,9 +2707,12 @@ static void cloneDecorationToVar(IRInst* srcInst, IRInst* varInst) { case kIROp_FormatDecoration: case kIROp_UserTypeNameDecoration: - case kIROp_SemanticDecoration: cloneDecoration(decoration, varInst); break; + case kIROp_SemanticDecoration: + cloneDecoration(decoration, varInst); + break; - default: break; + default: + break; } } } @@ -2677,7 +2780,9 @@ static LegalVal declareSimpleVar( } break; - default: SLANG_UNEXPECTED("unexpected IR opcode"); break; + default: + SLANG_UNEXPECTED("unexpected IR opcode"); + break; } if (irVar) @@ -2955,7 +3060,9 @@ static void _addFieldsToWrappedBufferElementTypeLayout( } break; - default: SLANG_UNEXPECTED("unhandled element wrapping flavor"); break; + default: + SLANG_UNEXPECTED("unhandled element wrapping flavor"); + break; } } @@ -3330,7 +3437,8 @@ static LegalVal declareVars( switch (type.flavor) { - case LegalType::Flavor::none: return LegalVal(); + case LegalType::Flavor::none: + return LegalVal(); case LegalType::Flavor::simple: return declareSimpleVar( @@ -3975,7 +4083,8 @@ struct IREmptyTypeLegalizationContext : IRTypeLegalizationContext case kIROp_DllImportDecoration: case kIROp_DllExportDecoration: case kIROp_HLSLExportDecoration: - case kIROp_BinaryInterfaceTypeDecoration: return true; + case kIROp_BinaryInterfaceTypeDecoration: + return true; } } return false; diff --git a/source/slang/slang-ir-legalize-varying-params.cpp b/source/slang/slang-ir-legalize-varying-params.cpp index a710f0605..025bcf1b8 100644 --- a/source/slang/slang-ir-legalize-varying-params.cpp +++ b/source/slang/slang-ir-legalize-varying-params.cpp @@ -134,13 +134,18 @@ IRInst* materialize(IRBuilder& builder, LegalizedVaryingVal const& val) { switch (val.getFlavor()) { - case LegalizedVaryingVal::Flavor::None: return nullptr; // TODO: should use a `void` literal + case LegalizedVaryingVal::Flavor::None: + return nullptr; // TODO: should use a `void` literal - case LegalizedVaryingVal::Flavor::Value: return val.getValue(); + case LegalizedVaryingVal::Flavor::Value: + return val.getValue(); - case LegalizedVaryingVal::Flavor::Address: return builder.emitLoad(val.getAddress()); + case LegalizedVaryingVal::Flavor::Address: + return builder.emitLoad(val.getAddress()); - default: SLANG_UNEXPECTED("unimplemented"); break; + default: + SLANG_UNEXPECTED("unimplemented"); + break; } } @@ -148,13 +153,16 @@ void assign(IRBuilder& builder, LegalizedVaryingVal const& dest, LegalizedVaryin { switch (dest.getFlavor()) { - case LegalizedVaryingVal::Flavor::None: break; + case LegalizedVaryingVal::Flavor::None: + break; case LegalizedVaryingVal::Flavor::Address: builder.emitStore(dest.getAddress(), materialize(builder, src)); break; - default: SLANG_UNEXPECTED("unimplemented"); break; + default: + SLANG_UNEXPECTED("unimplemented"); + break; } } @@ -1263,7 +1271,8 @@ struct CUDAEntryPointVaryingParamLegalizeContext : EntryPointVaryingParamLegaliz return LegalizedVaryingVal::makeValue(groupThreadIndex); case SystemValueSemanticName::DispatchThreadID: return LegalizedVaryingVal::makeValue(dispatchThreadID); - default: return diagnoseUnsupportedSystemVal(info); + default: + return diagnoseUnsupportedSystemVal(info); } } @@ -1312,7 +1321,8 @@ struct CUDAEntryPointVaryingParamLegalizeContext : EntryPointVaryingParamLegaliz } return LegalizedVaryingVal::makeValue(getHitAttributes); } - default: return diagnoseUnsupportedUserVal(info); + default: + return diagnoseUnsupportedUserVal(info); } } }; @@ -1438,7 +1448,8 @@ struct CPUEntryPointVaryingParamLegalizeContext : EntryPointVaryingParamLegalize switch (info.systemValueSemanticName) { - case SystemValueSemanticName::GroupID: return LegalizedVaryingVal::makeValue(groupID); + case SystemValueSemanticName::GroupID: + return LegalizedVaryingVal::makeValue(groupID); case SystemValueSemanticName::GroupThreadID: return LegalizedVaryingVal::makeValue(groupThreadID); case SystemValueSemanticName::GroupIndex: @@ -1446,7 +1457,8 @@ struct CPUEntryPointVaryingParamLegalizeContext : EntryPointVaryingParamLegalize case SystemValueSemanticName::DispatchThreadID: return LegalizedVaryingVal::makeValue(dispatchThreadID); - default: return diagnoseUnsupportedSystemVal(info); + default: + return diagnoseUnsupportedSystemVal(info); } } }; diff --git a/source/slang/slang-ir-link.cpp b/source/slang/slang-ir-link.cpp index 52babe185..a764db117 100644 --- a/source/slang/slang-ir-link.cpp +++ b/source/slang/slang-ir-link.cpp @@ -225,7 +225,8 @@ IRInst* IRSpecContext::maybeCloneValue(IRInst* originalValue) case kIROp_InterfaceRequirementEntry: case kIROp_GlobalGenericParam: case kIROp_WitnessTable: - case kIROp_InterfaceType: return cloneGlobalValue(this, originalValue); + case kIROp_InterfaceType: + return cloneGlobalValue(this, originalValue); case kIROp_BoolLit: { @@ -404,7 +405,8 @@ static void cloneExtraDecorationsFromInst( { switch (decoration->getOp()) { - default: break; + default: + break; case kIROp_HLSLExportDecoration: case kIROp_BindExistentialSlotsDecoration: @@ -1153,8 +1155,10 @@ bool canInstContainBasicBlocks(IROp opcode) { switch (opcode) { - case kIROp_Expand: return true; - default: return false; + case kIROp_Expand: + return true; + default: + return false; } } @@ -1230,7 +1234,8 @@ IRInst* cloneInst( cast<IRGlobalGenericParam>(originalInst), originalValues); - default: break; + default: + break; } // The common case is that we just need to construct a cloned @@ -1484,8 +1489,10 @@ static bool doesFuncHaveDefinition(IRFunc* func) switch (decor->getOp()) { case kIROp_IntrinsicOpDecoration: - case kIROp_TargetIntrinsicDecoration: return true; - default: continue; + case kIROp_TargetIntrinsicDecoration: + return true; + default: + continue; } } return false; @@ -1529,7 +1536,8 @@ static bool doesTargetAllowUnresolvedFuncSymbol(TargetRequest* req) if (req->getOptionSet().getBoolOption(CompilerOptionName::IncompleteLibrary)) return true; return false; - default: return false; + default: + return false; } } @@ -1918,7 +1926,8 @@ LinkedIR linkIR(CodeGenContext* codeGenContext) } break; - default: break; + default: + break; } } } diff --git a/source/slang/slang-ir-liveness.cpp b/source/slang/slang-ir-liveness.cpp index 46d307f7f..91721e5ea 100644 --- a/source/slang/slang-ir-liveness.cpp +++ b/source/slang/slang-ir-liveness.cpp @@ -940,7 +940,8 @@ void LivenessContext::_findAliasesAndAccesses(IRInst* root) break; } - default: break; + default: + break; } // Make sure the access is through the alias (as opposed to some other part of the @@ -960,7 +961,8 @@ void LivenessContext::_findAliasesAndAccesses(IRInst* root) _addAccessInst(cur); break; } - default: break; + default: + break; } } } @@ -1084,7 +1086,9 @@ bool LivenessContext::_isAccessTerminator(IRTerminatorInst* terminator) case kIROp_CastIntToPtr: case kIROp_CastPtrToInt: case kIROp_CastPtrToBool: - case kIROp_PtrCast: val = val->getOperand(0); break; + case kIROp_PtrCast: + val = val->getOperand(0); + break; } // If it *is* the root it's an access diff --git a/source/slang/slang-ir-lower-binding-query.cpp b/source/slang/slang-ir-lower-binding-query.cpp index e54430cfa..0935f1e54 100644 --- a/source/slang/slang-ir-lower-binding-query.cpp +++ b/source/slang/slang-ir-lower-binding-query.cpp @@ -236,9 +236,11 @@ struct BindingQueryLoweringContext : public WorkListPass SLANG_UNEXPECTED("unhandled binding query instruction type"); UNREACHABLE_RETURN(query); - case kIROp_GetRegisterIndex: return opaqueValueInfo.registerIndex; + case kIROp_GetRegisterIndex: + return opaqueValueInfo.registerIndex; - case kIROp_GetRegisterSpace: return opaqueValueInfo.registerSpace; + case kIROp_GetRegisterSpace: + return opaqueValueInfo.registerSpace; } } @@ -309,7 +311,8 @@ struct BindingQueryLoweringContext : public WorkListPass { switch (offsetAttr->getResourceKind()) { - default: break; + default: + break; case LayoutResourceKind::ShaderResource: case LayoutResourceKind::UnorderedAccess: diff --git a/source/slang/slang-ir-lower-bit-cast.cpp b/source/slang/slang-ir-lower-bit-cast.cpp index aef4a6dfc..450ad8ac9 100644 --- a/source/slang/slang-ir-lower-bit-cast.cpp +++ b/source/slang/slang-ir-lower-bit-cast.cpp @@ -33,8 +33,11 @@ struct BitCastLoweringContext { switch (inst->getOp()) { - case kIROp_BitCast: processBitCast(inst); break; - default: break; + case kIROp_BitCast: + processBitCast(inst); + break; + default: + break; } } diff --git a/source/slang/slang-ir-lower-buffer-element-type.cpp b/source/slang/slang-ir-lower-buffer-element-type.cpp index 46243eba3..7d722bf9c 100644 --- a/source/slang/slang-ir-lower-buffer-element-type.cpp +++ b/source/slang/slang-ir-lower-buffer-element-type.cpp @@ -308,10 +308,14 @@ struct LoweredElementTypeContext { switch (name) { - case IRTypeLayoutRuleName::Std140: return "std140"; - case IRTypeLayoutRuleName::Std430: return "std430"; - case IRTypeLayoutRuleName::Natural: return "natural"; - default: return "default"; + case IRTypeLayoutRuleName::Std140: + return "std140"; + case IRTypeLayoutRuleName::Std430: + return "std430"; + case IRTypeLayoutRuleName::Natural: + return "natural"; + default: + return "default"; } } @@ -613,7 +617,8 @@ struct LoweredElementTypeContext return info; } } - default: break; + default: + break; } } @@ -957,8 +962,11 @@ struct LoweredElementTypeContext } break; case kIROp_RWStructuredBufferGetElementPtr: - case kIROp_GetOffsetPtr: ptrValsWorkList.add(user); break; - case kIROp_StructuredBufferGetDimensions: break; + case kIROp_GetOffsetPtr: + ptrValsWorkList.add(user); + break; + case kIROp_StructuredBufferGetDimensions: + break; case kIROp_Call: { // If a structured buffer or pointer typed value is used directly as @@ -991,7 +999,8 @@ struct LoweredElementTypeContext builder.emitStore(ptrVal, packedVal); } break; - default: break; + default: + break; } }); } @@ -1194,16 +1203,22 @@ IRTypeLayoutRules* getTypeLayoutRuleForBuffer(TargetProgram* target, IRType* buf : kIROp_DefaultBufferLayoutType; switch (layoutTypeOp) { - case kIROp_DefaultBufferLayoutType: return IRTypeLayoutRules::getStd430(); - case kIROp_Std140BufferLayoutType: return IRTypeLayoutRules::getStd140(); - case kIROp_Std430BufferLayoutType: return IRTypeLayoutRules::getStd430(); - case kIROp_ScalarBufferLayoutType: return IRTypeLayoutRules::getNatural(); + case kIROp_DefaultBufferLayoutType: + return IRTypeLayoutRules::getStd430(); + case kIROp_Std140BufferLayoutType: + return IRTypeLayoutRules::getStd140(); + case kIROp_Std430BufferLayoutType: + return IRTypeLayoutRules::getStd430(); + case kIROp_ScalarBufferLayoutType: + return IRTypeLayoutRules::getNatural(); } return IRTypeLayoutRules::getStd430(); } case kIROp_ConstantBufferType: - case kIROp_ParameterBlockType: return IRTypeLayoutRules::getStd140(); - case kIROp_PtrType: return IRTypeLayoutRules::getNatural(); + case kIROp_ParameterBlockType: + return IRTypeLayoutRules::getStd140(); + case kIROp_PtrType: + return IRTypeLayoutRules::getNatural(); } return IRTypeLayoutRules::getNatural(); } diff --git a/source/slang/slang-ir-lower-error-handling.cpp b/source/slang/slang-ir-lower-error-handling.cpp index e566e4a80..917658ac4 100644 --- a/source/slang/slang-ir-lower-error-handling.cpp +++ b/source/slang/slang-ir-lower-error-handling.cpp @@ -164,10 +164,17 @@ struct ErrorHandlingLoweringContext { switch (inst->getOp()) { - case kIROp_TryCall: processTryCall(cast<IRTryCall>(inst)); break; - case kIROp_Return: processReturn(cast<IRReturn>(inst)); break; - case kIROp_Throw: processThrow(cast<IRThrow>(inst)); break; - default: break; + case kIROp_TryCall: + processTryCall(cast<IRTryCall>(inst)); + break; + case kIROp_Return: + processReturn(cast<IRReturn>(inst)); + break; + case kIROp_Throw: + processThrow(cast<IRThrow>(inst)); + break; + default: + break; } } @@ -204,8 +211,11 @@ struct ErrorHandlingLoweringContext { switch (child->getOp()) { - case kIROp_FuncType: oldFuncTypes.add(cast<IRFuncType>(child)); break; - default: break; + case kIROp_FuncType: + oldFuncTypes.add(cast<IRFuncType>(child)); + break; + default: + break; } } for (auto funcType : oldFuncTypes) diff --git a/source/slang/slang-ir-lower-expand-type.cpp b/source/slang/slang-ir-lower-expand-type.cpp index 181b64567..6bd79737b 100644 --- a/source/slang/slang-ir-lower-expand-type.cpp +++ b/source/slang/slang-ir-lower-expand-type.cpp @@ -19,7 +19,8 @@ IRInst* clonePatternValImpl( switch (val->getOp()) { - case kIROp_ExpandTypeOrVal: return val; + case kIROp_ExpandTypeOrVal: + return val; case kIROp_Each: { auto eachInst = as<IREach>(val); @@ -33,7 +34,8 @@ IRInst* clonePatternValImpl( case kIROp_Specialize: case kIROp_LookupWitness: case kIROp_ExtractExistentialType: - case kIROp_ExtractExistentialWitnessTable: break; + case kIROp_ExtractExistentialWitnessTable: + break; default: // If the value is not a type, and it is not in a block, then it is some global inst // that shouldn't be deep copied into current block, such as a IRFunc. diff --git a/source/slang/slang-ir-lower-generic-function.cpp b/source/slang/slang-ir-lower-generic-function.cpp index 5c39b2124..f2b1d1a6a 100644 --- a/source/slang/slang-ir-lower-generic-function.cpp +++ b/source/slang/slang-ir-lower-generic-function.cpp @@ -76,8 +76,10 @@ struct GenericFunctionLoweringContext { switch (genericChild->getOp()) { - case kIROp_Func: continue; - case kIROp_Return: continue; + case kIROp_Func: + continue; + case kIROp_Return: + continue; } // Process all generic parameters and local type definitions. auto clonedChild = cloneInst(&cloneEnv, &builder, genericChild); @@ -95,7 +97,9 @@ struct GenericFunctionLoweringContext } break; case kIROp_Specialize: - case kIROp_LookupWitness: childrenToDemote.add(clonedChild); break; + case kIROp_LookupWitness: + childrenToDemote.add(clonedChild); + break; default: { bool shouldDemote = false; diff --git a/source/slang/slang-ir-lower-generic-type.cpp b/source/slang/slang-ir-lower-generic-type.cpp index 5cc297536..9579b0a2b 100644 --- a/source/slang/slang-ir-lower-generic-type.cpp +++ b/source/slang/slang-ir-lower-generic-type.cpp @@ -39,7 +39,8 @@ struct GenericTypeLoweringContext switch (inst->getOp()) { - default: break; + default: + break; case kIROp_StructField: { // Translate the struct field type. diff --git a/source/slang/slang-ir-lower-l-value-cast.cpp b/source/slang/slang-ir-lower-l-value-cast.cpp index 10dc0267f..3d3c15132 100644 --- a/source/slang/slang-ir-lower-l-value-cast.cpp +++ b/source/slang/slang-ir-lower-l-value-cast.cpp @@ -23,8 +23,11 @@ struct LValueCastLoweringContext switch (inst->getOp()) { case kIROp_InOutImplicitCast: - case kIROp_OutImplicitCast: _processLValueCast(inst); break; - default: break; + case kIROp_OutImplicitCast: + _processLValueCast(inst); + break; + default: + break; } } @@ -149,7 +152,8 @@ struct LValueCastLoweringContext } break; } - default: break; + default: + break; } // If we can't use the other mechanisms we are going to do a conversion diff --git a/source/slang/slang-ir-lower-optional-type.cpp b/source/slang/slang-ir-lower-optional-type.cpp index e6ae2eea3..5c9dcd722 100644 --- a/source/slang/slang-ir-lower-optional-type.cpp +++ b/source/slang/slang-ir-lower-optional-type.cpp @@ -80,9 +80,12 @@ struct OptionalTypeLoweringContext case kIROp_NativePtrType: case kIROp_NativeStringType: case kIROp_PtrType: - case kIROp_ClassType: return true; - case kIROp_InterfaceType: return isComInterfaceType((IRType*)type); - default: return false; + case kIROp_ClassType: + return true; + case kIROp_InterfaceType: + return isComInterfaceType((IRType*)type); + default: + return false; } } @@ -240,12 +243,23 @@ struct OptionalTypeLoweringContext { switch (inst->getOp()) { - case kIROp_MakeOptionalValue: processMakeOptionalValue((IRMakeOptionalValue*)inst); break; - case kIROp_MakeOptionalNone: processMakeOptionalNone((IRMakeOptionalNone*)inst); break; - case kIROp_OptionalHasValue: processGetOptionalHasValue((IROptionalHasValue*)inst); break; - case kIROp_GetOptionalValue: processGetOptionalValue((IRGetOptionalValue*)inst); break; - case kIROp_OptionalType: processOptionalType((IROptionalType*)inst); break; - default: break; + case kIROp_MakeOptionalValue: + processMakeOptionalValue((IRMakeOptionalValue*)inst); + break; + case kIROp_MakeOptionalNone: + processMakeOptionalNone((IRMakeOptionalNone*)inst); + break; + case kIROp_OptionalHasValue: + processGetOptionalHasValue((IROptionalHasValue*)inst); + break; + case kIROp_GetOptionalValue: + processGetOptionalValue((IRGetOptionalValue*)inst); + break; + case kIROp_OptionalType: + processOptionalType((IROptionalType*)inst); + break; + default: + break; } } diff --git a/source/slang/slang-ir-lower-reinterpret.cpp b/source/slang/slang-ir-lower-reinterpret.cpp index 9dd31aa4d..1b733d832 100644 --- a/source/slang/slang-ir-lower-reinterpret.cpp +++ b/source/slang/slang-ir-lower-reinterpret.cpp @@ -28,8 +28,11 @@ struct ReinterpretLoweringContext { switch (inst->getOp()) { - case kIROp_Reinterpret: processReinterpret(inst); break; - default: break; + case kIROp_Reinterpret: + processReinterpret(inst); + break; + default: + break; } } diff --git a/source/slang/slang-ir-lower-result-type.cpp b/source/slang/slang-ir-lower-result-type.cpp index 655d8041a..4cf684f33 100644 --- a/source/slang/slang-ir-lower-result-type.cpp +++ b/source/slang/slang-ir-lower-result-type.cpp @@ -111,8 +111,10 @@ struct ResultTypeLoweringContext case kIROp_UInt16Type: case kIROp_UIntType: case kIROp_UInt64Type: - case kIROp_UIntPtrType: break; - default: SLANG_ASSERT_FAILURE("error type is not lowered to an integer type."); + case kIROp_UIntPtrType: + break; + default: + SLANG_ASSERT_FAILURE("error type is not lowered to an integer type."); } IRBuilder builderStorage(module); auto builder = &builderStorage; @@ -247,13 +249,26 @@ struct ResultTypeLoweringContext { switch (inst->getOp()) { - case kIROp_MakeResultValue: processMakeResultValue((IRMakeResultValue*)inst); break; - case kIROp_MakeResultError: processMakeResultError((IRMakeResultError*)inst); break; - case kIROp_GetResultError: processGetResultError((IRGetResultError*)inst); break; - case kIROp_GetResultValue: processGetResultValue((IRGetResultValue*)inst); break; - case kIROp_IsResultError: processIsResultError((IRIsResultError*)inst); break; - case kIROp_ResultType: processResultType((IRResultType*)inst); break; - default: break; + case kIROp_MakeResultValue: + processMakeResultValue((IRMakeResultValue*)inst); + break; + case kIROp_MakeResultError: + processMakeResultError((IRMakeResultError*)inst); + break; + case kIROp_GetResultError: + processGetResultError((IRGetResultError*)inst); + break; + case kIROp_GetResultValue: + processGetResultValue((IRGetResultValue*)inst); + break; + case kIROp_IsResultError: + processIsResultError((IRIsResultError*)inst); + break; + case kIROp_ResultType: + processResultType((IRResultType*)inst); + break; + default: + break; } } diff --git a/source/slang/slang-ir-lower-tuple-types.cpp b/source/slang/slang-ir-lower-tuple-types.cpp index a55e6a61e..066895b78 100644 --- a/source/slang/slang-ir-lower-tuple-types.cpp +++ b/source/slang/slang-ir-lower-tuple-types.cpp @@ -349,16 +349,35 @@ struct TupleLoweringContext switch (inst->getOp()) { case kIROp_MakeTuple: - case kIROp_MakeValuePack: processMakeTuple((IRMakeTuple*)inst); break; - case kIROp_GetTupleElement: processGetTupleElement((IRGetTupleElement*)inst); break; - case kIROp_GetElementPtr: processGetElementPtr((IRGetElementPtr*)inst); break; - case kIROp_swizzle: processSwizzle((IRSwizzle*)inst); break; - case kIROp_swizzleSet: processSwizzleSet((IRSwizzleSet*)inst); break; - case kIROp_SwizzledStore: processSwizzledStore((IRSwizzledStore*)inst); break; - case kIROp_TupleType: processTupleType((IRTupleType*)inst); break; - case kIROp_IndexedFieldKey: processIndexedFieldKey((IRIndexedFieldKey*)inst); break; - case kIROp_UpdateElement: processUpdateElement((IRUpdateElement*)inst); break; - default: break; + case kIROp_MakeValuePack: + processMakeTuple((IRMakeTuple*)inst); + break; + case kIROp_GetTupleElement: + processGetTupleElement((IRGetTupleElement*)inst); + break; + case kIROp_GetElementPtr: + processGetElementPtr((IRGetElementPtr*)inst); + break; + case kIROp_swizzle: + processSwizzle((IRSwizzle*)inst); + break; + case kIROp_swizzleSet: + processSwizzleSet((IRSwizzleSet*)inst); + break; + case kIROp_SwizzledStore: + processSwizzledStore((IRSwizzledStore*)inst); + break; + case kIROp_TupleType: + processTupleType((IRTupleType*)inst); + break; + case kIROp_IndexedFieldKey: + processIndexedFieldKey((IRIndexedFieldKey*)inst); + break; + case kIROp_UpdateElement: + processUpdateElement((IRUpdateElement*)inst); + break; + default: + break; } } diff --git a/source/slang/slang-ir-lower-witness-lookup.cpp b/source/slang/slang-ir-lower-witness-lookup.cpp index e24f8c4b6..8aa42ab41 100644 --- a/source/slang/slang-ir-lower-witness-lookup.cpp +++ b/source/slang/slang-ir-lower-witness-lookup.cpp @@ -97,7 +97,8 @@ struct WitnessLookupLoweringContext case kIROp_MatrixType: case kIROp_StructType: case kIROp_ClassType: - case kIROp_InterfaceType: return (IRType*)type; + case kIROp_InterfaceType: + return (IRType*)type; default: { List<IRInst*> translatedOperands; diff --git a/source/slang/slang-ir-marshal-native-call.cpp b/source/slang/slang-ir-marshal-native-call.cpp index 42d8b2db6..2257ef098 100644 --- a/source/slang/slang-ir-marshal-native-call.cpp +++ b/source/slang/slang-ir-marshal-native-call.cpp @@ -11,8 +11,10 @@ IRType* NativeCallMarshallingContext::getNativeType(IRBuilder& builder, IRType* { switch (type->getOp()) { - case kIROp_StringType: return builder.getNativeStringType(); - case kIROp_InterfaceType: return builder.getNativePtrType(type); + case kIROp_StringType: + return builder.getNativeStringType(); + case kIROp_InterfaceType: + return builder.getNativePtrType(type); case kIROp_ComPtrType: return builder.getNativePtrType((IRType*)as<IRComPtrType>(type)->getOperand(0)); case kIROp_InOutType: @@ -20,7 +22,8 @@ IRType* NativeCallMarshallingContext::getNativeType(IRBuilder& builder, IRType* case kIROp_ConstRefType: case kIROp_OutType: return builder.getPtrType(getNativeType(builder, (IRType*)type->getOperand(0))); - default: return type; + default: + return type; } } @@ -64,8 +67,12 @@ void NativeCallMarshallingContext::marshalRefManagedValueToNativeValue( switch (ptrTypeBase->getValueType()->getOp()) { case kIROp_InterfaceType: - case kIROp_ComPtrType: args.add(builder.emitGetManagedPtrWriteRef(originalArg)); break; - default: args.add(originalArg); break; + case kIROp_ComPtrType: + args.add(builder.emitGetManagedPtrWriteRef(originalArg)); + break; + default: + args.add(originalArg); + break; } } @@ -80,7 +87,8 @@ void NativeCallMarshallingContext::marshalManagedValueToNativeValue( case kIROp_InOutType: case kIROp_RefType: case kIROp_ConstRefType: - case kIROp_OutType: return marshalRefManagedValueToNativeValue(builder, originalArg, args); + case kIROp_OutType: + return marshalRefManagedValueToNativeValue(builder, originalArg, args); case kIROp_StringType: { auto nativeStr = builder.emitGetNativeString(originalArg); @@ -93,7 +101,9 @@ void NativeCallMarshallingContext::marshalManagedValueToNativeValue( args.add(nativePtr); } break; - default: args.add(originalArg); break; + default: + args.add(originalArg); + break; } } @@ -125,7 +135,9 @@ IRInst* NativeCallMarshallingContext::marshalNativeValueToManagedValue( return builder.emitLoad(comPtrVar); } break; - default: return nativeVal; break; + default: + return nativeVal; + break; } } @@ -174,7 +186,9 @@ void NativeCallMarshallingContext::marshalManagedValueToNativeResultValue( args.add(nativePtr); } break; - default: args.add(originalArg); break; + default: + args.add(originalArg); + break; } } diff --git a/source/slang/slang-ir-metal-legalize.cpp b/source/slang/slang-ir-metal-legalize.cpp index 9cfebc686..65c547d82 100644 --- a/source/slang/slang-ir-metal-legalize.cpp +++ b/source/slang/slang-ir-metal-legalize.cpp @@ -323,7 +323,9 @@ struct LegalizeMetalEntryPointContext case Stage::Mesh: case Stage::Geometry: case Stage::Domain: - case Stage::Hull: isGeometryStage = true; break; + case Stage::Hull: + isGeometryStage = true; + break; } List<IRParam*> paramsToPack; @@ -1408,7 +1410,9 @@ struct LegalizeMetalEntryPointContext builder.addTargetSystemValueDecoration(key, toSlice("position")); break; } - default: SLANG_ASSERT(false); return; + default: + SLANG_ASSERT(false); + return; } fixUpFuncType(func, structType); @@ -1921,9 +1925,14 @@ struct LegalizeMetalEntryPointContext // Other Legalize switch (entryPoint.entryPointDecor->getProfile().getStage()) { - case Stage::Amplification: legalizeDispatchMeshPayloadForMetal(entryPoint); break; - case Stage::Mesh: legalizeMeshEntryPoint(entryPoint); break; - default: break; + case Stage::Amplification: + legalizeDispatchMeshPayloadForMetal(entryPoint); + break; + case Stage::Mesh: + legalizeMeshEntryPoint(entryPoint); + break; + default: + break; } } }; @@ -2038,11 +2047,14 @@ struct MetalAddressSpaceAssigner : InitialAddressSpaceAssigner { switch (inst->getOp()) { - case kIROp_Var: outAddressSpace = AddressSpace::ThreadLocal; return true; + case kIROp_Var: + outAddressSpace = AddressSpace::ThreadLocal; + return true; case kIROp_RWStructuredBufferGetElementPtr: outAddressSpace = AddressSpace::Global; return true; - default: return false; + default: + return false; } } @@ -2079,12 +2091,14 @@ struct MetalAddressSpaceAssigner : InitialAddressSpaceAssigner return AddressSpace::GroupShared; switch (inst->getOp()) { - case kIROp_RWStructuredBufferGetElementPtr: return AddressSpace::Global; + case kIROp_RWStructuredBufferGetElementPtr: + return AddressSpace::Global; case kIROp_Var: if (as<IRBlock>(inst->getParent())) return AddressSpace::ThreadLocal; break; - default: break; + default: + break; } auto type = unwrapAttributedType(inst->getDataType()); if (!type) diff --git a/source/slang/slang-ir-optix-entry-point-uniforms.cpp b/source/slang/slang-ir-optix-entry-point-uniforms.cpp index 99c519582..f29cbe222 100644 --- a/source/slang/slang-ir-optix-entry-point-uniforms.cpp +++ b/source/slang/slang-ir-optix-entry-point-uniforms.cpp @@ -45,9 +45,11 @@ struct CollectOptixEntryPointUniformParams : PerEntryPointPass // switch (entryPointDecoration->getProfile().getStage()) { - default: break; + default: + break; - case Stage::Compute: return; + case Stage::Compute: + return; } // We expect all entry points to have explicit layout information attached. diff --git a/source/slang/slang-ir-peephole.cpp b/source/slang/slang-ir-peephole.cpp index 3d02398fd..0a08c67ff 100644 --- a/source/slang/slang-ir-peephole.cpp +++ b/source/slang/slang-ir-peephole.cpp @@ -349,7 +349,8 @@ struct PeepholeContext : InstPassBase } break; } - default: break; + default: + break; } break; case kIROp_FieldExtract: @@ -914,7 +915,9 @@ struct PeepholeContext : InstPassBase case kIROp_Sub: case kIROp_Div: case kIROp_And: - case kIROp_Or: changed |= tryOptimizeArithmeticInst(inst); break; + case kIROp_Or: + changed |= tryOptimizeArithmeticInst(inst); + break; case kIROp_Param: { auto block = as<IRBlock>(inst->parent); @@ -1117,17 +1120,27 @@ struct PeepholeContext : InstPassBase bool result = false; switch (inst->getOp()) { - case kIROp_IsInt: result = isIntegralType(type); break; - case kIROp_IsBool: result = type->getOp() == kIROp_BoolType; break; - case kIROp_IsFloat: result = isFloatingType(type); break; - case kIROp_IsHalf: result = type->getOp() == kIROp_HalfType; break; + case kIROp_IsInt: + result = isIntegralType(type); + break; + case kIROp_IsBool: + result = type->getOp() == kIROp_BoolType; + break; + case kIROp_IsFloat: + result = isFloatingType(type); + break; + case kIROp_IsHalf: + result = type->getOp() == kIROp_HalfType; + break; case kIROp_IsUnsignedInt: result = isIntegralType(type) && !getIntTypeInfo(type).isSigned; break; case kIROp_IsSignedInt: result = isIntegralType(type) && getIntTypeInfo(type).isSigned; break; - case kIROp_IsVector: result = as<IRVectorType>(type); break; + case kIROp_IsVector: + result = as<IRVectorType>(type); + break; } inst->replaceUsesWith(builder.getBoolValue(result)); maybeRemoveOldInst(inst); @@ -1169,7 +1182,8 @@ struct PeepholeContext : InstPassBase } break; } - default: break; + default: + break; } } diff --git a/source/slang/slang-ir-propagate-func-properties.cpp b/source/slang/slang-ir-propagate-func-properties.cpp index acc458b9d..8c13a6455 100644 --- a/source/slang/slang-ir-propagate-func-properties.cpp +++ b/source/slang/slang-ir-propagate-func-properties.cpp @@ -24,8 +24,10 @@ static bool isResourceLoad(IROp op) case kIROp_ByteAddressBufferLoad: case kIROp_StructuredBufferLoadStatus: case kIROp_RWStructuredBufferLoad: - case kIROp_RWStructuredBufferLoadStatus: return true; - default: return false; + case kIROp_RWStructuredBufferLoadStatus: + return true; + default: + return false; } } @@ -42,8 +44,10 @@ static bool isKnownOpCodeWithSideEffect(IROp op) case kIROp_Param: case kIROp_Unreachable: case kIROp_Store: - case kIROp_SwizzledStore: return true; - default: return false; + case kIROp_SwizzledStore: + return true; + default: + return false; } } @@ -57,7 +61,8 @@ public: { switch (decoration->getOp()) { - case kIROp_ReadNoneDecoration: return true; + case kIROp_ReadNoneDecoration: + return true; } } return false; @@ -70,7 +75,8 @@ public: switch (decoration->getOp()) { case kIROp_ReadNoneDecoration: - case kIROp_TargetIntrinsicDecoration: return false; + case kIROp_TargetIntrinsicDecoration: + return false; } } return true; @@ -258,7 +264,8 @@ public: { case kIROp_ReadNoneDecoration: case kIROp_NoSideEffectDecoration: - case kIROp_TargetIntrinsicDecoration: return false; + case kIROp_TargetIntrinsicDecoration: + return false; } } return true; @@ -271,7 +278,8 @@ public: switch (decoration->getOp()) { case kIROp_ReadNoneDecoration: - case kIROp_NoSideEffectDecoration: return true; + case kIROp_NoSideEffectDecoration: + return true; } } return false; diff --git a/source/slang/slang-ir-pytorch-cpp-binding.cpp b/source/slang/slang-ir-pytorch-cpp-binding.cpp index fa6361434..6ca39001a 100644 --- a/source/slang/slang-ir-pytorch-cpp-binding.cpp +++ b/source/slang/slang-ir-pytorch-cpp-binding.cpp @@ -528,7 +528,8 @@ IRType* translateToHostType( return nullptr; return builder->getArrayType(elementType, as<IRArrayType>(type)->getElementCount()); } - default: break; + default: + break; } if (sink) @@ -583,7 +584,8 @@ IRInst* castHostToCUDAType(IRBuilder* builder, IRType* hostType, IRType* cudaTyp switch (cudaType->getOp()) { - case kIROp_TensorViewType: return builder->emitMakeTensorView(cudaType, inst); + case kIROp_TensorViewType: + return builder->emitMakeTensorView(cudaType, inst); case kIROp_StructType: { auto cudaStructType = cast<IRStructType>(cudaType); @@ -653,7 +655,8 @@ IRInst* castHostToCUDAType(IRBuilder* builder, IRType* hostType, IRType* cudaTyp resultElements.getBuffer()); } - default: break; + default: + break; } // If translateToHostType worked correctly, there should be no unhandled cases here. @@ -950,7 +953,8 @@ void generateReflectionForType(IRType* type, DiagnosticSink* sink) builder.getStringValue(elementCountStr.getUnownedSlice()))); break; } - default: break; + default: + break; } auto _nameListTupleType = builder.getTargetTupleType( diff --git a/source/slang/slang-ir-redundancy-removal.cpp b/source/slang/slang-ir-redundancy-removal.cpp index b90a8705d..b885a8946 100644 --- a/source/slang/slang-ir-redundancy-removal.cpp +++ b/source/slang/slang-ir-redundancy-removal.cpp @@ -204,8 +204,11 @@ static IRInst* _getRootVar(IRInst* inst) switch (inst->getOp()) { case kIROp_FieldAddress: - case kIROp_GetElementPtr: inst = inst->getOperand(0); break; - default: return inst; + case kIROp_GetElementPtr: + inst = inst->getOperand(0); + break; + default: + return inst; } } return inst; @@ -253,8 +256,11 @@ bool tryRemoveRedundantStore(IRGlobalValueWithCode* func, IRStore* store) switch (accessChain->getOp()) { case kIROp_GetElementPtr: - case kIROp_FieldAddress: accessChain = accessChain->getOperand(0); continue; - default: break; + case kIROp_FieldAddress: + accessChain = accessChain->getOperand(0); + continue; + default: + break; } break; } diff --git a/source/slang/slang-ir-remove-unused-generic-param.cpp b/source/slang/slang-ir-remove-unused-generic-param.cpp index 21747ef97..dd4efeddd 100644 --- a/source/slang/slang-ir-remove-unused-generic-param.cpp +++ b/source/slang/slang-ir-remove-unused-generic-param.cpp @@ -25,7 +25,8 @@ struct RemoveUnusedGenericParamContext : InstPassBase switch (returnVal->getOp()) { case kIROp_StructType: - case kIROp_ClassType: break; + case kIROp_ClassType: + break; case kIROp_Func: case kIROp_FuncType: default: diff --git a/source/slang/slang-ir-restructure-scoping.cpp b/source/slang/slang-ir-restructure-scoping.cpp index 72c25bcd6..f0266b3fc 100644 --- a/source/slang/slang-ir-restructure-scoping.cpp +++ b/source/slang/slang-ir-restructure-scoping.cpp @@ -142,13 +142,16 @@ IRInst* getDefaultInitVal(IRBuilder* builder, IRType* type) { switch (type->getOp()) { - default: return nullptr; + default: + return nullptr; - case kIROp_BoolType: return builder->getBoolValue(false); + case kIROp_BoolType: + return builder->getBoolValue(false); case kIROp_IntType: case kIROp_UIntType: - case kIROp_UInt64Type: return builder->getIntValue(type, 0); + case kIROp_UInt64Type: + return builder->getIntValue(type, 0); case kIROp_HalfType: case kIROp_FloatType: diff --git a/source/slang/slang-ir-sccp.cpp b/source/slang/slang-ir-sccp.cpp index 370b048b8..62584040a 100644 --- a/source/slang/slang-ir-sccp.cpp +++ b/source/slang/slang-ir-sccp.cpp @@ -139,8 +139,10 @@ struct SCCPContext case kIROp_CastFloatToInt: case kIROp_IntCast: case kIROp_FloatCast: - case kIROp_Select: return true; - default: return false; + case kIROp_Select: + return true; + default: + return false; } } @@ -236,7 +238,8 @@ struct SCCPContext // values of aggregate types (e.g., a `makeArray` or `makeStruct` // where all the operands are constant is itself a constant). - default: break; + default: + break; } // Look up in the dictionary and just return the value we get from it. @@ -274,12 +277,15 @@ struct SCCPContext IRBuilder* getBuilder() { return &builderStorage; } // LatticeVal constant evaluation methods. -#define SLANG_SCCP_RETURN_IF_NONE_OR_ANY(v) \ - switch (v.flavor) \ - { \ - case LatticeVal::Flavor::None: return LatticeVal::getNone(); \ - case LatticeVal::Flavor::Any: return LatticeVal::getAny(); \ - default: break; \ +#define SLANG_SCCP_RETURN_IF_NONE_OR_ANY(v) \ + switch (v.flavor) \ + { \ + case LatticeVal::Flavor::None: \ + return LatticeVal::getNone(); \ + case LatticeVal::Flavor::Any: \ + return LatticeVal::getAny(); \ + default: \ + break; \ } LatticeVal evalCast(IRType* type, LatticeVal v0) @@ -316,7 +322,8 @@ struct SCCPContext resultVal = getBuilder()->getIntValue(type, (IRIntegerValue)intVal); } break; - default: return LatticeVal::getAny(); + default: + return LatticeVal::getAny(); } break; case kIROp_FloatType: @@ -335,7 +342,8 @@ struct SCCPContext type, (IRFloatingPointValue)irConstant->value.intVal); break; - default: return LatticeVal::getAny(); + default: + return LatticeVal::getAny(); } break; case kIROp_BoolType: @@ -350,7 +358,8 @@ struct SCCPContext resultVal = getBuilder()->getBoolValue(irConstant->value.intVal != 0); } break; - default: return LatticeVal::getAny(); + default: + return LatticeVal::getAny(); } } if (!resultVal) @@ -382,7 +391,9 @@ struct SCCPContext resultVal = getBuilder()->getFloatValue(type, (IRFloatingPointValue)0.0); break; - case kIROp_BoolType: resultVal = getBuilder()->getBoolValue(false); break; + case kIROp_BoolType: + resultVal = getBuilder()->getBoolValue(false); + break; } if (!resultVal) return LatticeVal::getAny(); @@ -425,7 +436,8 @@ struct SCCPContext type, floatFunc(c0->value.floatVal, c1->value.floatVal)); break; - default: break; + default: + break; } if (!resultVal) return LatticeVal::getAny(); @@ -460,7 +472,8 @@ struct SCCPContext resultVal = getBuilder()->getIntValue(type, intFunc(c0->value.intVal, c1->value.intVal)); break; - default: break; + default: + break; } if (!resultVal) return LatticeVal::getAny(); @@ -488,7 +501,8 @@ struct SCCPContext case kIROp_BoolType: resultVal = getBuilder()->getIntValue(type, intFunc(c0->value.intVal)); break; - default: break; + default: + break; } if (!resultVal) return LatticeVal::getAny(); @@ -529,7 +543,8 @@ struct SCCPContext resultVal = getBuilder()->getBoolValue(floatFunc(c0->value.floatVal, c1->value.floatVal)); break; - default: break; + default: + break; } if (!resultVal) return LatticeVal::getAny(); @@ -741,7 +756,8 @@ struct SCCPContext case kIROp_HalfType: resultVal = getBuilder()->getFloatValue(type, -c0->value.floatVal); break; - default: break; + default: + break; } if (!resultVal) return LatticeVal::getAny(); @@ -814,7 +830,8 @@ struct SCCPContext case kIROp_DoubleType: resultVal = getBuilder()->getFloatValue(type, Int64AsDouble(sourceValueBits)); break; - default: break; + default: + break; } if (!resultVal) return LatticeVal::getAny(); @@ -842,7 +859,8 @@ struct SCCPContext case kIROp_IntLit: case kIROp_FloatLit: case kIROp_StringLit: - case kIROp_BoolLit: return LatticeVal::getConstant(inst); + case kIROp_BoolLit: + return LatticeVal::getConstant(inst); // We might also want to special-case certain // instructions where we shouldn't bother trying to @@ -853,8 +871,10 @@ struct SCCPContext case kIROp_ByteAddressBufferStore: case kIROp_Alloca: case kIROp_Store: - case kIROp_Load: return LatticeVal::getAny(); - default: break; + case kIROp_Load: + return LatticeVal::getAny(); + default: + break; } // TODO: We should now look up the lattice values for @@ -904,11 +924,14 @@ struct SCCPContext case kIROp_CastFloatToInt: switch (inst->getOperandCount()) { - case 1: return evalCast(inst->getDataType(), getLatticeVal(inst->getOperand(0))); + case 1: + return evalCast(inst->getDataType(), getLatticeVal(inst->getOperand(0))); - default: return LatticeVal::getAny(); + default: + return LatticeVal::getAny(); } - case kIROp_DefaultConstruct: return evalDefaultConstruct(inst->getDataType()); + case kIROp_DefaultConstruct: + return evalDefaultConstruct(inst->getDataType()); case kIROp_Add: return evalAdd( inst->getDataType(), @@ -1003,7 +1026,8 @@ struct SCCPContext inst->getDataType(), getLatticeVal(inst->getOperand(0)), getLatticeVal(inst->getOperand(1))); - case kIROp_Not: return evalNot(inst->getDataType(), getLatticeVal(inst->getOperand(0))); + case kIROp_Not: + return evalNot(inst->getDataType(), getLatticeVal(inst->getOperand(0))); case kIROp_BitAnd: return evalBitAnd( inst->getDataType(), @@ -1023,7 +1047,8 @@ struct SCCPContext getLatticeVal(inst->getOperand(1))); case kIROp_BitCast: return evalBitCast(inst->getDataType(), getLatticeVal(inst->getOperand(0))); - case kIROp_Neg: return evalNeg(inst->getDataType(), getLatticeVal(inst->getOperand(0))); + case kIROp_Neg: + return evalNeg(inst->getDataType(), getLatticeVal(inst->getOperand(0))); case kIROp_Lsh: return evalLsh( inst->getDataType(), @@ -1039,7 +1064,8 @@ struct SCCPContext getLatticeVal(inst->getOperand(0)), getLatticeVal(inst->getOperand(1)), getLatticeVal(inst->getOperand(2))); - default: break; + default: + break; } // A safe default is to assume that every instruction not @@ -1328,7 +1354,9 @@ struct SCCPContext case kIROp_StructType: case kIROp_ClassType: case kIROp_InterfaceType: - case kIROp_WitnessTable: changed |= applyOnScope(child); break; + case kIROp_WitnessTable: + changed |= applyOnScope(child); + break; } } return changed; @@ -1759,7 +1787,8 @@ static bool applySparseConditionalConstantPropagationRec( { case kIROp_Func: case kIROp_Block: - case kIROp_Generic: break; + case kIROp_Generic: + break; default: // Skip other op codes. continue; diff --git a/source/slang/slang-ir-simplify-cfg.cpp b/source/slang/slang-ir-simplify-cfg.cpp index a3131d1a7..90d30dcc7 100644 --- a/source/slang/slang-ir-simplify-cfg.cpp +++ b/source/slang/slang-ir-simplify-cfg.cpp @@ -56,7 +56,8 @@ static IRInst* findBreakableRegionHeaderInst(IRDominatorTree* domTree, IRBlock* switch (terminator->getOp()) { case kIROp_Switch: - case kIROp_loop: return terminator; + case kIROp_loop: + return terminator; } } return nullptr; @@ -145,7 +146,8 @@ static bool isTrivialSingleIterationLoop( if (isBlockInRegion(context.domTree, as<IRSwitch>(terminator), breakOriginBlock)) return false; break; - default: break; + default: + break; } } } @@ -576,7 +578,8 @@ static bool trySimplifySwitch(IRBuilder& builder, IRSwitch* switchInst) // If the target block is used by a special control flow inst, // it is likely a merge block and we can't fuse it. return; - default: break; + default: + break; } } targetUse->set(target); diff --git a/source/slang/slang-ir-simplify-for-emit.cpp b/source/slang/slang-ir-simplify-for-emit.cpp index 0d8614059..c3b8ded3e 100644 --- a/source/slang/slang-ir-simplify-for-emit.cpp +++ b/source/slang/slang-ir-simplify-for-emit.cpp @@ -232,13 +232,25 @@ struct SimplifyForEmitContext : public InstPassBase // emit logic to skip producing a temp var for the loaded result. switch (inst->getOp()) { - case kIROp_MakeStruct: processMakeStruct(inst); break; - case kIROp_MakeArray: processMakeArray(inst); break; - case kIROp_MakeArrayFromElement: processMakeArrayFromElement(inst); break; - case kIROp_Load: processLoad(as<IRLoad>(inst)); break; + case kIROp_MakeStruct: + processMakeStruct(inst); + break; + case kIROp_MakeArray: + processMakeArray(inst); + break; + case kIROp_MakeArrayFromElement: + processMakeArrayFromElement(inst); + break; + case kIROp_Load: + processLoad(as<IRLoad>(inst)); + break; case kIROp_GetElement: - case kIROp_FieldExtract: processElementExtract(inst); break; - case kIROp_Var: processVar(inst); break; + case kIROp_FieldExtract: + processElementExtract(inst); + break; + case kIROp_Var: + processVar(inst); + break; } } @@ -255,7 +267,9 @@ struct SimplifyForEmitContext : public InstPassBase { case kIROp_MakeStruct: case kIROp_MakeArray: - case kIROp_MakeArrayFromElement: addToFollowUpWorkList(inst); break; + case kIROp_MakeArrayFromElement: + addToFollowUpWorkList(inst); + break; } } } @@ -274,7 +288,9 @@ struct SimplifyForEmitContext : public InstPassBase { switch (inst->getOp()) { - case kIROp_Load: addToFollowUpWorkList(inst); break; + case kIROp_Load: + addToFollowUpWorkList(inst); + break; } } } @@ -293,7 +309,9 @@ struct SimplifyForEmitContext : public InstPassBase { switch (inst->getOp()) { - case kIROp_Var: addToFollowUpWorkList(inst); break; + case kIROp_Var: + addToFollowUpWorkList(inst); + break; } } } @@ -313,7 +331,9 @@ struct SimplifyForEmitContext : public InstPassBase switch (inst->getOp()) { case kIROp_GetElement: - case kIROp_FieldExtract: addToFollowUpWorkList(inst); break; + case kIROp_FieldExtract: + addToFollowUpWorkList(inst); + break; } } } diff --git a/source/slang/slang-ir-specialize-dispatch.cpp b/source/slang/slang-ir-specialize-dispatch.cpp index ae7b2dc67..75e0016d3 100644 --- a/source/slang/slang-ir-specialize-dispatch.cpp +++ b/source/slang/slang-ir-specialize-dispatch.cpp @@ -31,10 +31,17 @@ IRFunc* specializeDispatchFunction( { switch (inst->getOp()) { - case kIROp_Call: callInst = cast<IRCall>(inst); break; - case kIROp_LookupWitness: lookupInst = cast<IRLookupWitnessMethod>(inst); break; - case kIROp_Return: returnInst = cast<IRReturn>(inst); break; - default: break; + case kIROp_Call: + callInst = cast<IRCall>(inst); + break; + case kIROp_LookupWitness: + lookupInst = cast<IRLookupWitnessMethod>(inst); + break; + case kIROp_Return: + returnInst = cast<IRReturn>(inst); + break; + default: + break; } } SLANG_ASSERT(callInst && lookupInst && returnInst); diff --git a/source/slang/slang-ir-specialize-resources.cpp b/source/slang/slang-ir-specialize-resources.cpp index 2230ec857..6aca4bbc7 100644 --- a/source/slang/slang-ir-specialize-resources.cpp +++ b/source/slang/slang-ir-specialize-resources.cpp @@ -935,7 +935,8 @@ struct ResourceOutputSpecializationPass } return; } - default: return; + default: + return; }; }); if (failedResult(recursiveSpecializationResult)) @@ -1016,7 +1017,9 @@ struct ResourceOutputSpecializationPass // switch (oldParamInfo.oldArgMode) { - default: SLANG_UNEXPECTED("unhandled case"); break; + default: + SLANG_UNEXPECTED("unhandled case"); + break; case ParamInfo::OldArgMode::Keep: // If the parameter was not specialized away, then @@ -1316,8 +1319,10 @@ bool isIllegalGLSLParameterType(IRType* type) { case SLANG_RESOURCE_ACCESS_READ_WRITE: case SLANG_RESOURCE_ACCESS_WRITE: - case SLANG_RESOURCE_ACCESS_RASTER_ORDERED: return true; - default: break; + case SLANG_RESOURCE_ACCESS_RASTER_ORDERED: + return true; + default: + break; } } if (as<IRSubpassInputType>(type)) diff --git a/source/slang/slang-ir-specialize.cpp b/source/slang/slang-ir-specialize.cpp index be7812264..81ad5ca2a 100644 --- a/source/slang/slang-ir-specialize.cpp +++ b/source/slang/slang-ir-specialize.cpp @@ -87,7 +87,8 @@ struct SpecializationContext { case kIROp_GlobalGenericParam: case kIROp_LookupWitness: - case kIROp_GetTupleElement: return false; + case kIROp_GetTupleElement: + return false; case kIROp_Specialize: // The `specialize` instruction is a bit sepcial, // because it is possible to have a `specialize` @@ -560,34 +561,45 @@ struct SpecializationContext // but in order to realize these we often need to propagate // through local simplification on values of existential type. // - case kIROp_ExtractExistentialType: return maybeSpecializeExtractExistentialType(inst); - case kIROp_ExtractExistentialValue: return maybeSpecializeExtractExistentialValue(inst); + case kIROp_ExtractExistentialType: + return maybeSpecializeExtractExistentialType(inst); + case kIROp_ExtractExistentialValue: + return maybeSpecializeExtractExistentialValue(inst); case kIROp_ExtractExistentialWitnessTable: return maybeSpecializeExtractExistentialWitnessTable(inst); - case kIROp_Load: return maybeSpecializeLoad(as<IRLoad>(inst)); + case kIROp_Load: + return maybeSpecializeLoad(as<IRLoad>(inst)); - case kIROp_FieldExtract: return maybeSpecializeFieldExtract(as<IRFieldExtract>(inst)); - case kIROp_FieldAddress: return maybeSpecializeFieldAddress(as<IRFieldAddress>(inst)); + case kIROp_FieldExtract: + return maybeSpecializeFieldExtract(as<IRFieldExtract>(inst)); + case kIROp_FieldAddress: + return maybeSpecializeFieldAddress(as<IRFieldAddress>(inst)); - case kIROp_GetElement: return maybeSpecializeGetElement(as<IRGetElement>(inst)); + case kIROp_GetElement: + return maybeSpecializeGetElement(as<IRGetElement>(inst)); case kIROp_GetElementPtr: return maybeSpecializeGetElementAddress(as<IRGetElementPtr>(inst)); case kIROp_BindExistentialsType: return maybeSpecializeBindExistentialsType(as<IRBindExistentialsType>(inst)); - case kIROp_Expand: return maybeSpecializeExpand(as<IRExpand>(inst)); + case kIROp_Expand: + return maybeSpecializeExpand(as<IRExpand>(inst)); - case kIROp_GetTupleElement: return maybeSpecializeFoldableInst(inst); + case kIROp_GetTupleElement: + return maybeSpecializeFoldableInst(inst); case kIROp_TypePack: - case kIROp_TupleType: return maybeSpecializeTypePackOrTupleType(inst); + case kIROp_TupleType: + return maybeSpecializeTypePackOrTupleType(inst); case kIROp_MakeValuePack: - case kIROp_MakeTuple: return maybeSpecializeMakeValuePackOrTuple(inst); + case kIROp_MakeTuple: + return maybeSpecializeMakeValuePackOrTuple(inst); - case kIROp_CountOf: return maybeSpecializeCountOf(inst); + case kIROp_CountOf: + return maybeSpecializeCountOf(inst); case kIROp_Func: @@ -722,15 +734,19 @@ struct SpecializationContext switch (operand->getOp()) { case kIROp_MakeValuePack: - case kIROp_MakeTuple: operand = operand->getDataType(); break; + case kIROp_MakeTuple: + operand = operand->getDataType(); + break; } // We can only figure out the count of a type pack or tuple type. switch (operand->getOp()) { case kIROp_TypePack: - case kIROp_TupleType: break; - default: return false; + case kIROp_TupleType: + break; + default: + return false; } // If none of the element type is a TypePack, we can just return the count. @@ -740,7 +756,8 @@ struct SpecializationContext { case kIROp_Param: case kIROp_TypePack: - case kIROp_ExpandTypeOrVal: return false; + case kIROp_ExpandTypeOrVal: + return false; } } IRBuilder builder(module); @@ -901,7 +918,8 @@ struct SpecializationContext case kIROp_ExistentialTypeSpecializationDictionary: _readSpecializationDictionaryImpl(existentialSpecializedStructs, child); break; - default: continue; + default: + continue; } } } @@ -1543,8 +1561,10 @@ struct SpecializationContext case kIROp_Call: case kIROp_ExtractExistentialType: case kIROp_CreateExistentialObject: - case kIROp_Param: return false; - default: break; + case kIROp_Param: + return false; + default: + break; } for (UInt i = 0; i < curInst->getOperandCount(); ++i) @@ -2729,7 +2749,8 @@ struct SpecializationContext switch (inst->getOp()) { - default: break; + default: + break; case kIROp_GlobalGenericParam: case kIROp_BindGlobalGenericParam: @@ -2878,7 +2899,8 @@ void finalizeSpecialization(IRModule* module) switch (inst->getOp()) { - default: break; + default: + break; case kIROp_StructKey: case kIROp_Func: @@ -2888,8 +2910,11 @@ void finalizeSpecialization(IRModule* module) switch (decor->getOp()) { case kIROp_DispatchFuncDecoration: - case kIROp_ResultWitnessDecoration: decor->removeAndDeallocate(); break; - default: break; + case kIROp_ResultWitnessDecoration: + decor->removeAndDeallocate(); + break; + default: + break; } decor = nextDecor; } @@ -2897,7 +2922,9 @@ void finalizeSpecialization(IRModule* module) case kIROp_ExistentialFuncSpecializationDictionary: case kIROp_ExistentialTypeSpecializationDictionary: - case kIROp_GenericSpecializationDictionary: inst->removeAndDeallocate(); break; + case kIROp_GenericSpecializationDictionary: + inst->removeAndDeallocate(); + break; } } } diff --git a/source/slang/slang-ir-spirv-legalize.cpp b/source/slang/slang-ir-spirv-legalize.cpp index 1ce8423cf..ff1ddadca 100644 --- a/source/slang/slang-ir-spirv-legalize.cpp +++ b/source/slang/slang-ir-spirv-legalize.cpp @@ -142,13 +142,21 @@ struct SPIRVLegalizationContext : public SourceEmitterBase StringBuilder nameSb; switch (inst->getOp()) { - case kIROp_HLSLRWStructuredBufferType: nameSb << "RWStructuredBuffer"; break; - case kIROp_HLSLAppendStructuredBufferType: nameSb << "AppendStructuredBuffer"; break; - case kIROp_HLSLConsumeStructuredBufferType: nameSb << "ConsumeStructuredBuffer"; break; + case kIROp_HLSLRWStructuredBufferType: + nameSb << "RWStructuredBuffer"; + break; + case kIROp_HLSLAppendStructuredBufferType: + nameSb << "AppendStructuredBuffer"; + break; + case kIROp_HLSLConsumeStructuredBufferType: + nameSb << "ConsumeStructuredBuffer"; + break; case kIROp_HLSLRasterizerOrderedStructuredBufferType: nameSb << "RasterizerOrderedStructuredBuffer"; break; - default: nameSb << "StructuredBuffer"; break; + default: + nameSb << "StructuredBuffer"; + break; } builder.addNameHintDecoration(structType, nameSb.getUnownedSlice()); if (m_sharedContext->isSpirv14OrLater()) @@ -347,8 +355,10 @@ struct SPIRVLegalizationContext : public SourceEmitterBase { case kIROp_RaytracingAccelerationStructureType: case kIROp_GLSLAtomicUintType: - case kIROp_RayQueryType: return true; - default: return false; + case kIROp_RayQueryType: + return true; + default: + return false; } } @@ -585,9 +595,15 @@ struct SPIRVLegalizationContext : public SourceEmitterBase { case LayoutResourceKind::Uniform: case LayoutResourceKind::DescriptorTableSlot: - case LayoutResourceKind::ConstantBuffer: addressSpace = AddressSpace::Uniform; break; - case LayoutResourceKind::VaryingInput: addressSpace = AddressSpace::Input; break; - case LayoutResourceKind::VaryingOutput: addressSpace = AddressSpace::Output; break; + case LayoutResourceKind::ConstantBuffer: + addressSpace = AddressSpace::Uniform; + break; + case LayoutResourceKind::VaryingInput: + addressSpace = AddressSpace::Input; + break; + case LayoutResourceKind::VaryingOutput: + addressSpace = AddressSpace::Output; + break; case LayoutResourceKind::ShaderResource: case LayoutResourceKind::UnorderedAccess: addressSpace = getStorageBufferAddressSpace(); @@ -598,15 +614,20 @@ struct SPIRVLegalizationContext : public SourceEmitterBase case LayoutResourceKind::SpecializationConstant: addressSpace = AddressSpace::SpecializationConstant; break; - case LayoutResourceKind::RayPayload: addressSpace = AddressSpace::IncomingRayPayload; break; + case LayoutResourceKind::RayPayload: + addressSpace = AddressSpace::IncomingRayPayload; + break; case LayoutResourceKind::CallablePayload: addressSpace = AddressSpace::IncomingCallableData; break; - case LayoutResourceKind::HitAttributes: addressSpace = AddressSpace::HitAttribute; break; + case LayoutResourceKind::HitAttributes: + addressSpace = AddressSpace::HitAttribute; + break; case LayoutResourceKind::ShaderRecord: addressSpace = AddressSpace::ShaderRecordBuffer; break; - default: break; + default: + break; } return addressSpace; } @@ -846,7 +867,9 @@ struct SPIRVLegalizationContext : public SourceEmitterBase switch (arg->getOp()) { case kIROp_Var: - case kIROp_GlobalVar: newArgs.add(arg); continue; + case kIROp_GlobalVar: + newArgs.add(arg); + continue; case kIROp_Param: if (arg->getParent() == getParentFunc(arg)->getFirstBlock()) { @@ -854,7 +877,8 @@ struct SPIRVLegalizationContext : public SourceEmitterBase continue; } break; - default: break; + default: + break; } auto root = getRootAddr(arg); if (root) @@ -1146,7 +1170,9 @@ struct SPIRVLegalizationContext : public SourceEmitterBase case kIROp_IntCast: case kIROp_GetElementPtr: case kIROp_Load: - case kIROp_NonUniformResourceIndex: resWorkList.add(nonuniformUser); break; + case kIROp_NonUniformResourceIndex: + resWorkList.add(nonuniformUser); + break; }; // Clean up the base inst from the IR module, to avoid duplicate decorations. @@ -1573,7 +1599,8 @@ struct SPIRVLegalizationContext : public SourceEmitterBase case kIROp_MakeVector: case kIROp_MakeMatrix: case kIROp_MakeMatrixFromScalar: - case kIROp_MakeVectorFromScalar: return true; + case kIROp_MakeVectorFromScalar: + return true; default: if (as<IRConstant>(inst)) return true; @@ -1643,7 +1670,8 @@ struct SPIRVLegalizationContext : public SourceEmitterBase case kIROp_Neq: case kIROp_Eql: case kIROp_Call: - case kIROp_SPIRVAsm: return true; + case kIROp_SPIRVAsm: + return true; default: if (as<IRSPIRVAsmInst>(inst)) return true; @@ -1720,7 +1748,8 @@ struct SPIRVLegalizationContext : public SourceEmitterBase case kIROp_Func: case kIROp_Specialize: case kIROp_Generic: - case kIROp_LookupWitness: return inst; + case kIROp_LookupWitness: + return inst; } if (as<IRType>(inst)) return inst; @@ -1805,18 +1834,42 @@ struct SPIRVLegalizationContext : public SourceEmitterBase switch (inst->getOp()) { - case kIROp_StructField: processStructField(as<IRStructField>(inst)); break; - case kIROp_GlobalParam: processGlobalParam(as<IRGlobalParam>(inst)); break; - case kIROp_GlobalVar: processGlobalVar(as<IRGlobalVar>(inst)); break; - case kIROp_Var: processVar(as<IRVar>(inst)); break; - case kIROp_Param: processParam(as<IRParam>(inst)); break; - case kIROp_Call: processCall(as<IRCall>(inst)); break; - case kIROp_GetElement: processGetElement(as<IRGetElement>(inst)); break; - case kIROp_GetElementPtr: processGetElementPtr(as<IRGetElementPtr>(inst)); break; - case kIROp_GetOffsetPtr: processGetOffsetPtr(inst); break; - case kIROp_FieldAddress: processFieldAddress(as<IRFieldAddress>(inst)); break; - case kIROp_FieldExtract: processFieldExtract(as<IRFieldExtract>(inst)); break; - case kIROp_ImageSubscript: processImageSubscript(as<IRImageSubscript>(inst)); break; + case kIROp_StructField: + processStructField(as<IRStructField>(inst)); + break; + case kIROp_GlobalParam: + processGlobalParam(as<IRGlobalParam>(inst)); + break; + case kIROp_GlobalVar: + processGlobalVar(as<IRGlobalVar>(inst)); + break; + case kIROp_Var: + processVar(as<IRVar>(inst)); + break; + case kIROp_Param: + processParam(as<IRParam>(inst)); + break; + case kIROp_Call: + processCall(as<IRCall>(inst)); + break; + case kIROp_GetElement: + processGetElement(as<IRGetElement>(inst)); + break; + case kIROp_GetElementPtr: + processGetElementPtr(as<IRGetElementPtr>(inst)); + break; + case kIROp_GetOffsetPtr: + processGetOffsetPtr(inst); + break; + case kIROp_FieldAddress: + processFieldAddress(as<IRFieldAddress>(inst)); + break; + case kIROp_FieldExtract: + processFieldExtract(as<IRFieldExtract>(inst)); + break; + case kIROp_ImageSubscript: + processImageSubscript(as<IRImageSubscript>(inst)); + break; case kIROp_RWStructuredBufferGetElementPtr: processRWStructuredBufferGetElementPtr( cast<IRRWStructuredBufferGetElementPtr>(inst)); @@ -1824,22 +1877,38 @@ struct SPIRVLegalizationContext : public SourceEmitterBase case kIROp_MeshOutputRef: processMeshOutputGetElementPtr(cast<IRMeshOutputRef>(inst)); break; - case kIROp_MeshOutputSet: processMeshOutputSet(cast<IRMeshOutputSet>(inst)); break; + case kIROp_MeshOutputSet: + processMeshOutputSet(cast<IRMeshOutputSet>(inst)); + break; case kIROp_RWStructuredBufferLoad: case kIROp_StructuredBufferLoad: case kIROp_RWStructuredBufferLoadStatus: - case kIROp_StructuredBufferLoadStatus: processStructuredBufferLoad(inst); break; - case kIROp_RWStructuredBufferStore: processRWStructuredBufferStore(inst); break; - case kIROp_NonUniformResourceIndex: processNonUniformResourceIndex(inst); break; - case kIROp_loop: processLoop(as<IRLoop>(inst)); break; - case kIROp_ifElse: processIfElse(as<IRIfElse>(inst)); break; - case kIROp_Switch: processSwitch(as<IRSwitch>(inst)); break; + case kIROp_StructuredBufferLoadStatus: + processStructuredBufferLoad(inst); + break; + case kIROp_RWStructuredBufferStore: + processRWStructuredBufferStore(inst); + break; + case kIROp_NonUniformResourceIndex: + processNonUniformResourceIndex(inst); + break; + case kIROp_loop: + processLoop(as<IRLoop>(inst)); + break; + case kIROp_ifElse: + processIfElse(as<IRIfElse>(inst)); + break; + case kIROp_Switch: + processSwitch(as<IRSwitch>(inst)); + break; case kIROp_Less: case kIROp_Leq: case kIROp_Eql: case kIROp_Geq: case kIROp_Greater: - case kIROp_Neq: processComparison(inst); break; + case kIROp_Neq: + processComparison(inst); + break; case kIROp_MakeVectorFromScalar: case kIROp_MakeUInt64: case kIROp_MakeVector: @@ -1854,10 +1923,18 @@ struct SPIRVLegalizationContext : public SourceEmitterBase case kIROp_MakeResultValue: case kIROp_MakeResultError: case kIROp_MakeOptionalValue: - case kIROp_MakeOptionalNone: processConstructor(inst); break; - case kIROp_PtrLit: processPtrLit(inst); break; - case kIROp_unconditionalBranch: processBranch(inst); break; - case kIROp_SPIRVAsm: processSPIRVAsm(as<IRSPIRVAsm>(inst)); break; + case kIROp_MakeOptionalNone: + processConstructor(inst); + break; + case kIROp_PtrLit: + processPtrLit(inst); + break; + case kIROp_unconditionalBranch: + processBranch(inst); + break; + case kIROp_SPIRVAsm: + processSPIRVAsm(as<IRSPIRVAsm>(inst)); + break; case kIROp_DebugValue: if (!isSimpleDataType(as<IRDebugValue>(inst)->getDebugVar()->getDataType())) inst->removeAndDeallocate(); @@ -1932,7 +2009,8 @@ struct SPIRVLegalizationContext : public SourceEmitterBase case CapabilityName::SPV_EXT_demote_to_helper_invocation: m_sharedContext->m_useDemoteToHelperInvocationExtension = true; break; - default: break; + default: + break; } } } diff --git a/source/slang/slang-ir-spirv-snippet.cpp b/source/slang/slang-ir-spirv-snippet.cpp index df94b2974..6ed902ba4 100644 --- a/source/slang/slang-ir-spirv-snippet.cpp +++ b/source/slang/slang-ir-spirv-snippet.cpp @@ -56,7 +56,9 @@ SpvWord readWordOrWordLiteral(Misc::TokenReader& reader) { switch (reader.NextToken().Type) { - case Slang::Misc::TokenType::IntLiteral: ret = reader.ReadUInt(); break; + case Slang::Misc::TokenType::IntLiteral: + ret = reader.ReadUInt(); + break; case Slang::Misc::TokenType::Identifier: { const auto i = reader.ReadWord(); @@ -80,7 +82,8 @@ SpvWord readWordOrWordLiteral(Misc::TokenReader& reader) } } break; - default: throw Misc::TextFormatException("Text parsing error: Expected int or SPIR-V enum"); + default: + throw Misc::TextFormatException("Text parsing error: Expected int or SPIR-V enum"); } } while (reader.AdvanceIf(Misc::TokenType::OpBitOr)); return ret; @@ -114,7 +117,9 @@ RefPtr<SpvSnippet> SpvSnippet::parse( SpvOp opCode; switch (tokenReader.NextToken().Type) { - case Slang::Misc::TokenType::IntLiteral: opCode = (SpvOp)tokenReader.ReadInt(); break; + case Slang::Misc::TokenType::IntLiteral: + opCode = (SpvOp)tokenReader.ReadInt(); + break; case Slang::Misc::TokenType::Identifier: { auto opName = tokenReader.ReadWord(); @@ -302,7 +307,9 @@ RefPtr<SpvSnippet> SpvSnippet::parse( } } break; - default: insideOperandList = false; break; + default: + insideOperandList = false; + break; } } snippet->instructions.add(inst); diff --git a/source/slang/slang-ir-spirv-snippet.h b/source/slang/slang-ir-spirv-snippet.h index b884ee90a..3d71748f4 100644 --- a/source/slang/slang-ir-spirv-snippet.h +++ b/source/slang/slang-ir-spirv-snippet.h @@ -95,7 +95,9 @@ struct SpvSnippet : public RefObject case ASMType::FloatOrDouble: result = combineHash(result, Slang::getHashCode(floatValues[i])); break; - default: result = combineHash(result, Slang::getHashCode(intValues[i])); break; + default: + result = combineHash(result, Slang::getHashCode(intValues[i])); + break; } } return result; @@ -109,16 +111,20 @@ struct SpvSnippet : public RefObject case ASMType::Half: case ASMType::Float: case ASMType::Double: - case ASMType::FloatOrDouble: return floatValues[0] == other.floatValues[0]; + case ASMType::FloatOrDouble: + return floatValues[0] == other.floatValues[0]; case ASMType::Float2: return floatValues[0] == other.floatValues[0] && floatValues[1] == other.floatValues[1]; - case ASMType::Int: return intValues[0] == other.intValues[0]; + case ASMType::Int: + return intValues[0] == other.intValues[0]; case ASMType::UInt: - case ASMType::UInt16: return intValues[0] == other.intValues[0]; + case ASMType::UInt16: + return intValues[0] == other.intValues[0]; case ASMType::UInt2: return intValues[0] == other.intValues[0] && intValues[1] == other.intValues[1]; - default: return false; + default: + return false; } } }; diff --git a/source/slang/slang-ir-ssa-register-allocate.cpp b/source/slang/slang-ir-ssa-register-allocate.cpp index 13fd2fe5e..e3bda0c1b 100644 --- a/source/slang/slang-ir-ssa-register-allocate.cpp +++ b/source/slang/slang-ir-ssa-register-allocate.cpp @@ -46,7 +46,8 @@ struct RegisterAllocateContext if (inst0 == inst1->getOperand(0)) return true; break; - default: break; + default: + break; } // If insts have the same name, prefer to coalesce them. @@ -301,8 +302,10 @@ struct RegisterAllocateContext if (allocateForCompositeTypeOnly && !isCompositeType(inst->getFullType())) return false; return true; - case kIROp_UpdateElement: return true; - default: return false; + case kIROp_UpdateElement: + return true; + default: + return false; } } bool needProcessing(IRGlobalValueWithCode* func) diff --git a/source/slang/slang-ir-ssa.cpp b/source/slang/slang-ir-ssa.cpp index a927064c7..d57d8548e 100644 --- a/source/slang/slang-ir-ssa.cpp +++ b/source/slang/slang-ir-ssa.cpp @@ -116,9 +116,11 @@ bool allUsesLeadToLoads(IRInst* inst) auto user = u->getUser(); switch (user->getOp()) { - default: return false; + default: + return false; - case kIROp_Load: break; + case kIROp_Load: + break; case kIROp_GetElementPtr: case kIROp_FieldAddress: @@ -279,12 +281,15 @@ IRVar* asPromotableVarAccessChain(ConstructSSAContext* context, IRInst* value) { switch (value->getOp()) { - case kIROp_Var: return asPromotableVar(context, value); + case kIROp_Var: + return asPromotableVar(context, value); case kIROp_FieldAddress: - case kIROp_GetElementPtr: return asPromotableVarAccessChain(context, value->getOperand(0)); + case kIROp_GetElementPtr: + return asPromotableVarAccessChain(context, value->getOperand(0)); - default: return nullptr; + default: + return nullptr; } } @@ -303,9 +308,12 @@ IRInst* applyAccessChain( { switch (accessChain->getOp()) { - default: SLANG_UNEXPECTED("unexpected op along access chain"); UNREACHABLE_RETURN(leafVarValue); + default: + SLANG_UNEXPECTED("unexpected op along access chain"); + UNREACHABLE_RETURN(leafVarValue); - case kIROp_Var: return leafVarValue; + case kIROp_Var: + return leafVarValue; case kIROp_FieldAddress: { @@ -1214,7 +1222,8 @@ bool constructSSA(IRModule* module, IRInst* globalVal) switch (globalVal->getOp()) { case kIROp_Func: - case kIROp_GlobalVar: return constructSSA(module, (IRGlobalValueWithCode*)globalVal); + case kIROp_GlobalVar: + return constructSSA(module, (IRGlobalValueWithCode*)globalVal); case kIROp_Generic: { @@ -1236,7 +1245,8 @@ bool constructSSA(IRModule* module, IRInst* globalVal) return constructSSA(module, returnVal); } - default: break; + default: + break; } return false; } @@ -1259,7 +1269,8 @@ bool constructSSA(IRInst* globalVal) case kIROp_GlobalVar: return constructSSA(globalVal->getModule(), (IRGlobalValueWithCode*)globalVal); - default: break; + default: + break; } return false; } diff --git a/source/slang/slang-ir-strip-cached-dict.cpp b/source/slang/slang-ir-strip-cached-dict.cpp index d14a74d73..202b3a4a2 100644 --- a/source/slang/slang-ir-strip-cached-dict.cpp +++ b/source/slang/slang-ir-strip-cached-dict.cpp @@ -15,8 +15,11 @@ void stripCachedDictionaries(IRModule* module) { case kIROp_GenericSpecializationDictionary: case kIROp_ExistentialFuncSpecializationDictionary: - case kIROp_ExistentialTypeSpecializationDictionary: toRemove.add(inst); break; - default: continue; + case kIROp_ExistentialTypeSpecializationDictionary: + toRemove.add(inst); + break; + default: + continue; } } for (auto inst : toRemove) diff --git a/source/slang/slang-ir-strip.cpp b/source/slang/slang-ir-strip.cpp index 6d83cd310..e9fbbceb6 100644 --- a/source/slang/slang-ir-strip.cpp +++ b/source/slang/slang-ir-strip.cpp @@ -12,11 +12,14 @@ static bool _shouldStripInst(IRInst* inst, IRStripOptions const& options) { switch (inst->getOp()) { - default: return false; + default: + return false; - case kIROp_HighLevelDeclDecoration: return true; + case kIROp_HighLevelDeclDecoration: + return true; - case kIROp_NameHintDecoration: return options.shouldStripNameHints; + case kIROp_NameHintDecoration: + return options.shouldStripNameHints; } } diff --git a/source/slang/slang-ir-synthesize-active-mask.cpp b/source/slang/slang-ir-synthesize-active-mask.cpp index 9bebf7b9f..f899fee1a 100644 --- a/source/slang/slang-ir-synthesize-active-mask.cpp +++ b/source/slang/slang-ir-synthesize-active-mask.cpp @@ -1064,7 +1064,8 @@ struct SynthesizeActiveMaskForFunctionContext // so we can elect to simply do nothing. // case kIROp_MissingReturn: - case kIROp_Unreachable: break; + case kIROp_Unreachable: + break; case kIROp_unconditionalBranch: { diff --git a/source/slang/slang-ir-uniformity.cpp b/source/slang/slang-ir-uniformity.cpp index 666f72d0c..312b64af3 100644 --- a/source/slang/slang-ir-uniformity.cpp +++ b/source/slang/slang-ir-uniformity.cpp @@ -180,11 +180,17 @@ struct ValidateUniformityContext return true; addr = as<IRFieldAddress>(addr)->getBase(); break; - case kIROp_GetElementPtr: addr = as<IRGetElementPtr>(addr)->getBase(); break; - case kIROp_GetOffsetPtr: addr = addr->getOperand(0); break; + case kIROp_GetElementPtr: + addr = as<IRGetElementPtr>(addr)->getBase(); + break; + case kIROp_GetOffsetPtr: + addr = addr->getOperand(0); + break; case kIROp_Param: - case kIROp_Var: return addr->findDecoration<IRDynamicUniformDecoration>() != nullptr; - default: addr = nullptr; + case kIROp_Var: + return addr->findDecoration<IRDynamicUniformDecoration>() != nullptr; + default: + addr = nullptr; } } return false; @@ -238,8 +244,12 @@ struct ValidateUniformityContext switch (inst->getOp()) { case kIROp_Store: - case kIROp_SwizzledStore: addToWorkList(inst->getOperand(0)); break; - case kIROp_Return: addToWorkList(inst); break; + case kIROp_SwizzledStore: + addToWorkList(inst->getOperand(0)); + break; + case kIROp_Return: + addToWorkList(inst); + break; case kIROp_Call: { auto call = as<IRCall>(inst); @@ -269,7 +279,8 @@ struct ValidateUniformityContext continue; switch (user->getOp()) { - case kIROp_TreatAsDynamicUniform: continue; + case kIROp_TreatAsDynamicUniform: + continue; case kIROp_FieldAddress: { if (isDynamicUniformLocation(user)) @@ -408,7 +419,8 @@ struct ValidateUniformityContext } break; } - default: break; + default: + break; } addToWorkList(user); } diff --git a/source/slang/slang-ir-use-uninitialized-values.cpp b/source/slang/slang-ir-use-uninitialized-values.cpp index 390d1a9fc..da88463d6 100644 --- a/source/slang/slang-ir-use-uninitialized-values.cpp +++ b/source/slang/slang-ir-use-uninitialized-values.cpp @@ -21,8 +21,10 @@ static bool isMetaOp(IRInst* inst) case kIROp_IsFloat: case kIROp_IsVector: case kIROp_GetNaturalStride: - case kIROp_TypeEquals: return true; - default: break; + case kIROp_TypeEquals: + return true; + default: + break; } return false; @@ -65,8 +67,10 @@ static ParameterCheckType isPotentiallyUnintended(IRParam* param, Stage stage, i { case kIROp_VerticesType: case kIROp_IndicesType: - case kIROp_PrimitivesType: return Never; - default: break; + case kIROp_PrimitivesType: + return Never; + default: + break; } return AsOut; @@ -87,7 +91,8 @@ static ParameterCheckType isPotentiallyUnintended(IRParam* param, Stage stage, i case Stage::Geometry: // Second parameter is the triangle stream return (index == 1) ? Never : AsInOut; - default: break; + default: + break; } return AsInOut; @@ -105,8 +110,10 @@ static bool isAliasable(IRInst* inst) case kIROp_FieldAddress: case kIROp_GetElement: case kIROp_GetElementPtr: - case kIROp_InOutImplicitCast: return true; - default: break; + case kIROp_InOutImplicitCast: + return true; + default: + break; } return false; @@ -122,8 +129,10 @@ static bool isDifferentiableFunc(IRInst* func) case kIROp_ForwardDifferentiableDecoration: case kIROp_BackwardDerivativeDecoration: case kIROp_BackwardDifferentiableDecoration: - case kIROp_UserDefinedBackwardDerivativeDecoration: return true; - default: break; + case kIROp_UserDefinedBackwardDerivativeDecoration: + return true; + default: + break; } } @@ -288,7 +297,8 @@ static InstructionUsageType getInstructionUsageType(IRInst* user, IRInst* inst) case kIROp_Store: case kIROp_SwizzledStore: case kIROp_SPIRVAsm: - case kIROp_AtomicStore: return Store; + case kIROp_AtomicStore: + return Store; case kIROp_SPIRVAsmOperandInst: // For SPIRV asm instructions, need to check out the entire @@ -302,7 +312,8 @@ static InstructionUsageType getInstructionUsageType(IRInst* user, IRInst* inst) // Miscellaenous cases case kIROp_ManagedPtrAttach: - case kIROp_Unmodified: return Store; + case kIROp_Unmodified: + return Store; default: // Default case is that if the instruction is a pointer, it @@ -331,9 +342,12 @@ static void collectInstructionByUsage( InstructionUsageType usage = getInstructionUsageType(user, inst); switch (usage) { - case Load: return loads.add(user); - case Store: return stores.add(user); - case StoreParent: return stores.add(user->getParent()); + case Load: + return loads.add(user); + case Store: + return stores.add(user); + case StoreParent: + return stores.add(user->getParent()); } } diff --git a/source/slang/slang-ir-util.cpp b/source/slang/slang-ir-util.cpp index eb6b8a7aa..c7b40da8b 100644 --- a/source/slang/slang-ir-util.cpp +++ b/source/slang/slang-ir-util.cpp @@ -116,7 +116,8 @@ IROp getTypeStyle(IROp op) // All float like return kIROp_FloatType; } - default: return kIROp_Invalid; + default: + return kIROp_Invalid; } } @@ -124,8 +125,10 @@ IROp getTypeStyle(BaseType op) { switch (op) { - case BaseType::Void: return kIROp_VoidType; - case BaseType::Bool: return kIROp_BoolType; + case BaseType::Void: + return kIROp_VoidType; + case BaseType::Bool: + return kIROp_BoolType; case BaseType::Char: case BaseType::Int8: case BaseType::Int16: @@ -136,11 +139,14 @@ IROp getTypeStyle(BaseType op) case BaseType::UInt16: case BaseType::UInt: case BaseType::UInt64: - case BaseType::UIntPtr: return kIROp_IntType; + case BaseType::UIntPtr: + return kIROp_IntType; case BaseType::Half: case BaseType::Float: - case BaseType::Double: return kIROp_FloatType; - default: return kIROp_Invalid; + case BaseType::Double: + return kIROp_FloatType; + default: + return kIROp_Invalid; } } @@ -199,7 +205,8 @@ bool isValueType(IRInst* dataType) case kIROp_ArrayType: case kIROp_FuncType: case kIROp_RaytracingAccelerationStructureType: - case kIROp_GLSLAtomicUintType: return true; + case kIROp_GLSLAtomicUintType: + return true; default: // Read-only resource handles are considered as Value type. if (auto resType = as<IRResourceTypeBase>(dataType)) @@ -237,10 +244,13 @@ bool isSimpleDataType(IRType* type) case kIROp_MatrixType: case kIROp_InterfaceType: case kIROp_AnyValueType: - case kIROp_PtrType: return true; + case kIROp_PtrType: + return true; case kIROp_ArrayType: - case kIROp_UnsizedArrayType: return isSimpleDataType((IRType*)type->getOperand(0)); - default: return false; + case kIROp_UnsizedArrayType: + return isSimpleDataType((IRType*)type->getOperand(0)); + default: + return false; } } @@ -352,10 +362,16 @@ void copyNameHintAndDebugDecorations(IRInst* dest, IRInst* src) { switch (decor->getOp()) { - case kIROp_NameHintDecoration: nameHintDecoration = decor; break; + case kIROp_NameHintDecoration: + nameHintDecoration = decor; + break; case kIROp_ImportDecoration: - case kIROp_ExportDecoration: linkageDecoration = decor; break; - case kIROp_DebugLocationDecoration: debugLocationDecoration = decor; break; + case kIROp_ExportDecoration: + linkageDecoration = decor; + break; + case kIROp_DebugLocationDecoration: + debugLocationDecoration = decor; + break; } } if (nameHintDecoration) @@ -379,21 +395,51 @@ void getTypeNameHint(StringBuilder& sb, IRInst* type) switch (type->getOp()) { - case kIROp_FloatType: sb << "float"; break; - case kIROp_HalfType: sb << "half"; break; - case kIROp_DoubleType: sb << "double"; break; - case kIROp_IntType: sb << "int"; break; - case kIROp_Int8Type: sb << "int8"; break; - case kIROp_Int16Type: sb << "int16"; break; - case kIROp_Int64Type: sb << "int64"; break; - case kIROp_IntPtrType: sb << "intptr"; break; - case kIROp_UIntType: sb << "uint"; break; - case kIROp_UInt8Type: sb << "uint8"; break; - case kIROp_UInt16Type: sb << "uint16"; break; - case kIROp_UInt64Type: sb << "uint64"; break; - case kIROp_UIntPtrType: sb << "uintptr"; break; - case kIROp_CharType: sb << "char"; break; - case kIROp_StringType: sb << "string"; break; + case kIROp_FloatType: + sb << "float"; + break; + case kIROp_HalfType: + sb << "half"; + break; + case kIROp_DoubleType: + sb << "double"; + break; + case kIROp_IntType: + sb << "int"; + break; + case kIROp_Int8Type: + sb << "int8"; + break; + case kIROp_Int16Type: + sb << "int16"; + break; + case kIROp_Int64Type: + sb << "int64"; + break; + case kIROp_IntPtrType: + sb << "intptr"; + break; + case kIROp_UIntType: + sb << "uint"; + break; + case kIROp_UInt8Type: + sb << "uint8"; + break; + case kIROp_UInt16Type: + sb << "uint16"; + break; + case kIROp_UInt64Type: + sb << "uint64"; + break; + case kIROp_UIntPtrType: + sb << "uintptr"; + break; + case kIROp_CharType: + sb << "char"; + break; + case kIROp_StringType: + sb << "string"; + break; case kIROp_ArrayType: sb << "array<"; getTypeNameHint(sb, type->getOperand(0)); @@ -420,33 +466,64 @@ void getTypeNameHint(StringBuilder& sb, IRInst* type) auto textureType = as<IRResourceTypeBase>(type); switch (textureType->getAccess()) { - case SLANG_RESOURCE_ACCESS_APPEND: sb << "Append"; break; - case SLANG_RESOURCE_ACCESS_CONSUME: sb << "Consume"; break; - case SLANG_RESOURCE_ACCESS_RASTER_ORDERED: sb << "RasterizerOrdered"; break; - case SLANG_RESOURCE_ACCESS_WRITE: sb << "RW"; break; - case SLANG_RESOURCE_ACCESS_FEEDBACK: sb << "Feedback"; break; - case SLANG_RESOURCE_ACCESS_READ: break; + case SLANG_RESOURCE_ACCESS_APPEND: + sb << "Append"; + break; + case SLANG_RESOURCE_ACCESS_CONSUME: + sb << "Consume"; + break; + case SLANG_RESOURCE_ACCESS_RASTER_ORDERED: + sb << "RasterizerOrdered"; + break; + case SLANG_RESOURCE_ACCESS_WRITE: + sb << "RW"; + break; + case SLANG_RESOURCE_ACCESS_FEEDBACK: + sb << "Feedback"; + break; + case SLANG_RESOURCE_ACCESS_READ: + break; } if (textureType->isCombined()) { switch (textureType->GetBaseShape()) { - case SLANG_TEXTURE_1D: sb << "Sampler1D"; break; - case SLANG_TEXTURE_2D: sb << "Sampler2D"; break; - case SLANG_TEXTURE_3D: sb << "Sampler3D"; break; - case SLANG_TEXTURE_CUBE: sb << "SamplerCube"; break; - case SLANG_TEXTURE_BUFFER: sb << "SamplerBuffer"; break; + case SLANG_TEXTURE_1D: + sb << "Sampler1D"; + break; + case SLANG_TEXTURE_2D: + sb << "Sampler2D"; + break; + case SLANG_TEXTURE_3D: + sb << "Sampler3D"; + break; + case SLANG_TEXTURE_CUBE: + sb << "SamplerCube"; + break; + case SLANG_TEXTURE_BUFFER: + sb << "SamplerBuffer"; + break; } } else { switch (textureType->GetBaseShape()) { - case SLANG_TEXTURE_1D: sb << "Texture1D"; break; - case SLANG_TEXTURE_2D: sb << "Texture2D"; break; - case SLANG_TEXTURE_3D: sb << "Texture3D"; break; - case SLANG_TEXTURE_CUBE: sb << "TextureCube"; break; - case SLANG_TEXTURE_BUFFER: sb << "Buffer"; break; + case SLANG_TEXTURE_1D: + sb << "Texture1D"; + break; + case SLANG_TEXTURE_2D: + sb << "Texture2D"; + break; + case SLANG_TEXTURE_3D: + sb << "Texture3D"; + break; + case SLANG_TEXTURE_CUBE: + sb << "TextureCube"; + break; + case SLANG_TEXTURE_BUFFER: + sb << "Buffer"; + break; } } if (textureType->isMultisample()) @@ -483,14 +560,24 @@ void getTypeNameHint(StringBuilder& sb, IRInst* type) getTypeNameHint(sb, as<IRGLSLShaderStorageBufferType>(type)->getElementType()); sb << ">"; break; - case kIROp_HLSLByteAddressBufferType: sb << "ByteAddressBuffer"; break; - case kIROp_HLSLRWByteAddressBufferType: sb << "RWByteAddressBuffer"; break; + case kIROp_HLSLByteAddressBufferType: + sb << "ByteAddressBuffer"; + break; + case kIROp_HLSLRWByteAddressBufferType: + sb << "RWByteAddressBuffer"; + break; case kIROp_HLSLRasterizerOrderedByteAddressBufferType: sb << "RasterizerOrderedByteAddressBuffer"; break; - case kIROp_GLSLAtomicUintType: sb << "AtomicCounter"; break; - case kIROp_RaytracingAccelerationStructureType: sb << "RayTracingAccelerationStructure"; break; - case kIROp_HitObjectType: sb << "HitObject"; break; + case kIROp_GLSLAtomicUintType: + sb << "AtomicCounter"; + break; + case kIROp_RaytracingAccelerationStructureType: + sb << "RayTracingAccelerationStructure"; + break; + case kIROp_HitObjectType: + sb << "HitObject"; + break; case kIROp_HLSLConstBufferPointerType: sb << "ConstantBufferPointer<"; getTypeNameHint(sb, as<IRHLSLConstBufferPointerType>(type)->getValueType()); @@ -521,9 +608,15 @@ void getTypeNameHint(StringBuilder& sb, IRInst* type) getTypeNameHint(sb, as<IRHLSLStructuredBufferTypeBase>(type)->getElementType()); sb << ">"; break; - case kIROp_SamplerStateType: sb << "SamplerState"; break; - case kIROp_SamplerComparisonStateType: sb << "SamplerComparisonState"; break; - case kIROp_TextureFootprintType: sb << "TextureFootprint"; break; + case kIROp_SamplerStateType: + sb << "SamplerState"; + break; + case kIROp_SamplerComparisonStateType: + sb << "SamplerComparisonState"; + break; + case kIROp_TextureFootprintType: + sb << "TextureFootprint"; + break; case kIROp_Specialize: { auto specialize = as<IRSpecialize>(type); @@ -567,7 +660,9 @@ void getTypeNameHint(StringBuilder& sb, IRInst* type) getTypeNameHint(sb, as<IRMatrixType>(type)->getColumnCount()); sb << ">"; break; - case kIROp_IntLit: sb << as<IRIntLit>(type)->getValue(); break; + case kIROp_IntLit: + sb << as<IRIntLit>(type)->getValue(); + break; default: if (auto decor = type->findDecoration<IRNameHintDecoration>()) sb << decor->getName(); @@ -582,8 +677,11 @@ IRInst* getRootAddr(IRInst* addr) switch (addr->getOp()) { case kIROp_GetElementPtr: - case kIROp_FieldAddress: addr = addr->getOperand(0); continue; - default: break; + case kIROp_FieldAddress: + addr = addr->getOperand(0); + continue; + default: + break; } break; } @@ -603,7 +701,8 @@ IRInst* getRootAddr(IRInst* addr, List<IRInst*>& outAccessChain, List<IRInst*>* outTypes->add(addr->getFullType()); addr = addr->getOperand(0); continue; - default: break; + default: + break; } break; } @@ -662,7 +761,8 @@ bool isPtrLikeOrHandleType(IRInst* type) case kIROp_PtrType: case kIROp_RefType: case kIROp_ConstRefType: - case kIROp_GLSLShaderStorageBufferType: return true; + case kIROp_GLSLShaderStorageBufferType: + return true; } return false; } @@ -789,13 +889,20 @@ IROp getSwapSideComparisonOp(IROp op) { switch (op) { - case kIROp_Eql: return kIROp_Eql; - case kIROp_Neq: return kIROp_Neq; - case kIROp_Leq: return kIROp_Geq; - case kIROp_Geq: return kIROp_Leq; - case kIROp_Less: return kIROp_Greater; - case kIROp_Greater: return kIROp_Less; - default: return kIROp_Nop; + case kIROp_Eql: + return kIROp_Eql; + case kIROp_Neq: + return kIROp_Neq; + case kIROp_Leq: + return kIROp_Geq; + case kIROp_Geq: + return kIROp_Leq; + case kIROp_Less: + return kIROp_Greater; + case kIROp_Greater: + return kIROp_Less; + default: + return kIROp_Nop; } } @@ -852,8 +959,11 @@ void removeLinkageDecorations(IRGlobalValueWithCode* func) case kIROp_DllImportDecoration: case kIROp_CudaDeviceExportDecoration: case kIROp_DllExportDecoration: - case kIROp_HLSLExportDecoration: toRemove.add(inst); break; - default: break; + case kIROp_HLSLExportDecoration: + toRemove.add(inst); + break; + default: + break; } } for (auto inst : toRemove) @@ -893,12 +1003,16 @@ IRInst* tryFindBasePtr(IRInst* inst, IRInst* parentFunc) // Keep going up the tree until we find a variable. switch (inst->getOp()) { - case kIROp_Var: return getParentFunc(inst) == parentFunc ? inst : nullptr; - case kIROp_Param: return getParentFunc(inst) == parentFunc ? inst : nullptr; + case kIROp_Var: + return getParentFunc(inst) == parentFunc ? inst : nullptr; + case kIROp_Param: + return getParentFunc(inst) == parentFunc ? inst : nullptr; case kIROp_GetElementPtr: return tryFindBasePtr(as<IRGetElementPtr>(inst)->getBase(), parentFunc); - case kIROp_FieldAddress: return tryFindBasePtr(as<IRFieldAddress>(inst)->getBase(), parentFunc); - default: return nullptr; + case kIROp_FieldAddress: + return tryFindBasePtr(as<IRFieldAddress>(inst)->getBase(), parentFunc); + default: + return nullptr; } } @@ -1061,7 +1175,8 @@ bool doesCalleeHaveSideEffect(IRInst* callee) { case kIROp_NoSideEffectDecoration: case kIROp_ReadNoneDecoration: - case kIROp_IgnoreSideEffectsDecoration: return false; + case kIROp_IgnoreSideEffectsDecoration: + return false; } } return true; @@ -1101,8 +1216,10 @@ IRInst* getVulkanPayloadLocation(IRInst* payloadGlobalVar) case kIROp_VulkanRayPayloadInDecoration: case kIROp_VulkanCallablePayloadDecoration: case kIROp_VulkanCallablePayloadInDecoration: - case kIROp_VulkanHitObjectAttributesDecoration: return decor->getOperand(0); - default: continue; + case kIROp_VulkanHitObjectAttributesDecoration: + return decor->getOperand(0); + default: + continue; } } return location; @@ -1203,9 +1320,12 @@ bool isGlobalOrUnknownMutableAddress(IRGlobalValueWithCode* parentFunc, IRInst* case kIROp_GlobalParam: case kIROp_GlobalConstant: case kIROp_Var: - case kIROp_Param: break; - case kIROp_Call: return true; - default: return true; + case kIROp_Param: + break; + case kIROp_Call: + return true; + default: + return true; } auto addrInstParent = getParentFunc(root); @@ -1216,9 +1336,12 @@ bool isZero(IRInst* inst) { switch (inst->getOp()) { - case kIROp_IntLit: return as<IRIntLit>(inst)->getValue() == 0; - case kIROp_FloatLit: return as<IRFloatLit>(inst)->getValue() == 0.0; - case kIROp_BoolLit: return as<IRBoolLit>(inst)->getValue() == false; + case kIROp_IntLit: + return as<IRIntLit>(inst)->getValue() == 0; + case kIROp_FloatLit: + return as<IRFloatLit>(inst)->getValue() == 0.0; + case kIROp_BoolLit: + return as<IRBoolLit>(inst)->getValue() == false; case kIROp_MakeVector: case kIROp_MakeVectorFromScalar: case kIROp_MakeMatrix: @@ -1236,8 +1359,10 @@ bool isZero(IRInst* inst) return true; } case kIROp_CastIntToFloat: - case kIROp_CastFloatToInt: return isZero(inst->getOperand(0)); - default: return false; + case kIROp_CastFloatToInt: + return isZero(inst->getOperand(0)); + default: + return false; } } @@ -1245,9 +1370,12 @@ bool isOne(IRInst* inst) { switch (inst->getOp()) { - case kIROp_IntLit: return as<IRIntLit>(inst)->getValue() == 1; - case kIROp_FloatLit: return as<IRFloatLit>(inst)->getValue() == 1.0; - case kIROp_BoolLit: return as<IRBoolLit>(inst)->getValue(); + case kIROp_IntLit: + return as<IRIntLit>(inst)->getValue() == 1; + case kIROp_FloatLit: + return as<IRFloatLit>(inst)->getValue() == 1.0; + case kIROp_BoolLit: + return as<IRBoolLit>(inst)->getValue(); case kIROp_MakeVector: case kIROp_MakeVectorFromScalar: case kIROp_MakeMatrix: @@ -1265,8 +1393,10 @@ bool isOne(IRInst* inst) return true; } case kIROp_CastIntToFloat: - case kIROp_CastFloatToInt: return isOne(inst->getOperand(0)); - default: return false; + case kIROp_CastFloatToInt: + return isOne(inst->getOperand(0)); + default: + return false; } } @@ -1274,8 +1404,10 @@ IRPtrTypeBase* isMutablePointerType(IRInst* inst) { switch (inst->getOp()) { - case kIROp_ConstRefType: return nullptr; - default: return as<IRPtrTypeBase>(inst); + case kIROp_ConstRefType: + return nullptr; + default: + return as<IRPtrTypeBase>(inst); } } @@ -1527,13 +1659,20 @@ IRType* getSPIRVSampledElementType(IRInst* sampledType) IRBuilder builder(sampledType); switch (sampledElementType->getOp()) { - case kIROp_HalfType: sampledElementType = builder.getBasicType(BaseType::Float); break; + case kIROp_HalfType: + sampledElementType = builder.getBasicType(BaseType::Float); + break; case kIROp_UInt16Type: case kIROp_UInt8Type: - case kIROp_CharType: sampledElementType = builder.getBasicType(BaseType::UInt); break; + case kIROp_CharType: + sampledElementType = builder.getBasicType(BaseType::UInt); + break; case kIROp_Int8Type: - case kIROp_Int16Type: sampledElementType = builder.getBasicType(BaseType::Int); break; - default: break; + case kIROp_Int16Type: + sampledElementType = builder.getBasicType(BaseType::Int); + break; + default: + break; } return sampledElementType; } @@ -1565,23 +1704,40 @@ UnownedStringSlice getBasicTypeNameHint(IRType* basicType) { switch (basicType->getOp()) { - case kIROp_IntType: return UnownedStringSlice::fromLiteral("int"); - case kIROp_Int8Type: return UnownedStringSlice::fromLiteral("int8"); - case kIROp_Int16Type: return UnownedStringSlice::fromLiteral("int16"); - case kIROp_Int64Type: return UnownedStringSlice::fromLiteral("int64"); - case kIROp_IntPtrType: return UnownedStringSlice::fromLiteral("intptr"); - case kIROp_UIntType: return UnownedStringSlice::fromLiteral("uint"); - case kIROp_UInt8Type: return UnownedStringSlice::fromLiteral("uint8"); - case kIROp_UInt16Type: return UnownedStringSlice::fromLiteral("uint16"); - case kIROp_UInt64Type: return UnownedStringSlice::fromLiteral("uint64"); - case kIROp_UIntPtrType: return UnownedStringSlice::fromLiteral("uintptr"); - case kIROp_FloatType: return UnownedStringSlice::fromLiteral("float"); - case kIROp_HalfType: return UnownedStringSlice::fromLiteral("half"); - case kIROp_DoubleType: return UnownedStringSlice::fromLiteral("double"); - case kIROp_BoolType: return UnownedStringSlice::fromLiteral("bool"); - case kIROp_VoidType: return UnownedStringSlice::fromLiteral("void"); - case kIROp_CharType: return UnownedStringSlice::fromLiteral("char"); - default: return UnownedStringSlice(); + case kIROp_IntType: + return UnownedStringSlice::fromLiteral("int"); + case kIROp_Int8Type: + return UnownedStringSlice::fromLiteral("int8"); + case kIROp_Int16Type: + return UnownedStringSlice::fromLiteral("int16"); + case kIROp_Int64Type: + return UnownedStringSlice::fromLiteral("int64"); + case kIROp_IntPtrType: + return UnownedStringSlice::fromLiteral("intptr"); + case kIROp_UIntType: + return UnownedStringSlice::fromLiteral("uint"); + case kIROp_UInt8Type: + return UnownedStringSlice::fromLiteral("uint8"); + case kIROp_UInt16Type: + return UnownedStringSlice::fromLiteral("uint16"); + case kIROp_UInt64Type: + return UnownedStringSlice::fromLiteral("uint64"); + case kIROp_UIntPtrType: + return UnownedStringSlice::fromLiteral("uintptr"); + case kIROp_FloatType: + return UnownedStringSlice::fromLiteral("float"); + case kIROp_HalfType: + return UnownedStringSlice::fromLiteral("half"); + case kIROp_DoubleType: + return UnownedStringSlice::fromLiteral("double"); + case kIROp_BoolType: + return UnownedStringSlice::fromLiteral("bool"); + case kIROp_VoidType: + return UnownedStringSlice::fromLiteral("void"); + case kIROp_CharType: + return UnownedStringSlice::fromLiteral("char"); + default: + return UnownedStringSlice(); } } @@ -1639,8 +1795,10 @@ struct GenericChildrenMigrationContextImpl case kIROp_ClassType: case kIROp_Func: case kIROp_Generic: - case kIROp_Expand: return false; - default: break; + case kIROp_Expand: + return false; + default: + break; } if (as<IRConstant>(inst)) return false; @@ -1706,7 +1864,8 @@ IRType* dropNormAttributes(IRType* const t) switch (a->getAttr()->getOp()) { case kIROp_UNormAttr: - case kIROp_SNormAttr: return dropNormAttributes(a->getBaseType()); + case kIROp_SNormAttr: + return dropNormAttributes(a->getBaseType()); } } return t; diff --git a/source/slang/slang-ir-util.h b/source/slang/slang-ir-util.h index d700ae35e..b483d950c 100644 --- a/source/slang/slang-ir-util.h +++ b/source/slang/slang-ir-util.h @@ -340,8 +340,10 @@ inline bool isCompositeType(IRType* type) { case kIROp_StructType: case kIROp_ArrayType: - case kIROp_UnsizedArrayType: return true; - default: return false; + case kIROp_UnsizedArrayType: + return true; + default: + return false; } } diff --git a/source/slang/slang-ir-validate.cpp b/source/slang/slang-ir-validate.cpp index 36cb518c4..4652b011f 100644 --- a/source/slang/slang-ir-validate.cpp +++ b/source/slang/slang-ir-validate.cpp @@ -243,7 +243,8 @@ void validateIRInstOperand(IRValidateContext* context, IRInst* inst, IRUse* oper // Allow exceptions. switch (inst->getOp()) { - case kIROp_DifferentiableTypeDictionaryItem: return; + case kIROp_DifferentiableTypeDictionaryItem: + return; } // // We failed to find `operandParent` while walking the ancestors of `inst`, @@ -289,8 +290,10 @@ void validateIRInstOperands(IRInst* inst) case kIROp_ifElse: case kIROp_unconditionalBranch: case kIROp_conditionalBranch: - case kIROp_Switch: return; - default: break; + case kIROp_Switch: + return; + default: + break; } validateIRInstOperands(nullptr, inst); diff --git a/source/slang/slang-ir-variable-scope-correction.cpp b/source/slang/slang-ir-variable-scope-correction.cpp index bc425a3ba..2994f4d3d 100644 --- a/source/slang/slang-ir-variable-scope-correction.cpp +++ b/source/slang/slang-ir-variable-scope-correction.cpp @@ -254,7 +254,8 @@ bool VariableScopeCorrectionContext::_isStorableType(IRType* type) { case kIROp_VectorType: case kIROp_MatrixType: - case kIROp_StructType: return true; + case kIROp_StructType: + return true; case kIROp_ArrayType: { if (auto arrayType = as<IRArrayTypeBase>(type)) @@ -262,8 +263,10 @@ bool VariableScopeCorrectionContext::_isStorableType(IRType* type) else return false; } - case kIROp_UnsizedArrayType: return false; - default: return false; + case kIROp_UnsizedArrayType: + return false; + default: + return false; } } diff --git a/source/slang/slang-ir-wgsl-legalize.cpp b/source/slang/slang-ir-wgsl-legalize.cpp index 96eb13be4..691810cbb 100644 --- a/source/slang/slang-ir-wgsl-legalize.cpp +++ b/source/slang/slang-ir-wgsl-legalize.cpp @@ -330,8 +330,10 @@ void LegalizeWGSLEntryPointContext::legalizeCall(IRCall* call) switch (arg->getOp()) { case kIROp_Var: - case kIROp_Param: continue; - default: break; + case kIROp_Param: + continue; + default: + break; } // Create a local variable to hold the input argument. @@ -386,8 +388,10 @@ void LegalizeWGSLEntryPointContext::legalizeBinaryOp(IRInst* inst) switch (type->getOp()) { case kIROp_VectorType: - case kIROp_MatrixType: return true; - default: return false; + case kIROp_MatrixType: + return true; + default: + return false; } }; if (isVectorOrMatrix(inst->getOperand(0)->getDataType()) && @@ -417,8 +421,12 @@ void LegalizeWGSLEntryPointContext::processInst(IRInst* inst) { switch (inst->getOp()) { - case kIROp_Call: legalizeCall(static_cast<IRCall*>(inst)); break; - case kIROp_Switch: legalizeSwitch(as<IRSwitch>(inst)); break; + case kIROp_Call: + legalizeCall(static_cast<IRCall*>(inst)); + break; + case kIROp_Switch: + legalizeSwitch(as<IRSwitch>(inst)); + break; // For all binary operators, make sure both side of the operator have the same type // (vector-ness and matrix-ness). @@ -440,7 +448,9 @@ void LegalizeWGSLEntryPointContext::processInst(IRInst* inst) case kIROp_Greater: case kIROp_Less: case kIROp_Geq: - case kIROp_Leq: legalizeBinaryOp(inst); break; + case kIROp_Leq: + legalizeBinaryOp(inst); + break; default: for (auto child : inst->getModifiableChildren()) diff --git a/source/slang/slang-ir-wrap-structured-buffers.cpp b/source/slang/slang-ir-wrap-structured-buffers.cpp index 76fa5e289..aef301745 100644 --- a/source/slang/slang-ir-wrap-structured-buffers.cpp +++ b/source/slang/slang-ir-wrap-structured-buffers.cpp @@ -170,8 +170,10 @@ struct WrapStructuredBuffersContext case kIROp_StructuredBufferLoadStatus: case kIROp_RWStructuredBufferStore: case kIROp_RWStructuredBufferLoadStatus: - case kIROp_RWStructuredBufferGetElementPtr: break; - default: return; + case kIROp_RWStructuredBufferGetElementPtr: + break; + default: + return; } builder->setInsertAfter(user); diff --git a/source/slang/slang-ir.cpp b/source/slang/slang-ir.cpp index 3bd31d6e9..2cbafea6c 100644 --- a/source/slang/slang-ir.cpp +++ b/source/slang/slang-ir.cpp @@ -82,7 +82,8 @@ bool isSimpleDecoration(IROp op) { return true; } - default: break; + default: + break; } return false; } @@ -303,9 +304,13 @@ IRIntegerValue getIntVal(IRInst* inst) { switch (inst->getOp()) { - default: SLANG_UNEXPECTED("needed a known integer value"); UNREACHABLE_RETURN(0); + default: + SLANG_UNEXPECTED("needed a known integer value"); + UNREACHABLE_RETURN(0); - case kIROp_IntLit: return static_cast<IRConstant*>(inst)->value.intVal; break; + case kIROp_IntLit: + return static_cast<IRConstant*>(inst)->value.intVal; + break; } } @@ -559,7 +564,8 @@ static IRBlock::SuccessorList getSuccessors(IRInst* terminator) case kIROp_Return: case kIROp_Unreachable: case kIROp_MissingReturn: - case kIROp_GenericAsm: break; + case kIROp_GenericAsm: + break; case kIROp_unconditionalBranch: case kIROp_loop: @@ -723,11 +729,15 @@ UInt IRUnconditionalBranch::getArgCount() { switch (getOp()) { - case kIROp_unconditionalBranch: return getOperandCount() - 1; + case kIROp_unconditionalBranch: + return getOperandCount() - 1; - case kIROp_loop: return getOperandCount() - 3; + case kIROp_loop: + return getOperandCount() - 3; - default: SLANG_UNEXPECTED("unhandled unconditional branch opcode"); UNREACHABLE_RETURN(0); + default: + SLANG_UNEXPECTED("unhandled unconditional branch opcode"); + UNREACHABLE_RETURN(0); } } @@ -735,11 +745,15 @@ IRUse* IRUnconditionalBranch::getArgs() { switch (getOp()) { - case kIROp_unconditionalBranch: return getOperands() + 1; + case kIROp_unconditionalBranch: + return getOperands() + 1; - case kIROp_loop: return getOperands() + 3; + case kIROp_loop: + return getOperands() + 3; - default: SLANG_UNEXPECTED("unhandled unconditional branch opcode"); UNREACHABLE_RETURN(0); + default: + SLANG_UNEXPECTED("unhandled unconditional branch opcode"); + UNREACHABLE_RETURN(0); } } @@ -747,9 +761,14 @@ void IRUnconditionalBranch::removeArgument(UInt index) { switch (getOp()) { - case kIROp_unconditionalBranch: removeOperand(1 + index); break; - case kIROp_loop: removeOperand(3 + index); break; - default: SLANG_UNEXPECTED("unhandled unconditional branch opcode"); + case kIROp_unconditionalBranch: + removeOperand(1 + index); + break; + case kIROp_loop: + removeOperand(3 + index); + break; + default: + SLANG_UNEXPECTED("unhandled unconditional branch opcode"); } } @@ -839,7 +858,8 @@ bool isTerminatorInst(IROp op) { switch (op) { - default: return false; + default: + return false; case kIROp_Return: case kIROp_unconditionalBranch: @@ -848,7 +868,8 @@ bool isTerminatorInst(IROp op) case kIROp_ifElse: case kIROp_Switch: case kIROp_Unreachable: - case kIROp_MissingReturn: return true; + case kIROp_MissingReturn: + return true; } } @@ -1239,11 +1260,14 @@ IRInst* IRInsertLoc::getParent() const switch (getMode()) { default: - case Mode::None: return nullptr; + case Mode::None: + return nullptr; case Mode::Before: - case Mode::After: return inst->getParent(); + case Mode::After: + return inst->getParent(); case Mode::AtStart: - case Mode::AtEnd: return inst; + case Mode::AtEnd: + return inst; } } @@ -2069,7 +2093,8 @@ bool IRConstant::isValueEqual(IRConstant* rhs) { return true; } - default: break; + default: + break; } SLANG_ASSERT(!"Unhandled type"); @@ -2158,7 +2183,9 @@ IRConstant* IRBuilder::_findOrEmitConstant(IRConstant& keyInst) switch (keyInst.getOp()) { - default: SLANG_UNEXPECTED("missing case for IR constant"); break; + default: + SLANG_UNEXPECTED("missing case for IR constant"); + break; case kIROp_BoolLit: case kIROp_IntLit: @@ -2246,17 +2273,31 @@ IRInst* IRBuilder::getIntValue(IRType* type, IRIntegerValue inValue) // Truncate the input value based on `type`. switch (type->getOp()) { - case kIROp_Int8Type: keyInst.value.intVal = static_cast<int8_t>(inValue); break; - case kIROp_Int16Type: keyInst.value.intVal = static_cast<int16_t>(inValue); break; - case kIROp_IntType: keyInst.value.intVal = static_cast<int32_t>(inValue); break; - case kIROp_UInt8Type: keyInst.value.intVal = static_cast<uint8_t>(inValue); break; - case kIROp_UInt16Type: keyInst.value.intVal = static_cast<uint16_t>(inValue); break; + case kIROp_Int8Type: + keyInst.value.intVal = static_cast<int8_t>(inValue); + break; + case kIROp_Int16Type: + keyInst.value.intVal = static_cast<int16_t>(inValue); + break; + case kIROp_IntType: + keyInst.value.intVal = static_cast<int32_t>(inValue); + break; + case kIROp_UInt8Type: + keyInst.value.intVal = static_cast<uint8_t>(inValue); + break; + case kIROp_UInt16Type: + keyInst.value.intVal = static_cast<uint16_t>(inValue); + break; case kIROp_BoolType: keyInst.m_op = kIROp_BoolLit; keyInst.value.intVal = ((inValue != 0) ? 1 : 0); break; - case kIROp_UIntType: keyInst.value.intVal = static_cast<uint32_t>(inValue); break; - default: keyInst.value.intVal = inValue; break; + case kIROp_UIntType: + keyInst.value.intVal = static_cast<uint32_t>(inValue); + break; + default: + keyInst.value.intVal = inValue; + break; } return _findOrEmitConstant(keyInst); } @@ -2270,9 +2311,15 @@ IRInst* IRBuilder::getFloatValue(IRType* type, IRFloatingPointValue inValue) // Truncate the input value based on `type`. switch (type->getOp()) { - case kIROp_FloatType: keyInst.value.floatVal = static_cast<float>(inValue); break; - case kIROp_HalfType: keyInst.value.floatVal = HalfToFloat(FloatToHalf((float)inValue)); break; - default: keyInst.value.floatVal = inValue; break; + case kIROp_FloatType: + keyInst.value.floatVal = static_cast<float>(inValue); + break; + case kIROp_HalfType: + keyInst.value.floatVal = HalfToFloat(FloatToHalf((float)inValue)); + break; + default: + keyInst.value.floatVal = inValue; + break; } return _findOrEmitConstant(keyInst); @@ -3714,13 +3761,18 @@ IRInst* IRBuilder::emitDefaultConstruct(IRType* type, bool fallback) case kIROp_UIntType: case kIROp_UIntPtrType: case kIROp_UInt64Type: - case kIROp_CharType: return getIntValue(type, 0); - case kIROp_BoolType: return getBoolValue(false); + case kIROp_CharType: + return getIntValue(type, 0); + case kIROp_BoolType: + return getBoolValue(false); case kIROp_FloatType: case kIROp_HalfType: - case kIROp_DoubleType: return getFloatValue(type, 0.0); - case kIROp_VoidType: return getVoidValue(); - case kIROp_StringType: return getStringValue(UnownedStringSlice()); + case kIROp_DoubleType: + return getFloatValue(type, 0.0); + case kIROp_VoidType: + return getVoidValue(); + case kIROp_StringType: + return getStringValue(UnownedStringSlice()); case kIROp_PtrType: case kIROp_InOutType: case kIROp_OutType: @@ -3729,7 +3781,8 @@ IRInst* IRBuilder::emitDefaultConstruct(IRType* type, bool fallback) case kIROp_ConstRefType: case kIROp_ComPtrType: case kIROp_NativePtrType: - case kIROp_NativeStringType: return getNullPtrValue(type); + case kIROp_NativeStringType: + return getNullPtrValue(type); case kIROp_OptionalType: { auto inner = @@ -3804,7 +3857,8 @@ IRInst* IRBuilder::emitDefaultConstruct(IRType* type, bool fallback) return nullptr; return emitIntrinsicInst(type, kIROp_MakeMatrixFromScalar, 1, &inner); } - default: break; + default: + break; } if (fallback) { @@ -3842,19 +3896,25 @@ static TypeCastStyle _getTypeStyleId(IRType* type) auto style = getTypeStyle(type->getOp()); switch (style) { - case kIROp_IntType: return TypeCastStyle::Int; + case kIROp_IntType: + return TypeCastStyle::Int; case kIROp_FloatType: case kIROp_HalfType: - case kIROp_DoubleType: return TypeCastStyle::Float; - case kIROp_BoolType: return TypeCastStyle::Bool; + case kIROp_DoubleType: + return TypeCastStyle::Float; + case kIROp_BoolType: + return TypeCastStyle::Bool; case kIROp_PtrType: case kIROp_InOutType: case kIROp_OutType: case kIROp_RawPointerType: case kIROp_RefType: - case kIROp_ConstRefType: return TypeCastStyle::Ptr; - case kIROp_VoidType: return TypeCastStyle::Void; - default: return TypeCastStyle::Unknown; + case kIROp_ConstRefType: + return TypeCastStyle::Ptr; + case kIROp_VoidType: + return TypeCastStyle::Void; + default: + return TypeCastStyle::Unknown; } } @@ -4166,10 +4226,15 @@ IRInst* IRBuilder::emitMakeCompositeFromScalar(IRType* type, IRInst* scalarValue { switch (type->getOp()) { - case kIROp_VectorType: return emitMakeVectorFromScalar(type, scalarValue); - case kIROp_MatrixType: return emitMakeMatrixFromScalar(type, scalarValue); - case kIROp_ArrayType: return emitMakeArrayFromElement(type, scalarValue); - default: SLANG_UNEXPECTED("unhandled composite type"); UNREACHABLE_RETURN(nullptr); + case kIROp_VectorType: + return emitMakeVectorFromScalar(type, scalarValue); + case kIROp_MatrixType: + return emitMakeMatrixFromScalar(type, scalarValue); + case kIROp_ArrayType: + return emitMakeArrayFromElement(type, scalarValue); + default: + SLANG_UNEXPECTED("unhandled composite type"); + UNREACHABLE_RETURN(nullptr); } } @@ -5825,7 +5890,8 @@ IRInst* IRBuilder::emitGetNativePtr(IRInst* value) 1, &value); break; - case kIROp_ExtractExistentialType: return emitGetNativePtr(value->getOperand(0)); + case kIROp_ExtractExistentialType: + return emitGetNativePtr(value->getOperand(0)); default: SLANG_UNEXPECTED("invalid operand type for `getNativePtr`."); UNREACHABLE_RETURN(nullptr); @@ -6555,9 +6621,11 @@ static bool shouldFoldInstIntoUses(IRDumpContext* context, IRInst* inst) case kIROp_StructType: case kIROp_ClassType: case kIROp_GLSLShaderStorageBufferType: - case kIROp_InterfaceType: return false; + case kIROp_InterfaceType: + return false; - default: break; + default: + break; } if (as<IRType>(inst)) @@ -6830,15 +6898,24 @@ static void dumpInstExpr(IRDumpContext* context, IRInst* inst) dumpType(context, irConst->getFullType()); return; - case kIROp_BoolLit: dump(context, irConst->value.intVal ? "true" : "false"); return; + case kIROp_BoolLit: + dump(context, irConst->value.intVal ? "true" : "false"); + return; - case kIROp_BlobLit: dump(context, "<binary blob>"); return; + case kIROp_BlobLit: + dump(context, "<binary blob>"); + return; - case kIROp_StringLit: dumpEncodeString(context, irConst->getStringSlice()); return; + case kIROp_StringLit: + dumpEncodeString(context, irConst->getStringSlice()); + return; - case kIROp_PtrLit: dump(context, "<ptr>"); return; + case kIROp_PtrLit: + dump(context, "<ptr>"); + return; - default: break; + default: + break; } } @@ -6846,9 +6923,15 @@ static void dumpInstExpr(IRDumpContext* context, IRInst* inst) // clear anyway to the user switch (op) { - case kIROp_SPIRVAsmOperandEnum: dumpInstExpr(context, inst->getOperand(0)); return; - case kIROp_SPIRVAsmOperandLiteral: dumpInstExpr(context, inst->getOperand(0)); return; - case kIROp_SPIRVAsmOperandInst: dumpInstExpr(context, inst->getOperand(0)); return; + case kIROp_SPIRVAsmOperandEnum: + dumpInstExpr(context, inst->getOperand(0)); + return; + case kIROp_SPIRVAsmOperandLiteral: + dumpInstExpr(context, inst->getOperand(0)); + return; + case kIROp_SPIRVAsmOperandInst: + dumpInstExpr(context, inst->getOperand(0)); + return; case kIROp_SPIRVAsmOperandRayPayloadFromLocation: dump(context, "__rayPayloadFromLocation("); dumpInstExpr(context, inst->getOperand(0)); @@ -6868,8 +6951,12 @@ static void dumpInstExpr(IRDumpContext* context, IRInst* inst) dump(context, "%"); dumpInstExpr(context, inst->getOperand(0)); return; - case kIROp_SPIRVAsmOperandResult: dump(context, "result"); return; - case kIROp_SPIRVAsmOperandTruncate: dump(context, "__truncate"); return; + case kIROp_SPIRVAsmOperandResult: + dump(context, "result"); + return; + case kIROp_SPIRVAsmOperandTruncate: + dump(context, "__truncate"); + return; case kIROp_SPIRVAsmOperandSampledType: dump(context, "__sampledType("); dumpInstExpr(context, inst->getOperand(0)); @@ -6913,19 +7000,24 @@ static void dumpInstBody(IRDumpContext* context, IRInst* inst) case kIROp_Func: case kIROp_GlobalVar: case kIROp_Generic: - case kIROp_Expand: dumpIRGlobalValueWithCode(context, (IRGlobalValueWithCode*)inst); return; + case kIROp_Expand: + dumpIRGlobalValueWithCode(context, (IRGlobalValueWithCode*)inst); + return; case kIROp_WitnessTable: case kIROp_StructType: case kIROp_ClassType: case kIROp_GLSLShaderStorageBufferType: - case kIROp_SPIRVAsm: dumpIRParentInst(context, inst); return; + case kIROp_SPIRVAsm: + dumpIRParentInst(context, inst); + return; case kIROp_WitnessTableEntry: dumpIRWitnessTableEntry(context, (IRWitnessTableEntry*)inst); return; - default: break; + default: + break; } // Okay, we have a seemingly "ordinary" op now @@ -7237,8 +7329,10 @@ bool isIntegralType(IRType* t) case BaseType::UInt: case BaseType::UInt64: case BaseType::IntPtr: - case BaseType::UIntPtr: return true; - default: return false; + case BaseType::UIntPtr: + return true; + default: + return false; } } return false; @@ -7252,8 +7346,10 @@ bool isFloatingType(IRType* t) { case BaseType::Float: case BaseType::Half: - case BaseType::Double: return true; - default: return false; + case BaseType::Double: + return true; + default: + return false; } } return false; @@ -7263,18 +7359,27 @@ IntInfo getIntTypeInfo(const IRType* intType) { switch (intType->getOp()) { - case kIROp_UInt8Type: return {8, false}; - case kIROp_UInt16Type: return {16, false}; - case kIROp_UIntType: return {32, false}; - case kIROp_UInt64Type: return {64, false}; - case kIROp_Int8Type: return {8, true}; - case kIROp_Int16Type: return {16, true}; - case kIROp_IntType: return {32, true}; - case kIROp_Int64Type: return {64, true}; + case kIROp_UInt8Type: + return {8, false}; + case kIROp_UInt16Type: + return {16, false}; + case kIROp_UIntType: + return {32, false}; + case kIROp_UInt64Type: + return {64, false}; + case kIROp_Int8Type: + return {8, true}; + case kIROp_Int16Type: + return {16, true}; + case kIROp_IntType: + return {32, true}; + case kIROp_Int64Type: + return {64, true}; case kIROp_IntPtrType: // target platform dependent case kIROp_UIntPtrType: // target platform dependent - default: SLANG_UNEXPECTED("Unhandled type passed to getIntTypeInfo"); + default: + SLANG_UNEXPECTED("Unhandled type passed to getIntTypeInfo"); } } @@ -7282,11 +7387,16 @@ IROp getIntTypeOpFromInfo(const IntInfo info) { switch (info.width) { - case 8: return info.isSigned ? kIROp_Int8Type : kIROp_UInt8Type; - case 16: return info.isSigned ? kIROp_Int16Type : kIROp_UInt16Type; - case 32: return info.isSigned ? kIROp_IntType : kIROp_UIntType; - case 64: return info.isSigned ? kIROp_Int64Type : kIROp_UInt64Type; - default: SLANG_UNEXPECTED("Unhandled info passed to getIntTypeOpFromInfo"); + case 8: + return info.isSigned ? kIROp_Int8Type : kIROp_UInt8Type; + case 16: + return info.isSigned ? kIROp_Int16Type : kIROp_UInt16Type; + case 32: + return info.isSigned ? kIROp_IntType : kIROp_UIntType; + case 64: + return info.isSigned ? kIROp_Int64Type : kIROp_UInt64Type; + default: + SLANG_UNEXPECTED("Unhandled info passed to getIntTypeOpFromInfo"); } } @@ -7294,10 +7404,14 @@ FloatInfo getFloatingTypeInfo(const IRType* floatType) { switch (floatType->getOp()) { - case kIROp_HalfType: return {16}; - case kIROp_FloatType: return {32}; - case kIROp_DoubleType: return {64}; - default: SLANG_UNEXPECTED("Unhandled type passed to getFloatTypeInfo"); + case kIROp_HalfType: + return {16}; + case kIROp_FloatType: + return {32}; + case kIROp_DoubleType: + return {64}; + default: + SLANG_UNEXPECTED("Unhandled type passed to getFloatTypeInfo"); } } @@ -7308,8 +7422,10 @@ bool isIntegralScalarOrCompositeType(IRType* t) switch (t->getOp()) { case kIROp_VectorType: - case kIROp_MatrixType: return isIntegralType((IRType*)t->getOperand(0)); - default: return isIntegralType(t); + case kIROp_MatrixType: + return isIntegralType((IRType*)t->getOperand(0)); + default: + return isIntegralType(t); } } @@ -7718,11 +7834,20 @@ void IRInst::insertAt(IRInsertLoc const& loc) IRInst* other = loc.getInst(); switch (loc.getMode()) { - case IRInsertLoc::Mode::None: break; - case IRInsertLoc::Mode::Before: insertBefore(other); break; - case IRInsertLoc::Mode::After: insertAfter(other); break; - case IRInsertLoc::Mode::AtStart: insertAtStart(other); break; - case IRInsertLoc::Mode::AtEnd: insertAtEnd(other); break; + case IRInsertLoc::Mode::None: + break; + case IRInsertLoc::Mode::Before: + insertBefore(other); + break; + case IRInsertLoc::Mode::After: + insertAfter(other); + break; + case IRInsertLoc::Mode::AtStart: + insertAtStart(other); + break; + case IRInsertLoc::Mode::AtEnd: + insertAtEnd(other); + break; } } @@ -7857,7 +7982,8 @@ bool IRInst::mightHaveSideEffects(SideEffectAnalysisOptions options) { // By default, assume that we might have side effects, // to safely cover all the instructions we haven't had time to think about. - default: break; + default: + break; case kIROp_Call: { @@ -8015,13 +8141,15 @@ bool IRInst::mightHaveSideEffects(SideEffectAnalysisOptions options) case kIROp_TorchTensorGetView: case kIROp_GetStringHash: case kIROp_AllocateOpaqueHandle: - case kIROp_GetArrayLength: return false; + case kIROp_GetArrayLength: + return false; case kIROp_ForwardDifferentiate: case kIROp_BackwardDifferentiate: case kIROp_BackwardDifferentiatePrimal: case kIROp_BackwardDifferentiatePropagate: - case kIROp_DetachDerivative: return false; + case kIROp_DetachDerivative: + return false; case kIROp_Div: case kIROp_IRem: @@ -8036,7 +8164,8 @@ bool IRInst::mightHaveSideEffects(SideEffectAnalysisOptions options) } return false; - case kIROp_FRem: return false; + case kIROp_FRem: + return false; } return true; } @@ -8288,7 +8417,8 @@ IRInst* getResolvedInstForDecorations(IRInst* inst, bool resolveThroughDifferent case kIROp_BackwardDifferentiatePropagate: candidate = candidate->getOperand(0); continue; - default: break; + default: + break; } } if (auto genericInst = as<IRGeneric>(candidate)) @@ -8314,11 +8444,14 @@ bool isDefinition(IRInst* inVal) // switch (val->getOp()) { - case kIROp_Func: return val->getFirstChild() != nullptr; + case kIROp_Func: + return val->getFirstChild() != nullptr; - case kIROp_GlobalConstant: return cast<IRGlobalConstant>(val)->getValue() != nullptr; + case kIROp_GlobalConstant: + return cast<IRGlobalConstant>(val)->getValue() != nullptr; - default: break; + default: + break; } // In all other cases, if we have an instruciton @@ -8451,7 +8584,8 @@ bool isMovableInst(IRInst* inst) case kIROp_Eql: case kIROp_ExtractExistentialType: case kIROp_ExtractExistentialValue: - case kIROp_ExtractExistentialWitnessTable: return true; + case kIROp_ExtractExistentialWitnessTable: + return true; case kIROp_Call: // Similar to the case in IRInst::mightHaveSideEffects, pure // calls are ok @@ -8464,12 +8598,15 @@ bool isMovableInst(IRInst* inst) switch (addrType->getOp()) { case kIROp_ConstantBufferType: - case kIROp_ParameterBlockType: return true; - default: break; + case kIROp_ParameterBlockType: + return true; + default: + break; } } return false; - default: return false; + default: + return false; } } diff --git a/source/slang/slang-ir.h b/source/slang/slang-ir.h index 0a31232f5..05a6fa55c 100644 --- a/source/slang/slang-ir.h +++ b/source/slang/slang-ir.h @@ -1407,12 +1407,18 @@ struct IRResourceTypeBase : IRType { switch (getOperand(1)->getOp()) { - case kIROp_TextureShape1DType: return SLANG_TEXTURE_1D; - case kIROp_TextureShape2DType: return SLANG_TEXTURE_2D; - case kIROp_TextureShape3DType: return SLANG_TEXTURE_3D; - case kIROp_TextureShapeCubeType: return SLANG_TEXTURE_CUBE; - case kIROp_TextureShapeBufferType: return SLANG_TEXTURE_BUFFER; - default: return SLANG_RESOURCE_NONE; + case kIROp_TextureShape1DType: + return SLANG_TEXTURE_1D; + case kIROp_TextureShape2DType: + return SLANG_TEXTURE_2D; + case kIROp_TextureShape3DType: + return SLANG_TEXTURE_3D; + case kIROp_TextureShapeCubeType: + return SLANG_TEXTURE_CUBE; + case kIROp_TextureShapeBufferType: + return SLANG_TEXTURE_BUFFER; + default: + return SLANG_RESOURCE_NONE; } } bool isFeedback() { return getIntVal(getAccessInst()) == kCoreModule_ResourceAccessFeedback; } @@ -1433,13 +1439,18 @@ struct IRResourceTypeBase : IRType { switch (getIntVal(constVal)) { - case kCoreModule_ResourceAccessReadOnly: return SLANG_RESOURCE_ACCESS_READ; - case kCoreModule_ResourceAccessReadWrite: return SLANG_RESOURCE_ACCESS_READ_WRITE; + case kCoreModule_ResourceAccessReadOnly: + return SLANG_RESOURCE_ACCESS_READ; + case kCoreModule_ResourceAccessReadWrite: + return SLANG_RESOURCE_ACCESS_READ_WRITE; case kCoreModule_ResourceAccessRasterizerOrdered: return SLANG_RESOURCE_ACCESS_RASTER_ORDERED; - case kCoreModule_ResourceAccessFeedback: return SLANG_RESOURCE_ACCESS_FEEDBACK; - case kCoreModule_ResourceAccessWriteOnly: return SLANG_RESOURCE_ACCESS_WRITE; - default: break; + case kCoreModule_ResourceAccessFeedback: + return SLANG_RESOURCE_ACCESS_FEEDBACK; + case kCoreModule_ResourceAccessWriteOnly: + return SLANG_RESOURCE_ACCESS_WRITE; + default: + break; } } return SLANG_RESOURCE_ACCESS_UNKNOWN; diff --git a/source/slang/slang-language-server-auto-format.cpp b/source/slang/slang-language-server-auto-format.cpp index f8f9a4659..b7f601bc2 100644 --- a/source/slang/slang-language-server-auto-format.cpp +++ b/source/slang/slang-language-server-auto-format.cpp @@ -123,7 +123,8 @@ List<TextRange> extractFormattingExclusionRanges(UnownedStringSlice text) case TokenType::WhiteSpace: case TokenType::LineComment: case TokenType::BlockComment: - case TokenType::NewLine: break; + case TokenType::NewLine: + break; default: if (braceCounter == 0) goto breakLabel; diff --git a/source/slang/slang-language-server-completion.cpp b/source/slang/slang-language-server-completion.cpp index 699e5e764..82b7286ea 100644 --- a/source/slang/slang-language-server-completion.cpp +++ b/source/slang/slang-language-server-completion.cpp @@ -244,11 +244,15 @@ CompletionResult CompletionContext::gatherFileAndModuleCompletionItems( { switch (ch) { - case '-': nameSB.appendChar('_'); break; + case '-': + nameSB.appendChar('_'); + break; case '.': // Ignore any file items that contains a "." return; - default: nameSB.appendChar(ch); break; + default: + nameSB.appendChar(ch); + break; } } else @@ -535,7 +539,8 @@ CompletionResult CompletionContext::collectMembersAndSymbols() useCommitChars = (commitCharacterBehavior == CommitCharacterBehavior::All); addKeywords = true; break; - default: return result; + default: + return result; } HashSet<String> deduplicateSet; for (Index i = 0; diff --git a/source/slang/slang-legalize-types.cpp b/source/slang/slang-legalize-types.cpp index 077d43409..9c79e3167 100644 --- a/source/slang/slang-legalize-types.cpp +++ b/source/slang/slang-legalize-types.cpp @@ -289,7 +289,9 @@ struct TupleTypeBuilder } break; - case LegalType::Flavor::none: anyComplex = true; break; + case LegalType::Flavor::none: + anyComplex = true; + break; case LegalType::Flavor::implicitDeref: { @@ -347,7 +349,9 @@ struct TupleTypeBuilder } break; - default: SLANG_UNEXPECTED("unknown legal type flavor"); break; + default: + SLANG_UNEXPECTED("unknown legal type flavor"); + break; } PairInfo::Element pairElement; @@ -533,9 +537,11 @@ static LegalType createLegalUniformBufferType( // switch (legalElementType.flavor) { - default: return context->createLegalUniformBufferType(op, legalElementType); + default: + return context->createLegalUniformBufferType(op, legalElementType); - case LegalType::Flavor::none: return LegalType(); + case LegalType::Flavor::none: + return LegalType(); case LegalType::Flavor::simple: { @@ -761,7 +767,8 @@ LegalElementWrapping declareStructFields( switch (fieldType.flavor) { - case LegalType::Flavor::none: return LegalElementWrapping::makeVoid(); + case LegalType::Flavor::none: + return LegalElementWrapping::makeVoid(); case LegalType::Flavor::simple: { @@ -1005,7 +1012,8 @@ static LegalType wrapLegalType( { switch (legalType.flavor) { - case LegalType::Flavor::none: return LegalType(); + case LegalType::Flavor::none: + return LegalType(); case LegalType::Flavor::simple: { @@ -1150,8 +1158,11 @@ LegalType legalizeTypeImpl(TypeLegalizationContext* context, IRType* type) return LegalType::simple(bufferType); newElementType = legalElementType.getSimple(); break; - case LegalType::Flavor::none: newElementType = context->getBuilder()->getIntType(); break; - default: return LegalType::simple(bufferType); + case LegalType::Flavor::none: + newElementType = context->getBuilder()->getIntType(); + break; + default: + return LegalType::simple(bufferType); } ShortList<IRInst*> operands; for (UInt i = 0; i < bufferType->getOperandCount(); i++) diff --git a/source/slang/slang-lower-to-ir.cpp b/source/slang/slang-lower-to-ir.cpp index dc4e8aec7..b98218c5a 100644 --- a/source/slang/slang-lower-to-ir.cpp +++ b/source/slang/slang-lower-to-ir.cpp @@ -756,7 +756,8 @@ LoweredValInfo emitCallToVal( auto builder = context->irBuilder; switch (funcVal.flavor) { - case LoweredValInfo::Flavor::None: SLANG_UNEXPECTED("null function"); + case LoweredValInfo::Flavor::None: + SLANG_UNEXPECTED("null function"); default: switch (tryEnv.clauseType) { @@ -806,7 +807,8 @@ LoweredValInfo emitCallToVal( return LoweredValInfo::simple(value); } break; - default: SLANG_UNIMPLEMENTED_X("emitCallToVal(tryClauseType)"); + default: + SLANG_UNIMPLEMENTED_X("emitCallToVal(tryClauseType)"); } } } @@ -1053,7 +1055,8 @@ top: { case LoweredValInfo::Flavor::None: case LoweredValInfo::Flavor::Simple: - case LoweredValInfo::Flavor::Ptr: return lowered; + case LoweredValInfo::Flavor::Ptr: + return lowered; case LoweredValInfo::Flavor::BoundStorage: { @@ -1188,7 +1191,9 @@ top: auto result = builder->emitCast(info->type, getSimpleVal(context, baseVal)); return LoweredValInfo::simple(result); } - default: SLANG_UNEXPECTED("unhandled value flavor"); UNREACHABLE_RETURN(LoweredValInfo()); + default: + SLANG_UNEXPECTED("unhandled value flavor"); + UNREACHABLE_RETURN(LoweredValInfo()); } } @@ -1202,13 +1207,18 @@ IRInst* getSimpleVal(IRGenContext* context, LoweredValInfo lowered) switch (lowered.flavor) { - case LoweredValInfo::Flavor::None: return nullptr; + case LoweredValInfo::Flavor::None: + return nullptr; - case LoweredValInfo::Flavor::Simple: return lowered.val; + case LoweredValInfo::Flavor::Simple: + return lowered.val; - case LoweredValInfo::Flavor::Ptr: return builder->emitLoad(lowered.val); + case LoweredValInfo::Flavor::Ptr: + return builder->emitLoad(lowered.val); - default: SLANG_UNEXPECTED("unhandled value flavor"); UNREACHABLE_RETURN(nullptr); + default: + SLANG_UNEXPECTED("unhandled value flavor"); + UNREACHABLE_RETURN(nullptr); } } @@ -2318,10 +2328,18 @@ void addVarDecorations(IRGenContext* context, IRInst* inst, Decl* decl) IROp op; switch (t->getOp()) { - case kIROp_VerticesType: op = kIROp_VerticesDecoration; break; - case kIROp_IndicesType: op = kIROp_IndicesDecoration; break; - case kIROp_PrimitivesType: op = kIROp_PrimitivesDecoration; break; - default: SLANG_UNREACHABLE("Missing case for IRMeshOutputType"); break; + case kIROp_VerticesType: + op = kIROp_VerticesDecoration; + break; + case kIROp_IndicesType: + op = kIROp_IndicesDecoration; + break; + case kIROp_PrimitivesType: + op = kIROp_PrimitivesDecoration; + break; + default: + SLANG_UNREACHABLE("Missing case for IRMeshOutputType"); + break; } builder->addMeshOutputDecoration(op, inst, t->getMaxElementCount()); } @@ -2516,7 +2534,9 @@ void addInArg(IRGenContext* context, List<IRInst*>* ioArgs, LoweredValInfo argVa args.add(getSimpleVal(context, argVal)); break; - default: SLANG_UNIMPLEMENTED_X("addInArg case"); break; + default: + SLANG_UNIMPLEMENTED_X("addInArg case"); + break; } } @@ -2649,7 +2669,9 @@ void addArg( } break; - default: addInArg(context, ioArgs, argVal); break; + default: + addInArg(context, ioArgs, argVal); + break; } } @@ -3203,15 +3225,21 @@ void _lowerFuncDeclBaseTypeInfo( // then we will represent it with a pointer type in // the IR, but we will use a specialized pointer // type that encodes the parameter direction information. - case kParameterDirection_Out: irParamType = builder->getOutType(irParamType); break; - case kParameterDirection_InOut: irParamType = builder->getInOutType(irParamType); break; + case kParameterDirection_Out: + irParamType = builder->getOutType(irParamType); + break; + case kParameterDirection_InOut: + irParamType = builder->getInOutType(irParamType); + break; case kParameterDirection_Ref: irParamType = builder->getRefType(irParamType, AddressSpace::Generic); break; case kParameterDirection_ConstRef: irParamType = builder->getConstRefType(irParamType); break; - default: SLANG_UNEXPECTED("unknown parameter direction"); break; + default: + SLANG_UNEXPECTED("unknown parameter direction"); + break; } // If the parameter was explicitly marked as being a compile-time @@ -3605,7 +3633,8 @@ struct ExprLoweringContext { switch (funcVal.flavor) { - default: return; + default: + return; } } @@ -4511,7 +4540,8 @@ struct ExprLoweringVisitorBase : public ExprVisitor<Derived, LoweredValInfo> UNREACHABLE_RETURN(LoweredValInfo()); break; - case BaseType::Bool: return LoweredValInfo::simple(getBuilder()->getBoolValue(false)); + case BaseType::Bool: + return LoweredValInfo::simple(getBuilder()->getBoolValue(false)); case BaseType::Int8: case BaseType::Int16: @@ -5204,7 +5234,9 @@ struct ExprLoweringVisitorBase : public ExprVisitor<Derived, LoweredValInfo> case LoweredValInfo::Flavor::Ptr: return LoweredValInfo::ptr(builder->emitElementAddress(baseVal.val, indexVal)); - default: SLANG_UNIMPLEMENTED_X("subscript expr"); UNREACHABLE_RETURN(LoweredValInfo()); + default: + SLANG_UNIMPLEMENTED_X("subscript expr"); + UNREACHABLE_RETURN(LoweredValInfo()); } } @@ -7051,7 +7083,8 @@ LoweredValInfo tryGetAddress( break; // TODO: are there other cases we need to handled here? - default: break; + default: + break; } // If none of the special cases above applied, then we werent' able to make @@ -7471,7 +7504,9 @@ top: } break; - default: SLANG_UNIMPLEMENTED_X("assignment"); break; + default: + SLANG_UNIMPLEMENTED_X("assignment"); + break; } } @@ -7770,7 +7805,9 @@ struct DeclLoweringVisitor : DeclVisitor<DeclLoweringVisitor, LoweredValInfo> } break; - default: SLANG_UNEXPECTED("handled requirement witness case"); break; + default: + SLANG_UNEXPECTED("handled requirement witness case"); + break; } @@ -8974,10 +9011,18 @@ struct DeclLoweringVisitor : DeclVisitor<DeclLoweringVisitor, LoweredValInfo> { switch (semantic->componentMask.getContent()[0]) { - case 'x': componentOffset = 0; break; - case 'y': componentOffset = 1; break; - case 'z': componentOffset = 2; break; - case 'w': componentOffset = 3; break; + case 'x': + componentOffset = 0; + break; + case 'y': + componentOffset = 1; + break; + case 'z': + componentOffset = 2; + break; + case 'w': + componentOffset = 3; + break; } } builder->addDecoration( @@ -10808,8 +10853,10 @@ LoweredValInfo emitDeclRef(IRGenContext* context, Decl* decl, DeclRefBase* subst irArgs.getBuffer()); switch (genericVal.flavor) { - case LoweredValInfo::Flavor::Simple: return LoweredValInfo::simple(irSpecializedVal); - case LoweredValInfo::Flavor::Ptr: return LoweredValInfo::ptr(irSpecializedVal); + case LoweredValInfo::Flavor::Simple: + return LoweredValInfo::simple(irSpecializedVal); + case LoweredValInfo::Flavor::Ptr: + return LoweredValInfo::ptr(irSpecializedVal); default: SLANG_UNEXPECTED("unhandled lowered value flavor"); UNREACHABLE_RETURN(LoweredValInfo()); diff --git a/source/slang/slang-mangle.cpp b/source/slang/slang-mangle.cpp index eb26540b4..4257f5dc2 100644 --- a/source/slang/slang-mangle.cpp +++ b/source/slang/slang-mangle.cpp @@ -141,26 +141,56 @@ void emitBaseType(ManglingContext* context, BaseType baseType) { switch (baseType) { - case BaseType::Void: emitRaw(context, "V"); break; - case BaseType::Bool: emitRaw(context, "b"); break; - case BaseType::Int8: emitRaw(context, "c"); break; - case BaseType::Int16: emitRaw(context, "s"); break; - case BaseType::Int: emitRaw(context, "i"); break; - case BaseType::Int64: emitRaw(context, "I"); break; - case BaseType::UInt8: emitRaw(context, "C"); break; - case BaseType::UInt16: emitRaw(context, "S"); break; - case BaseType::UInt: emitRaw(context, "u"); break; - case BaseType::UInt64: emitRaw(context, "U"); break; - case BaseType::Half: emitRaw(context, "h"); break; - case BaseType::Float: emitRaw(context, "f"); break; - case BaseType::Double: emitRaw(context, "d"); break; - case BaseType::UIntPtr: emitRaw(context, "up"); break; + case BaseType::Void: + emitRaw(context, "V"); + break; + case BaseType::Bool: + emitRaw(context, "b"); + break; + case BaseType::Int8: + emitRaw(context, "c"); + break; + case BaseType::Int16: + emitRaw(context, "s"); + break; + case BaseType::Int: + emitRaw(context, "i"); + break; + case BaseType::Int64: + emitRaw(context, "I"); + break; + case BaseType::UInt8: + emitRaw(context, "C"); + break; + case BaseType::UInt16: + emitRaw(context, "S"); + break; + case BaseType::UInt: + emitRaw(context, "u"); + break; + case BaseType::UInt64: + emitRaw(context, "U"); + break; + case BaseType::Half: + emitRaw(context, "h"); + break; + case BaseType::Float: + emitRaw(context, "f"); + break; + case BaseType::Double: + emitRaw(context, "d"); + break; + case BaseType::UIntPtr: + emitRaw(context, "up"); + break; case BaseType::IntPtr: emitRaw(context, "ip"); break; break; - default: SLANG_UNEXPECTED("unimplemented case in base type mangling"); break; + default: + SLANG_UNEXPECTED("unimplemented case in base type mangling"); + break; } } @@ -567,11 +597,21 @@ void emitQualifiedName(ManglingContext* context, DeclRef<Decl> declRef, bool inc ParameterDirection paramDirection = getParameterDirection(paramDeclRef.getDecl()); switch (paramDirection) { - case kParameterDirection_Ref: emitRaw(context, "r_"); break; - case kParameterDirection_ConstRef: emitRaw(context, "c_"); break; - case kParameterDirection_Out: emitRaw(context, "o_"); break; - case kParameterDirection_InOut: emitRaw(context, "io_"); break; - case kParameterDirection_In: emitRaw(context, "i_"); break; + case kParameterDirection_Ref: + emitRaw(context, "r_"); + break; + case kParameterDirection_ConstRef: + emitRaw(context, "c_"); + break; + case kParameterDirection_Out: + emitRaw(context, "o_"); + break; + case kParameterDirection_InOut: + emitRaw(context, "io_"); + break; + case kParameterDirection_In: + emitRaw(context, "i_"); + break; default: StringBuilder errMsg; errMsg << "Unknown parameter direction: " << paramDirection; diff --git a/source/slang/slang-mangled-lexer.cpp b/source/slang/slang-mangled-lexer.cpp index 8188db35e..577ce1a95 100644 --- a/source/slang/slang-mangled-lexer.cpp +++ b/source/slang/slang-mangled-lexer.cpp @@ -36,14 +36,18 @@ void MangledLexer::readGenericParam() switch (peekChar()) { case 'T': - case 'C': nextChar(); break; + case 'C': + nextChar(); + break; case 'v': nextChar(); readType(); break; - default: SLANG_UNEXPECTED("bad name mangling"); break; + default: + SLANG_UNEXPECTED("bad name mangling"); + break; } } @@ -69,7 +73,9 @@ void MangledLexer::readType() case 'U': case 'h': case 'f': - case 'd': nextChar(); break; + case 'd': + nextChar(); + break; case 'v': nextChar(); @@ -77,7 +83,9 @@ void MangledLexer::readType() readType(); break; - default: readNamedType(); break; + default: + readNamedType(); + break; } } @@ -95,7 +103,9 @@ void MangledLexer::readVal() readRawStringSegment(); break; - default: readType(); break; + default: + readType(); + break; } } @@ -237,7 +247,8 @@ UInt MangledLexer::readParamCount() lexer.nextChar(); break; } - default: break; + default: + break; } } diff --git a/source/slang/slang-options.cpp b/source/slang/slang-options.cpp index bc83afe65..a4e7fb83c 100644 --- a/source/slang/slang-options.cpp +++ b/source/slang/slang-options.cpp @@ -2143,7 +2143,9 @@ SlangResult OptionsParser::_parse(int argc, char const* const* argv) case OptionKind::NoHLSLPackConstantBufferElements: case OptionKind::LoopInversion: case OptionKind::UnscopedEnum: - case OptionKind::PreserveParameters: linkage->m_optionSet.set(optionKind, true); break; + case OptionKind::PreserveParameters: + linkage->m_optionSet.set(optionKind, true); + break; case OptionKind::MatrixLayoutRow: case OptionKind::MatrixLayoutColumn: linkage->m_optionSet.setMatrixLayoutMode( @@ -2172,7 +2174,9 @@ SlangResult OptionsParser::_parse(int argc, char const* const* argv) break; } - case OptionKind::CompileCoreModule: m_compileCoreModule = true; break; + case OptionKind::CompileCoreModule: + m_compileCoreModule = true; + break; case OptionKind::ArchiveType: { SLANG_RETURN_ON_FAIL(_expectValue(m_archiveType)); @@ -2268,7 +2272,9 @@ SlangResult OptionsParser::_parse(int argc, char const* const* argv) m_compileRequest->setDefaultModuleName(moduleName.value.getBuffer()); break; } - case OptionKind::LoadRepro: SLANG_RETURN_ON_FAIL(_parseLoadRepro(arg)); break; + case OptionKind::LoadRepro: + SLANG_RETURN_ON_FAIL(_parseLoadRepro(arg)); + break; case OptionKind::LoadReproDirectory: { CommandLineArg reproDirectory; @@ -2312,12 +2318,18 @@ SlangResult OptionsParser::_parse(int argc, char const* const* argv) } break; } - case OptionKind::ReproFileSystem: SLANG_RETURN_ON_FAIL(_parseReproFileSystem(arg)); break; - case OptionKind::SerialIr: m_frontEndReq->useSerialIRBottleneck = true; break; + case OptionKind::ReproFileSystem: + SLANG_RETURN_ON_FAIL(_parseReproFileSystem(arg)); + break; + case OptionKind::SerialIr: + m_frontEndReq->useSerialIRBottleneck = true; + break; case OptionKind::VerbosePaths: m_requestImpl->getSink()->setFlag(DiagnosticSink::Flag::VerbosePath); break; - case OptionKind::DumpWarningDiagnostics: _dumpDiagnostics(Severity::Warning); break; + case OptionKind::DumpWarningDiagnostics: + _dumpDiagnostics(Severity::Warning); + break; case OptionKind::WarningsAsErrors: { CommandLineArg operand; @@ -2358,7 +2370,9 @@ SlangResult OptionsParser::_parse(int argc, char const* const* argv) // Severity::Warning)); break; } - case OptionKind::VerifyDebugSerialIr: m_frontEndReq->verifyDebugSerialization = true; break; + case OptionKind::VerifyDebugSerialIr: + m_frontEndReq->verifyDebugSerialization = true; + break; case OptionKind::IrCompression: { CommandLineArg name; @@ -2443,7 +2457,9 @@ SlangResult OptionsParser::_parse(int argc, char const* const* argv) (int)bindingSet); break; } - case OptionKind::Profile: SLANG_RETURN_ON_FAIL(_parseProfile(arg)); break; + case OptionKind::Profile: + SLANG_RETURN_ON_FAIL(_parseProfile(arg)); + break; case OptionKind::Capability: { // The `-capability` option is similar to `-profile` but does not set the actual @@ -2692,7 +2708,9 @@ SlangResult OptionsParser::_parse(int argc, char const* const* argv) m_compileRequest->setOptimizationLevel(level); break; } - case OptionKind::DebugInformation: SLANG_RETURN_ON_FAIL(_parseDebugInformation(arg)); break; + case OptionKind::DebugInformation: + SLANG_RETURN_ON_FAIL(_parseDebugInformation(arg)); + break; case OptionKind::FileSystem: { typedef TypeTextUtil::FileSystemType FileSystemType; @@ -2701,7 +2719,9 @@ SlangResult OptionsParser::_parse(int argc, char const* const* argv) switch (value) { - case FileSystemType::Default: m_compileRequest->setFileSystem(nullptr); break; + case FileSystemType::Default: + m_compileRequest->setFileSystem(nullptr); + break; case FileSystemType::LoadFile: m_compileRequest->setFileSystem(OSFileSystem::getLoadSingleton()); break; @@ -2711,13 +2731,17 @@ SlangResult OptionsParser::_parse(int argc, char const* const* argv) } break; } - case OptionKind::ReferenceModule: SLANG_RETURN_ON_FAIL(_parseReferenceModule(arg)); break; + case OptionKind::ReferenceModule: + SLANG_RETURN_ON_FAIL(_parseReferenceModule(arg)); + break; case OptionKind::Version: { m_sink->diagnoseRaw(Severity::Note, m_session->getBuildTagString()); break; } - case OptionKind::HelpStyle: SLANG_RETURN_ON_FAIL(_expectValue(m_helpStyle)); break; + case OptionKind::HelpStyle: + SLANG_RETURN_ON_FAIL(_expectValue(m_helpStyle)); + break; case OptionKind::Help: { SLANG_RETURN_ON_FAIL(_parseHelp(arg)); @@ -3447,7 +3471,9 @@ SlangResult OptionsParser::_parse(int argc, char const* const* argv) case CodeGenTarget::DXIL: case CodeGenTarget::MetalLib: case CodeGenTarget::MetalLibAssembly: - case CodeGenTarget::Metal: rawOutput.isWholeProgram = true; break; + case CodeGenTarget::Metal: + rawOutput.isWholeProgram = true; + break; case CodeGenTarget::SPIRV: case CodeGenTarget::SPIRVAssembly: if (getCurrentTarget()->optionSet.shouldEmitSPIRVDirectly()) diff --git a/source/slang/slang-parameter-binding.cpp b/source/slang/slang-parameter-binding.cpp index 63dba4cdf..3621c6c00 100644 --- a/source/slang/slang-parameter-binding.cpp +++ b/source/slang/slang-parameter-binding.cpp @@ -510,12 +510,17 @@ LayoutResourceKind findRegisterClassFromName(UnownedStringSlice const& registerC case 1: switch (*registerClassName.begin()) { - case 'b': return LayoutResourceKind::ConstantBuffer; - case 't': return LayoutResourceKind::ShaderResource; - case 'u': return LayoutResourceKind::UnorderedAccess; - case 's': return LayoutResourceKind::SamplerState; + case 'b': + return LayoutResourceKind::ConstantBuffer; + case 't': + return LayoutResourceKind::ShaderResource; + case 'u': + return LayoutResourceKind::UnorderedAccess; + case 's': + return LayoutResourceKind::SamplerState; - default: break; + default: + break; } break; @@ -526,7 +531,8 @@ LayoutResourceKind findRegisterClassFromName(UnownedStringSlice const& registerC } break; - default: break; + default: + break; } return LayoutResourceKind::None; } @@ -3216,7 +3222,9 @@ static void collectSpecializationParams(ParameterBindingContext* context, Compon } break; - default: SLANG_UNEXPECTED("unhandled specialization parameter flavor"); break; + default: + SLANG_UNEXPECTED("unhandled specialization parameter flavor"); + break; } } } @@ -3418,7 +3426,8 @@ static bool _isPTXTarget(CodeGenTarget target) { return true; } - default: return false; + default: + return false; } } @@ -3776,7 +3785,8 @@ static bool _calcNeedsDefaultSpace(SharedParameterBindingContext& sharedContext) { case LayoutResourceKind::RegisterSpace: case LayoutResourceKind::SubElementRegisterSpace: - case LayoutResourceKind::PushConstantBuffer: continue; + case LayoutResourceKind::PushConstantBuffer: + continue; case LayoutResourceKind::Uniform: { // If it's uniform, but we have globals binding defined, we don't need a default @@ -3792,7 +3802,8 @@ static bool _calcNeedsDefaultSpace(SharedParameterBindingContext& sharedContext) break; } - default: break; + default: + break; } // Otherwise, we have a shader parameter that will need @@ -3812,14 +3823,16 @@ static bool _calcNeedsDefaultSpace(SharedParameterBindingContext& sharedContext) { switch (resInfo.kind) { - default: break; + default: + break; case LayoutResourceKind::RegisterSpace: case LayoutResourceKind::SubElementRegisterSpace: case LayoutResourceKind::VaryingInput: case LayoutResourceKind::VaryingOutput: case LayoutResourceKind::HitAttributes: - case LayoutResourceKind::RayPayload: continue; + case LayoutResourceKind::RayPayload: + continue; } return true; diff --git a/source/slang/slang-parser.cpp b/source/slang/slang-parser.cpp index d0ea9797e..61d6ca1dc 100644 --- a/source/slang/slang-parser.cpp +++ b/source/slang/slang-parser.cpp @@ -347,11 +347,18 @@ static TokenType SkipBalancedToken(TokenReader* reader) TokenType tokenType = reader->advanceToken().type; switch (tokenType) { - default: break; + default: + break; - case TokenType::LParent: tokenType = SkipToMatchingToken(reader, TokenType::RParent); break; - case TokenType::LBrace: tokenType = SkipToMatchingToken(reader, TokenType::RBrace); break; - case TokenType::LBracket: tokenType = SkipToMatchingToken(reader, TokenType::RBracket); break; + case TokenType::LParent: + tokenType = SkipToMatchingToken(reader, TokenType::RParent); + break; + case TokenType::LBrace: + tokenType = SkipToMatchingToken(reader, TokenType::RBrace); + break; + case TokenType::LBracket: + tokenType = SkipToMatchingToken(reader, TokenType::RBracket); + break; } return tokenType; } @@ -381,9 +388,11 @@ static bool IsClosingToken(TokenType tokenType) case TokenType::EndOfFile: case TokenType::RBracket: case TokenType::RParent: - case TokenType::RBrace: return true; + case TokenType::RBrace: + return true; - default: return false; + default: + return false; } } @@ -458,24 +467,42 @@ static bool TryRecover( { switch (recoverBefore[ii]) { - default: break; + default: + break; - case TokenType::EndOfFile: lookingForEOF = true; break; - case TokenType::RBrace: lookingForRCurly = true; break; - case TokenType::RParent: lookingForRParen = true; break; - case TokenType::RBracket: lookingForRSquare = true; break; + case TokenType::EndOfFile: + lookingForEOF = true; + break; + case TokenType::RBrace: + lookingForRCurly = true; + break; + case TokenType::RParent: + lookingForRParen = true; + break; + case TokenType::RBracket: + lookingForRSquare = true; + break; } } for (int ii = 0; ii < recoverAfterCount; ++ii) { switch (recoverAfter[ii]) { - default: break; + default: + break; - case TokenType::EndOfFile: lookingForEOF = true; break; - case TokenType::RBrace: lookingForRCurly = true; break; - case TokenType::RParent: lookingForRParen = true; break; - case TokenType::RBracket: lookingForRSquare = true; break; + case TokenType::EndOfFile: + lookingForEOF = true; + break; + case TokenType::RBrace: + lookingForRCurly = true; + break; + case TokenType::RParent: + lookingForRParen = true; + break; + case TokenType::RBracket: + lookingForRSquare = true; + break; } } @@ -587,8 +614,10 @@ Token Parser::readTokenImpl(TokenType expected, bool forceSkippingToClosingToken { case TokenType::RBrace: case TokenType::RParent: - case TokenType::RBracket: break; - default: return tokenReader.peekToken(); + case TokenType::RBracket: + break; + default: + return tokenReader.peekToken(); } } @@ -1193,7 +1222,9 @@ static Modifiers ParseModifiers(Parser* parser) // HLSL uses `[attributeName]` style for its modifiers, which closely // matches the C++ `[[attributeName]]` style. - case TokenType::LBracket: ParseSquareBracketAttributes(parser, &modifierLink); break; + case TokenType::LBracket: + ParseSquareBracketAttributes(parser, &modifierLink); + break; } } } @@ -1351,8 +1382,11 @@ static NameLoc ParseDeclName(Parser* parser) // Note(tfoley): A bit of a hack: case TokenType::Comma: - case TokenType::OpAssign: break; - case TokenType::LParent: parser->ReadToken(TokenType::RParent); break; + case TokenType::OpAssign: + break; + case TokenType::LParent: + parser->ReadToken(TokenType::RParent); + break; // Note(tfoley): Even more of a hack! case TokenType::QuestionMark: @@ -1488,8 +1522,11 @@ static Decl* ParseGenericParamDecl(Parser* parser, GenericDecl* genericDecl) case TokenType::Colon: case TokenType::Comma: case TokenType::OpGreater: - case TokenType::OpAssign: break; - default: isTypeParam = false; break; + case TokenType::OpAssign: + break; + default: + isTypeParam = false; + break; } } @@ -1966,7 +2003,8 @@ static RefPtr<Declarator> parseDirectAbstractDeclarator( continue; } - case TokenType::LParent: break; + case TokenType::LParent: + break; case TokenType::OpLess: { @@ -2012,7 +2050,8 @@ static RefPtr<Declarator> parseDirectAbstractDeclarator( } } break; - default: break; + default: + break; } break; @@ -2116,7 +2155,9 @@ static void UnwrapDeclarator( } break; - default: SLANG_UNREACHABLE("all cases handled"); break; + default: + SLANG_UNREACHABLE("all cases handled"); + break; } } } @@ -2690,7 +2731,9 @@ static TypeSpec _parseSimpleTypeSpec(Parser* parser) { switch (peekTokenType(parser)) { - case TokenType::OpLess: typeExpr = parseGenericApp(parser, typeExpr); break; + case TokenType::OpLess: + typeExpr = parseGenericApp(parser, typeExpr); + break; case TokenType::Scope: { auto opToken = parser->ReadToken(TokenType::Scope); @@ -2703,7 +2746,8 @@ static TypeSpec _parseSimpleTypeSpec(Parser* parser) typeExpr = parseMemberType(parser, typeExpr, opToken.loc); break; } - default: shouldLoop = false; + default: + shouldLoop = false; } } @@ -3891,14 +3935,16 @@ static bool _peekModernStyleVarDecl(Parser* parser) switch (peekTokenType(parser, 1)) { - default: return false; + default: + return false; case TokenType::Colon: case TokenType::Comma: case TokenType::RParent: case TokenType::RBrace: case TokenType::RBracket: - case TokenType::LBrace: return true; + case TokenType::LBrace: + return true; } } @@ -4263,8 +4309,10 @@ static bool shouldDeclBeCheckedForNestingValidity(ASTNodeType declType) case ASTNodeType::IncludeDecl: case ASTNodeType::ImplementingDecl: case ASTNodeType::ModuleDeclarationDecl: - case ASTNodeType::AssocTypeDecl: return true; - default: return false; + case ASTNodeType::AssocTypeDecl: + return true; + default: + return false; } } @@ -4292,8 +4340,10 @@ static bool isDeclAllowed(bool languageServer, ASTNodeType parentType, ASTNodeTy case ASTNodeType::ClassDecl: case ASTNodeType::EnumDecl: case ASTNodeType::GenericDecl: - case ASTNodeType::ConstructorDecl: return true; - default: return false; + case ASTNodeType::ConstructorDecl: + return true; + default: + return false; } case ASTNodeType::StructDecl: case ASTNodeType::ClassDecl: @@ -4312,8 +4362,10 @@ static bool isDeclAllowed(bool languageServer, ASTNodeType parentType, ASTNodeTy case ASTNodeType::EnumDecl: case ASTNodeType::EnumCaseDecl: case ASTNodeType::GenericDecl: - case ASTNodeType::ConstructorDecl: return true; - default: return false; + case ASTNodeType::ConstructorDecl: + return true; + default: + return false; } case ASTNodeType::InterfaceDecl: switch (declType) @@ -4325,15 +4377,19 @@ static bool isDeclAllowed(bool languageServer, ASTNodeType parentType, ASTNodeTy case ASTNodeType::VarDecl: case ASTNodeType::LetDecl: case ASTNodeType::GenericDecl: - case ASTNodeType::ConstructorDecl: return true; - default: return false; + case ASTNodeType::ConstructorDecl: + return true; + default: + return false; } case ASTNodeType::GLSLInterfaceBlockDecl: switch (declType) { case ASTNodeType::VarDecl: - case ASTNodeType::LetDecl: return true; - default: return false; + case ASTNodeType::LetDecl: + return true; + default: + return false; } case ASTNodeType::ConstructorDecl: case ASTNodeType::AccessorDecl: @@ -4350,8 +4406,10 @@ static bool isDeclAllowed(bool languageServer, ASTNodeType parentType, ASTNodeTy case ASTNodeType::StructDecl: case ASTNodeType::ClassDecl: case ASTNodeType::EnumDecl: - case ASTNodeType::GenericDecl: return true; - default: return false; + case ASTNodeType::GenericDecl: + return true; + default: + return false; } case ASTNodeType::SubscriptDecl: case ASTNodeType::PropertyDecl: @@ -4360,8 +4418,10 @@ static bool isDeclAllowed(bool languageServer, ASTNodeType parentType, ASTNodeTy case ASTNodeType::AccessorDecl: case ASTNodeType::GetterDecl: case ASTNodeType::SetterDecl: - case ASTNodeType::RefAccessorDecl: return true; - default: return false; + case ASTNodeType::RefAccessorDecl: + return true; + default: + return false; } case ASTNodeType::ModuleDecl: case ASTNodeType::FileDecl: @@ -4392,8 +4452,10 @@ static bool isDeclAllowed(bool languageServer, ASTNodeType parentType, ASTNodeTy case ASTNodeType::EnumDecl: case ASTNodeType::InterfaceDecl: case ASTNodeType::GLSLInterfaceBlockDecl: - case ASTNodeType::ExtensionDecl: return true; - default: return false; + case ASTNodeType::ExtensionDecl: + return true; + default: + return false; } case ASTNodeType::GenericDecl: switch (declType) @@ -4407,8 +4469,10 @@ static bool isDeclAllowed(bool languageServer, ASTNodeType parentType, ASTNodeTy case ASTNodeType::TypeAliasDecl: case ASTNodeType::TypeDefDecl: case ASTNodeType::ExtensionDecl: - case ASTNodeType::SubscriptDecl: return true; - default: return false; + case ASTNodeType::SubscriptDecl: + return true; + default: + return false; } case ASTNodeType::VarDecl: case ASTNodeType::LetDecl: @@ -4419,8 +4483,10 @@ static bool isDeclAllowed(bool languageServer, ASTNodeType parentType, ASTNodeTy case ASTNodeType::IncludeDecl: case ASTNodeType::ImplementingDecl: case ASTNodeType::ModuleDeclarationDecl: - case ASTNodeType::AssocTypeDecl: return true; - default: return true; + case ASTNodeType::AssocTypeDecl: + return true; + default: + return true; } } @@ -4738,7 +4804,9 @@ static DeclBase* ParseDeclWithModifiers( } break; // If nothing else matched, we try to parse an "ordinary" declarator-based declaration - default: decl = ParseDeclaratorDecl(parser, containerDecl, modifiers); break; + default: + decl = ParseDeclaratorDecl(parser, containerDecl, modifiers); + break; } if (decl) @@ -6072,8 +6140,10 @@ Precedence GetOpLevel(Parser* parser, const Token& token) { switch (token.type) { - case TokenType::QuestionMark: return Precedence::TernaryConditional; - case TokenType::Comma: return Precedence::Comma; + case TokenType::QuestionMark: + return Precedence::TernaryConditional; + case TokenType::Comma: + return Precedence::Comma; case TokenType::OpAssign: case TokenType::OpMulAssign: case TokenType::OpDivAssign: @@ -6084,14 +6154,21 @@ Precedence GetOpLevel(Parser* parser, const Token& token) case TokenType::OpShrAssign: case TokenType::OpOrAssign: case TokenType::OpAndAssign: - case TokenType::OpXorAssign: return Precedence::Assignment; - case TokenType::OpOr: return Precedence::LogicalOr; - case TokenType::OpAnd: return Precedence::LogicalAnd; - case TokenType::OpBitOr: return Precedence::BitOr; - case TokenType::OpBitXor: return Precedence::BitXor; - case TokenType::OpBitAnd: return Precedence::BitAnd; + case TokenType::OpXorAssign: + return Precedence::Assignment; + case TokenType::OpOr: + return Precedence::LogicalOr; + case TokenType::OpAnd: + return Precedence::LogicalAnd; + case TokenType::OpBitOr: + return Precedence::BitOr; + case TokenType::OpBitXor: + return Precedence::BitXor; + case TokenType::OpBitAnd: + return Precedence::BitAnd; case TokenType::OpEql: - case TokenType::OpNeq: return Precedence::EqualityComparison; + case TokenType::OpNeq: + return Precedence::EqualityComparison; case TokenType::OpGreater: case TokenType::OpGeq: // Don't allow these ops inside a generic argument @@ -6099,18 +6176,22 @@ Precedence GetOpLevel(Parser* parser, const Token& token) return Precedence::Invalid; ; // fall-thru case TokenType::OpLeq: - case TokenType::OpLess: return Precedence::RelationalComparison; + case TokenType::OpLess: + return Precedence::RelationalComparison; case TokenType::OpRsh: // Don't allow this op inside a generic argument if (parser->genericDepth > 0) return Precedence::Invalid; ; // fall-thru - case TokenType::OpLsh: return Precedence::BitShift; + case TokenType::OpLsh: + return Precedence::BitShift; case TokenType::OpAdd: - case TokenType::OpSub: return Precedence::Additive; + case TokenType::OpSub: + return Precedence::Additive; case TokenType::OpMul: case TokenType::OpDiv: - case TokenType::OpMod: return Precedence::Multiplicative; + case TokenType::OpMod: + return Precedence::Multiplicative; default: { const auto content = token.getContent(); @@ -6133,7 +6214,9 @@ static Expr* parseOperator(Parser* parser) opToken.setContent(UnownedStringSlice::fromLiteral("?:")); break; - default: opToken = parser->ReadToken(); break; + default: + opToken = parser->ReadToken(); + break; } auto opExpr = parser->astBuilder->create<VarExpr>(); @@ -6485,7 +6568,8 @@ static FloatFixKind _fixFloatLiteralValue( } break; } - default: break; + default: + break; } } @@ -6688,7 +6772,8 @@ static bool _isCast(Parser* parser, Expr* expr) } break; } - default: break; + default: + break; } // We'll assume it's not a cast @@ -6863,15 +6948,23 @@ static Expr* parseAtomicExpr(Parser* parser) switch (*suffixCursor++) { case 'l': - case 'L': lCount++; break; + case 'L': + lCount++; + break; case 'u': - case 'U': uCount++; break; + case 'U': + uCount++; + break; case 'z': - case 'Z': zCount++; break; + case 'Z': + zCount++; + break; - default: unknownCount++; break; + default: + unknownCount++; + break; } } @@ -6955,15 +7048,23 @@ static Expr* parseAtomicExpr(Parser* parser) switch (*suffixCursor++) { case 'f': - case 'F': fCount++; break; + case 'F': + fCount++; + break; case 'l': - case 'L': lCount++; break; + case 'L': + lCount++; + break; case 'h': - case 'H': hCount++; break; + case 'H': + hCount++; + break; - default: unknownCount++; break; + default: + unknownCount++; + break; } } @@ -7156,7 +7257,8 @@ static Expr* parsePostfixExpr(Parser* parser) auto nextTokenType = peekTokenType(parser); switch (nextTokenType) { - default: return expr; + default: + return expr; // Postfix increment/decrement case TokenType::OpInc: @@ -7276,9 +7378,12 @@ static IRIntegerValue _foldIntegerPrefixOp(TokenType tokenType, IRIntegerValue v { switch (tokenType) { - case TokenType::OpBitNot: return ~value; - case TokenType::OpAdd: return value; - case TokenType::OpSub: return -value; + case TokenType::OpBitNot: + return ~value; + case TokenType::OpAdd: + return value; + case TokenType::OpSub: + return -value; default: { SLANG_ASSERT(!"Unexpected op"); @@ -7291,8 +7396,10 @@ static IRFloatingPointValue _foldFloatPrefixOp(TokenType tokenType, IRFloatingPo { switch (tokenType) { - case TokenType::OpAdd: return value; - case TokenType::OpSub: return -value; + case TokenType::OpAdd: + return value; + case TokenType::OpSub: + return -value; default: { SLANG_ASSERT(!"Unexpected op"); diff --git a/source/slang/slang-preprocessor.cpp b/source/slang/slang-preprocessor.cpp index 22ab9e49c..d3606235c 100644 --- a/source/slang/slang-preprocessor.cpp +++ b/source/slang/slang-preprocessor.cpp @@ -433,7 +433,9 @@ struct InputStreamStack case TokenType::NewLine: case TokenType::WhiteSpace: case TokenType::BlockComment: - case TokenType::LineComment: readToken(); break; + case TokenType::LineComment: + readToken(); + break; } } } @@ -516,11 +518,13 @@ private: Token token = m_lexer.lexToken(); switch (token.type) { - default: return token; + default: + return token; case TokenType::WhiteSpace: case TokenType::BlockComment: - case TokenType::LineComment: break; + case TokenType::LineComment: + break; } } } @@ -1230,7 +1234,8 @@ MacroInvocation::Arg ExpansionInputStream::_parseMacroArg(MacroInvocation* macro nestingDepth++; break; - default: break; + default: + break; } // Add the token and continue parsing. @@ -1273,7 +1278,8 @@ void ExpansionInputStream::_parseMacroArgs(MacroDefinition* macro, MacroInvocati switch (m_inputStreams.peekTokenType()) { case TokenType::RParent: - case TokenType::EndOfFile: return; + case TokenType::EndOfFile: + return; } } @@ -2058,7 +2064,9 @@ void MacroInvocation::_initCurrentOpStream() // switch (op.opcode) { - default: SLANG_UNEXPECTED("unhandled macro opcode case"); break; + default: + SLANG_UNEXPECTED("unhandled macro opcode case"); + break; case MacroDefinition::Opcode::RawSpan: { @@ -2326,9 +2334,11 @@ static bool IsEndOfLine(PreprocessorDirectiveContext* context) switch (inputStream->peekRawTokenType()) { case TokenType::EndOfFile: - case TokenType::NewLine: return true; + case TokenType::NewLine: + return true; - default: return false; + default: + return false; } } @@ -2541,9 +2551,12 @@ static PreprocessorExpressionValue ParseAndEvaluateUnaryExpression( switch (token.type) { // handle prefix unary ops - case TokenType::OpSub: return -ParseAndEvaluateUnaryExpression(context); - case TokenType::OpNot: return !ParseAndEvaluateUnaryExpression(context); - case TokenType::OpBitNot: return ~ParseAndEvaluateUnaryExpression(context); + case TokenType::OpSub: + return -ParseAndEvaluateUnaryExpression(context); + case TokenType::OpNot: + return !ParseAndEvaluateUnaryExpression(context); + case TokenType::OpBitNot: + return ~ParseAndEvaluateUnaryExpression(context); // handle parenthized sub-expression case TokenType::LParent: @@ -2560,7 +2573,8 @@ static PreprocessorExpressionValue ParseAndEvaluateUnaryExpression( return value; } - case TokenType::IntegerLiteral: return stringToInt(token.getContent()); + case TokenType::IntegerLiteral: + return stringToInt(token.getContent()); case TokenType::Identifier: { @@ -2683,29 +2697,47 @@ static int GetInfixOpPrecedence(Token const& opToken) // cause us to stop parsing an expression return -1; - case TokenType::OpMul: return 10; - case TokenType::OpDiv: return 10; - case TokenType::OpMod: return 10; - - case TokenType::OpAdd: return 9; - case TokenType::OpSub: return 9; - - case TokenType::OpLsh: return 8; - case TokenType::OpRsh: return 8; - - case TokenType::OpLess: return 7; - case TokenType::OpGreater: return 7; - case TokenType::OpLeq: return 7; - case TokenType::OpGeq: return 7; - - case TokenType::OpEql: return 6; - case TokenType::OpNeq: return 6; - - case TokenType::OpBitAnd: return 5; - case TokenType::OpBitOr: return 4; - case TokenType::OpBitXor: return 3; - case TokenType::OpAnd: return 2; - case TokenType::OpOr: return 1; + case TokenType::OpMul: + return 10; + case TokenType::OpDiv: + return 10; + case TokenType::OpMod: + return 10; + + case TokenType::OpAdd: + return 9; + case TokenType::OpSub: + return 9; + + case TokenType::OpLsh: + return 8; + case TokenType::OpRsh: + return 8; + + case TokenType::OpLess: + return 7; + case TokenType::OpGreater: + return 7; + case TokenType::OpLeq: + return 7; + case TokenType::OpGeq: + return 7; + + case TokenType::OpEql: + return 6; + case TokenType::OpNeq: + return 6; + + case TokenType::OpBitAnd: + return 5; + case TokenType::OpBitOr: + return 4; + case TokenType::OpBitXor: + return 3; + case TokenType::OpAnd: + return 2; + case TokenType::OpOr: + return 1; } }; @@ -2724,7 +2756,8 @@ static PreprocessorExpressionValue EvaluateInfixOp( return 0; break; - case TokenType::OpMul: return left * right; + case TokenType::OpMul: + return left * right; case TokenType::OpDiv: { if (right == 0) @@ -2753,21 +2786,36 @@ static PreprocessorExpressionValue EvaluateInfixOp( } return left % right; } - case TokenType::OpAdd: return left + right; - case TokenType::OpSub: return left - right; - case TokenType::OpLsh: return left << right; - case TokenType::OpRsh: return left >> right; - case TokenType::OpLess: return left < right ? 1 : 0; - case TokenType::OpGreater: return left > right ? 1 : 0; - case TokenType::OpLeq: return left <= right ? 1 : 0; - case TokenType::OpGeq: return left >= right ? 1 : 0; - case TokenType::OpEql: return left == right ? 1 : 0; - case TokenType::OpNeq: return left != right ? 1 : 0; - case TokenType::OpBitAnd: return left & right; - case TokenType::OpBitOr: return left | right; - case TokenType::OpBitXor: return left ^ right; - case TokenType::OpAnd: return left && right; - case TokenType::OpOr: return left || right; + case TokenType::OpAdd: + return left + right; + case TokenType::OpSub: + return left - right; + case TokenType::OpLsh: + return left << right; + case TokenType::OpRsh: + return left >> right; + case TokenType::OpLess: + return left < right ? 1 : 0; + case TokenType::OpGreater: + return left > right ? 1 : 0; + case TokenType::OpLeq: + return left <= right ? 1 : 0; + case TokenType::OpGeq: + return left >= right ? 1 : 0; + case TokenType::OpEql: + return left == right ? 1 : 0; + case TokenType::OpNeq: + return left != right ? 1 : 0; + case TokenType::OpBitAnd: + return left & right; + case TokenType::OpBitOr: + return left | right; + case TokenType::OpBitXor: + return left ^ right; + case TokenType::OpAnd: + return left && right; + case TokenType::OpOr: + return left || right; } } @@ -2935,11 +2983,16 @@ static void HandleElseDirective(PreprocessorDirectiveContext* context) switch (conditional->state) { - case Conditional::State::Before: conditional->state = Conditional::State::During; break; + case Conditional::State::Before: + conditional->state = Conditional::State::During; + break; - case Conditional::State::During: conditional->state = Conditional::State::After; break; + case Conditional::State::During: + conditional->state = Conditional::State::After; + break; - default: break; + default: + break; } updateLexerFlagsForConditionals(inputFile); @@ -3302,7 +3355,8 @@ static void _parseMacroOps( break; - case TokenType::EndOfFile: break; + case TokenType::EndOfFile: + break; } if (spanBeginIndex != spanEndIndex || @@ -3657,7 +3711,9 @@ static void HandleLineDirective(PreprocessorDirectiveContext* context) switch (PeekTokenType(context)) { - case TokenType::IntegerLiteral: line = stringToInt(AdvanceToken(context).getContent()); break; + case TokenType::IntegerLiteral: + line = stringToInt(AdvanceToken(context).getContent()); + break; case TokenType::EndOfFile: case TokenType::NewLine: @@ -3673,7 +3729,9 @@ static void HandleLineDirective(PreprocessorDirectiveContext* context) return; } [[fallthrough]]; - default: _diagnoseInvalidLineDirective(context); return; + default: + _diagnoseInvalidLineDirective(context); + return; } auto sourceManager = context->m_preprocessor->getSourceManager(); @@ -3682,9 +3740,13 @@ static void HandleLineDirective(PreprocessorDirectiveContext* context) switch (PeekTokenType(context)) { case TokenType::EndOfFile: - case TokenType::NewLine: file = sourceManager->getPathInfo(directiveLoc).foundPath; break; + case TokenType::NewLine: + file = sourceManager->getPathInfo(directiveLoc).foundPath; + break; - case TokenType::StringLiteral: file = getStringLiteralTokenValue(AdvanceToken(context)); break; + case TokenType::StringLiteral: + file = getStringLiteralTokenValue(AdvanceToken(context)); + break; case TokenType::IntegerLiteral: // Note(tfoley): GLSL allows the "source string" to be indicated by an integer @@ -3927,9 +3989,11 @@ static void HandleDirective(PreprocessorDirectiveContext* context) switch (directiveTokenType) { case TokenType::EndOfFile: - case TokenType::NewLine: return; + case TokenType::NewLine: + return; - default: break; + default: + break; } // Otherwise the directive name had better be an identifier @@ -4132,7 +4196,9 @@ static TokenList ReadAllTokens(Preprocessor* preprocessor) switch (token.type) { - default: tokens.add(token); break; + default: + tokens.add(token); + break; case TokenType::EndOfFile: // Note: we include the EOF token in the list, @@ -4144,7 +4210,8 @@ static TokenList ReadAllTokens(Preprocessor* preprocessor) case TokenType::NewLine: case TokenType::LineComment: case TokenType::BlockComment: - case TokenType::Invalid: break; + case TokenType::Invalid: + break; } } } diff --git a/source/slang/slang-profile.cpp b/source/slang/slang-profile.cpp index 2b013415d..7e12b4f4e 100644 --- a/source/slang/slang-profile.cpp +++ b/source/slang/slang-profile.cpp @@ -8,10 +8,12 @@ ProfileFamily getProfileFamily(ProfileVersion version) { switch (version) { - default: return ProfileFamily::Unknown; + default: + return ProfileFamily::Unknown; #define PROFILE_VERSION(TAG, FAMILY) \ - case ProfileVersion::TAG: return ProfileFamily::FAMILY; + case ProfileVersion::TAG: \ + return ProfileFamily::FAMILY; #include "slang-profile-defs.h" } } @@ -25,8 +27,10 @@ bool isRaytracingStage(Stage inStage) case Stage::Intersection: case Stage::ClosestHit: case Stage::Callable: - case Stage::AnyHit: return true; - default: return false; + case Stage::AnyHit: + return true; + default: + return false; } } @@ -35,11 +39,13 @@ const char* getStageName(Stage stage) switch (stage) { #define PROFILE_STAGE(ID, NAME, ENUM) \ - case Stage::ID: return #NAME; + case Stage::ID: \ + return #NAME; #include "slang-profile-defs.h" - default: return nullptr; + default: + return nullptr; } } diff --git a/source/slang/slang-reflection-api.cpp b/source/slang/slang-reflection-api.cpp index bb4dfbbc2..93e495194 100644 --- a/source/slang/slang-reflection-api.cpp +++ b/source/slang/slang-reflection-api.cpp @@ -217,7 +217,8 @@ static SlangParameterCategory maybeRemapParameterCategory( // TODO: implement more helpers here - default: break; + default: + break; } } @@ -658,8 +659,9 @@ SLANG_API SlangScalarType spReflectionType_GetScalarType(SlangReflectionType* in { switch (basicType->getBaseType()) { -#define CASE(BASE, TAG) \ - case BaseType::BASE: return SLANG_SCALAR_TYPE_##TAG +#define CASE(BASE, TAG) \ + case BaseType::BASE: \ + return SLANG_SCALAR_TYPE_##TAG CASE(Void, VOID); CASE(Bool, BOOL); @@ -1308,7 +1310,8 @@ SLANG_API size_t spReflectionTypeLayout_GetElementStride( switch (category) { // We store the stride explicitly for the uniform case - case SLANG_PARAMETER_CATEGORY_UNIFORM: return arrayTypeLayout->uniformStride; + case SLANG_PARAMETER_CATEGORY_UNIFORM: + return arrayTypeLayout->uniformStride; // For most other cases (resource registers), the "stride" // of an array is simply the number of resources (if any) @@ -1325,7 +1328,8 @@ SLANG_API size_t spReflectionTypeLayout_GetElementStride( // An important special case, though, is Vulkan descriptor-table slots, // where an entire array will use a single `binding`, so that the // effective stride is zero: - case SLANG_PARAMETER_CATEGORY_DESCRIPTOR_TABLE_SLOT: return 0; + case SLANG_PARAMETER_CATEGORY_DESCRIPTOR_TABLE_SLOT: + return 0; } } else if (auto vectorTypeLayout = as<VectorTypeLayout>(typeLayout)) @@ -1667,7 +1671,8 @@ SlangBindingType _calcResourceBindingType(Type* type) switch (SlangResourceShape(shape)) { - default: return SlangBindingType(SLANG_BINDING_TYPE_TEXTURE | mutableFlag); + default: + return SlangBindingType(SLANG_BINDING_TYPE_TEXTURE | mutableFlag); case SLANG_TEXTURE_BUFFER: return SlangBindingType(SLANG_BINDING_TYPE_TYPED_BUFFER | mutableFlag); @@ -1754,8 +1759,9 @@ SlangBindingType _calcBindingType(LayoutResourceKind kind) // directly to a `BindingType` because there is only // one case of types that have that resource kind. -#define CASE(FROM, TO) \ - case LayoutResourceKind::FROM: return SLANG_BINDING_TYPE_##TO +#define CASE(FROM, TO) \ + case LayoutResourceKind::FROM: \ + return SLANG_BINDING_TYPE_##TO CASE(ConstantBuffer, CONSTANT_BUFFER); CASE(SamplerState, SAMPLER); @@ -1779,9 +1785,11 @@ SlangBindingType _calcBindingType(Slang::TypeLayout* typeLayout, LayoutResourceK // switch (kind) { - default: break; + default: + break; - case LayoutResourceKind::PushConstantBuffer: return SLANG_BINDING_TYPE_PUSH_CONSTANT; + case LayoutResourceKind::PushConstantBuffer: + return SLANG_BINDING_TYPE_PUSH_CONSTANT; } // If the type or type layout implies a specific binding type @@ -1959,7 +1967,8 @@ struct ExtendedTypeLayoutContext kind = resInfo.kind; switch (kind) { - default: continue; + default: + continue; case LayoutResourceKind::ConstantBuffer: case LayoutResourceKind::PushConstantBuffer: @@ -1972,7 +1981,8 @@ struct ExtendedTypeLayoutContext // Note: the only case where a parameter group should // reflect as consuming `Uniform` storage is on CPU/CUDA, // where that will be the only resource it contains. - case LayoutResourceKind::Uniform: break; + case LayoutResourceKind::Uniform: + break; } bindingType = _calcBindingType(typeLayout, kind); @@ -2067,7 +2077,8 @@ struct ExtendedTypeLayoutContext // leak through that is measured in descriptor sets. // case LayoutResourceKind::SubElementRegisterSpace: - case LayoutResourceKind::None: break; + case LayoutResourceKind::None: + break; default: { @@ -2080,9 +2091,11 @@ struct ExtendedTypeLayoutContext { switch (resInfo.kind) { - case LayoutResourceKind::SubElementRegisterSpace: continue; + case LayoutResourceKind::SubElementRegisterSpace: + continue; - default: break; + default: + break; } TypeLayout::ExtendedInfo::DescriptorRangeInfo descriptorRange; @@ -2110,7 +2123,8 @@ struct ExtendedTypeLayoutContext // case LayoutResourceKind::SubElementRegisterSpace: case LayoutResourceKind::Uniform: - case LayoutResourceKind::None: break; + case LayoutResourceKind::None: + break; default: { @@ -2207,7 +2221,9 @@ struct ExtendedTypeLayoutContext case LayoutResourceKind::DescriptorTableSlot: case LayoutResourceKind::Uniform: case LayoutResourceKind::ConstantBuffer: // for metal - case LayoutResourceKind::MetalArgumentBufferElement: resInfo = info; break; + case LayoutResourceKind::MetalArgumentBufferElement: + resInfo = info; + break; } } SLANG_ASSERT(resInfo.kind != LayoutResourceKind::None); @@ -2384,7 +2400,8 @@ struct ExtendedTypeLayoutContext case LayoutResourceKind::HitAttributes: case LayoutResourceKind::RayPayload: case LayoutResourceKind::ExistentialTypeParam: - case LayoutResourceKind::ExistentialObjectParam: continue; + case LayoutResourceKind::ExistentialObjectParam: + continue; } // We will prefer to use a binding type derived from the specific @@ -3056,20 +3073,41 @@ SLANG_API SlangReflectionModifier* spReflectionVariable_FindModifier( Modifier* modifier = nullptr; switch (modifierID) { - case SLANG_MODIFIER_SHARED: modifier = var->findModifier<HLSLEffectSharedModifier>(); break; - case SLANG_MODIFIER_CONST: modifier = var->findModifier<ConstModifier>(); break; - case SLANG_MODIFIER_NO_DIFF: modifier = var->findModifier<NoDiffModifier>(); break; - case SLANG_MODIFIER_STATIC: modifier = var->findModifier<HLSLStaticModifier>(); break; - case SLANG_MODIFIER_EXPORT: modifier = var->findModifier<HLSLExportModifier>(); break; - case SLANG_MODIFIER_EXTERN: modifier = var->findModifier<ExternModifier>(); break; + case SLANG_MODIFIER_SHARED: + modifier = var->findModifier<HLSLEffectSharedModifier>(); + break; + case SLANG_MODIFIER_CONST: + modifier = var->findModifier<ConstModifier>(); + break; + case SLANG_MODIFIER_NO_DIFF: + modifier = var->findModifier<NoDiffModifier>(); + break; + case SLANG_MODIFIER_STATIC: + modifier = var->findModifier<HLSLStaticModifier>(); + break; + case SLANG_MODIFIER_EXPORT: + modifier = var->findModifier<HLSLExportModifier>(); + break; + case SLANG_MODIFIER_EXTERN: + modifier = var->findModifier<ExternModifier>(); + break; case SLANG_MODIFIER_DIFFERENTIABLE: modifier = var->findModifier<DifferentiableAttribute>(); break; - case SLANG_MODIFIER_MUTATING: modifier = var->findModifier<MutatingAttribute>(); break; - case SLANG_MODIFIER_IN: modifier = var->findModifier<InModifier>(); break; - case SLANG_MODIFIER_OUT: modifier = var->findModifier<OutModifier>(); break; - case SLANG_MODIFIER_INOUT: modifier = var->findModifier<InOutModifier>(); break; - default: return nullptr; + case SLANG_MODIFIER_MUTATING: + modifier = var->findModifier<MutatingAttribute>(); + break; + case SLANG_MODIFIER_IN: + modifier = var->findModifier<InModifier>(); + break; + case SLANG_MODIFIER_OUT: + modifier = var->findModifier<OutModifier>(); + break; + case SLANG_MODIFIER_INOUT: + modifier = var->findModifier<InOutModifier>(); + break; + default: + return nullptr; } return (SlangReflectionModifier*)modifier; diff --git a/source/slang/slang-repro.cpp b/source/slang/slang-repro.cpp index 4948fd498..9859ead52 100644 --- a/source/slang/slang-repro.cpp +++ b/source/slang/slang-repro.cpp @@ -335,7 +335,8 @@ static bool _isStorable(const PathInfo::Type type) { return true; } - default: return false; + default: + return false; } } @@ -346,8 +347,11 @@ static String _scrubName(const String& in) { switch (c) { - case ':': c = '_'; break; - default: break; + case ':': + c = '_'; + break; + default: + break; } builder.appendChar(c); } @@ -1347,9 +1351,14 @@ static SlangResult _calcCommandLine( switch (isolatedBit) { - case SLANG_COMPILE_FLAG_NO_MANGLING: cmd.addArg("-no-mangle"); break; - case SLANG_COMPILE_FLAG_NO_CODEGEN: cmd.addArg("-no-codegen"); break; - default: break; + case SLANG_COMPILE_FLAG_NO_MANGLING: + cmd.addArg("-no-mangle"); + break; + case SLANG_COMPILE_FLAG_NO_CODEGEN: + cmd.addArg("-no-codegen"); + break; + default: + break; } // Remove the bit @@ -1359,32 +1368,52 @@ static SlangResult _calcCommandLine( switch (SlangLineDirectiveMode(requestState->lineDirectiveMode)) { - case SLANG_LINE_DIRECTIVE_MODE_DEFAULT: break; + case SLANG_LINE_DIRECTIVE_MODE_DEFAULT: + break; case SLANG_LINE_DIRECTIVE_MODE_NONE: { cmd.addArg("-line-directive-mode"); cmd.addArg("none"); break; } - default: break; + default: + break; } switch (SlangDebugInfoLevel(requestState->debugInfoLevel)) { - case SLANG_DEBUG_INFO_LEVEL_STANDARD: cmd.addArg("-g"); break; - case SLANG_DEBUG_INFO_LEVEL_NONE: cmd.addArg("-g0"); break; - case SLANG_DEBUG_INFO_LEVEL_MINIMAL: cmd.addArg("-g1"); break; - case SLANG_DEBUG_INFO_LEVEL_MAXIMAL: cmd.addArg("-g3"); break; - default: break; + case SLANG_DEBUG_INFO_LEVEL_STANDARD: + cmd.addArg("-g"); + break; + case SLANG_DEBUG_INFO_LEVEL_NONE: + cmd.addArg("-g0"); + break; + case SLANG_DEBUG_INFO_LEVEL_MINIMAL: + cmd.addArg("-g1"); + break; + case SLANG_DEBUG_INFO_LEVEL_MAXIMAL: + cmd.addArg("-g3"); + break; + default: + break; } switch (SlangOptimizationLevel(requestState->optimizationLevel)) { - case SLANG_OPTIMIZATION_LEVEL_NONE: cmd.addArg("-O0"); break; - case SLANG_OPTIMIZATION_LEVEL_DEFAULT: cmd.addArg("-O"); break; - case SLANG_OPTIMIZATION_LEVEL_HIGH: cmd.addArg("-O2"); break; - case SLANG_OPTIMIZATION_LEVEL_MAXIMAL: cmd.addArg("-O3"); break; - default: break; + case SLANG_OPTIMIZATION_LEVEL_NONE: + cmd.addArg("-O0"); + break; + case SLANG_OPTIMIZATION_LEVEL_DEFAULT: + cmd.addArg("-O"); + break; + case SLANG_OPTIMIZATION_LEVEL_HIGH: + cmd.addArg("-O2"); + break; + case SLANG_OPTIMIZATION_LEVEL_MAXIMAL: + cmd.addArg("-O3"); + break; + default: + break; } // spSetOutputContainerFormat(externalRequest, @@ -1392,7 +1421,8 @@ static SlangResult _calcCommandLine( switch (SlangPassThrough(requestState->passThroughMode)) { - case SLANG_PASS_THROUGH_NONE: break; + case SLANG_PASS_THROUGH_NONE: + break; default: { cmd.addArg("-pass-through"); @@ -1409,9 +1439,14 @@ static SlangResult _calcCommandLine( switch (requestState->defaultMatrixLayoutMode) { - case SLANG_MATRIX_LAYOUT_ROW_MAJOR: cmd.addArg("-matrix-layout-row-major"); break; - case SLANG_MATRIX_LAYOUT_COLUMN_MAJOR: cmd.addArg("-matrix-layout-column-major"); break; - default: break; + case SLANG_MATRIX_LAYOUT_ROW_MAJOR: + cmd.addArg("-matrix-layout-row-major"); + break; + case SLANG_MATRIX_LAYOUT_COLUMN_MAJOR: + cmd.addArg("-matrix-layout-column-major"); + break; + default: + break; } } @@ -1449,7 +1484,8 @@ static SlangResult _calcCommandLine( cmd.addArg("precise"); break; } - default: break; + default: + break; } #if 0 @@ -1632,9 +1668,15 @@ static SlangResult _calcCommandLine( { switch (pathInfo->pathType) { - case SLANG_PATH_TYPE_FILE: builder << "file "; break; - case SLANG_PATH_TYPE_DIRECTORY: builder << "directory "; break; - default: builder << "?"; break; + case SLANG_PATH_TYPE_FILE: + builder << "file "; + break; + case SLANG_PATH_TYPE_DIRECTORY: + builder << "directory "; + break; + default: + builder << "?"; + break; } } @@ -1655,12 +1697,20 @@ static SlangResult _calcCommandLine( switch (curRes) { default: - case CompressedResult::Uninitialized: break; - case CompressedResult::Ok: break; + case CompressedResult::Uninitialized: + break; + case CompressedResult::Ok: + break; - case CompressedResult::NotFound: builder << "[not found]"; break; - case CompressedResult::CannotOpen: builder << "[cannot open]"; break; - case CompressedResult::Fail: builder << "[fail]"; break; + case CompressedResult::NotFound: + builder << "[not found]"; + break; + case CompressedResult::CannotOpen: + builder << "[cannot open]"; + break; + case CompressedResult::Fail: + builder << "[fail]"; + break; } } } diff --git a/source/slang/slang-serialize-factory.cpp b/source/slang/slang-serialize-factory.cpp index ef922c5c2..5ad1e4911 100644 --- a/source/slang/slang-serialize-factory.cpp +++ b/source/slang/slang-serialize-factory.cpp @@ -36,7 +36,8 @@ void* DefaultSerialObjectFactory::create(SerialTypeKind typeKind, SerialSubType } return nullptr; } - default: break; + default: + break; } return nullptr; diff --git a/source/slang/slang-serialize-ir-types.h b/source/slang/slang-serialize-ir-types.h index 5d2fda0c5..55a249f5b 100644 --- a/source/slang/slang-serialize-ir-types.h +++ b/source/slang/slang-serialize-ir-types.h @@ -243,7 +243,8 @@ SLANG_FORCE_INLINE bool IRSerialData::Inst::operator==(const ThisType& rhs) cons { return m_payload.m_int64 == rhs.m_payload.m_int64; } - default: break; + default: + break; } } diff --git a/source/slang/slang-serialize-ir.cpp b/source/slang/slang-serialize-ir.cpp index 0864dfc4e..c6926735a 100644 --- a/source/slang/slang-serialize-ir.cpp +++ b/source/slang/slang-serialize-ir.cpp @@ -470,7 +470,8 @@ Result _writeInstArrayChunk( return SLANG_OK; } - default: break; + default: + break; } return SLANG_FAIL; } diff --git a/source/slang/slang-serialize-types.cpp b/source/slang/slang-serialize-types.cpp index dbe81c11f..ea6cd9c34 100644 --- a/source/slang/slang-serialize-types.cpp +++ b/source/slang/slang-serialize-types.cpp @@ -287,11 +287,13 @@ struct ByteReader /* static */ UnownedStringSlice SerialParseUtil::getText(SerialCompressionType type) { #define SLANG_SERIAL_BINARY_CASE(type, name) \ - case SerialCompressionType::type: return UnownedStringSlice::fromLiteral(#name); + case SerialCompressionType::type: \ + return UnownedStringSlice::fromLiteral(#name); switch (type) { SLANG_SERIAL_BINARY_COMPRESSION_TYPE(SLANG_SERIAL_BINARY_CASE) - default: break; + default: + break; } SLANG_ASSERT(!"Unknown compression type"); return UnownedStringSlice::fromLiteral("unknown"); diff --git a/source/slang/slang-serialize.cpp b/source/slang/slang-serialize.cpp index 4f856e457..2a1a92302 100644 --- a/source/slang/slang-serialize.cpp +++ b/source/slang/slang-serialize.cpp @@ -361,7 +361,9 @@ SerialIndex SerialWriter::writeValObject(const Val* node) auto operand = node->m_operands[i]; switch (operand.kind) { - case ValNodeOperandKind::ConstantValue: serializedOperands.add((SerialIndex)0); break; + case ValNodeOperandKind::ConstantValue: + serializedOperands.add((SerialIndex)0); + break; case ValNodeOperandKind::ValNode: case ValNodeOperandKind::ASTNode: serializedOperands.add(addPointer(operand.values.nodeOperand)); @@ -774,7 +776,8 @@ size_t SerialInfo::Entry::calcSize(SerialClasses* serialClasses) const return size; } - default: break; + default: + break; } SLANG_ASSERT(!"Unknown type"); @@ -810,7 +813,8 @@ const void* SerialReader::getArray(SerialIndex index, Index& outCount) outCount = Index(arrayEntry->elementCount); return (arrayEntry + 1); } - default: break; + default: + break; } SLANG_ASSERT(!"Not an array"); @@ -849,7 +853,8 @@ SerialPointer SerialReader::getPointer(SerialIndex index) } break; } - default: break; + default: + break; } return ptr; @@ -1162,7 +1167,8 @@ SlangResult SerialReader::deserializeObjects() break; } - default: break; + default: + break; } } diff --git a/source/slang/slang-syntax.cpp b/source/slang/slang-syntax.cpp index 77f7c5fca..589a170fa 100644 --- a/source/slang/slang-syntax.cpp +++ b/source/slang/slang-syntax.cpp @@ -37,30 +37,78 @@ void printDiagnosticArg(StringBuilder& sb, ASTNodeType nodeType) switch (nodeType) { - case ASTNodeType::Decl: sb << "Decl"; break; - case ASTNodeType::UnresolvedDecl: sb << "UnresolvedDecl"; break; - case ASTNodeType::ContainerDecl: sb << "ContainerDecl"; break; - case ASTNodeType::AggTypeDeclBase: sb << "AggTypeDeclBase"; break; - case ASTNodeType::ExtensionDecl: sb << "extension"; break; - case ASTNodeType::AggTypeDecl: sb << "AggTypeDecl"; break; - case ASTNodeType::StructDecl: sb << "struct"; break; - case ASTNodeType::ClassDecl: sb << "class"; break; - case ASTNodeType::GLSLInterfaceBlockDecl: sb << "GLSL interface block"; break; - case ASTNodeType::EnumDecl: sb << "enum"; break; - case ASTNodeType::ThisTypeDecl: sb << "This"; break; - case ASTNodeType::InterfaceDecl: sb << "interface"; break; - case ASTNodeType::AssocTypeDecl: sb << "associatedtype"; break; - case ASTNodeType::GlobalGenericParamDecl: sb << "global generic param"; break; - case ASTNodeType::ScopeDecl: sb << "scope"; break; - case ASTNodeType::CallableDecl: sb << "CallableDecl"; break; - case ASTNodeType::FunctionDeclBase: sb << "FunctionDeclBase"; break; - case ASTNodeType::ConstructorDecl: sb << "__init"; break; - case ASTNodeType::AccessorDecl: sb << "accessor"; break; - case ASTNodeType::GetterDecl: sb << "getter"; break; - case ASTNodeType::SetterDecl: sb << "setter"; break; - case ASTNodeType::RefAccessorDecl: sb << "ref accessor"; break; - case ASTNodeType::FuncDecl: sb << "function"; break; - case ASTNodeType::DerivativeRequirementDecl: sb << "DerivativeRequirementDecl"; break; + case ASTNodeType::Decl: + sb << "Decl"; + break; + case ASTNodeType::UnresolvedDecl: + sb << "UnresolvedDecl"; + break; + case ASTNodeType::ContainerDecl: + sb << "ContainerDecl"; + break; + case ASTNodeType::AggTypeDeclBase: + sb << "AggTypeDeclBase"; + break; + case ASTNodeType::ExtensionDecl: + sb << "extension"; + break; + case ASTNodeType::AggTypeDecl: + sb << "AggTypeDecl"; + break; + case ASTNodeType::StructDecl: + sb << "struct"; + break; + case ASTNodeType::ClassDecl: + sb << "class"; + break; + case ASTNodeType::GLSLInterfaceBlockDecl: + sb << "GLSL interface block"; + break; + case ASTNodeType::EnumDecl: + sb << "enum"; + break; + case ASTNodeType::ThisTypeDecl: + sb << "This"; + break; + case ASTNodeType::InterfaceDecl: + sb << "interface"; + break; + case ASTNodeType::AssocTypeDecl: + sb << "associatedtype"; + break; + case ASTNodeType::GlobalGenericParamDecl: + sb << "global generic param"; + break; + case ASTNodeType::ScopeDecl: + sb << "scope"; + break; + case ASTNodeType::CallableDecl: + sb << "CallableDecl"; + break; + case ASTNodeType::FunctionDeclBase: + sb << "FunctionDeclBase"; + break; + case ASTNodeType::ConstructorDecl: + sb << "__init"; + break; + case ASTNodeType::AccessorDecl: + sb << "accessor"; + break; + case ASTNodeType::GetterDecl: + sb << "getter"; + break; + case ASTNodeType::SetterDecl: + sb << "setter"; + break; + case ASTNodeType::RefAccessorDecl: + sb << "ref accessor"; + break; + case ASTNodeType::FuncDecl: + sb << "function"; + break; + case ASTNodeType::DerivativeRequirementDecl: + sb << "DerivativeRequirementDecl"; + break; case ASTNodeType::ForwardDerivativeRequirementDecl: sb << "ForwardDerivativeRequirementDecl"; break; @@ -70,42 +118,114 @@ void printDiagnosticArg(StringBuilder& sb, ASTNodeType nodeType) case ASTNodeType::DerivativeRequirementReferenceDecl: sb << "DerivativeRequirementReferenceDecl"; break; - case ASTNodeType::SubscriptDecl: sb << "__subscript"; break; - case ASTNodeType::PropertyDecl: sb << "property"; break; - case ASTNodeType::NamespaceDeclBase: sb << "NamespaceDeclBase"; break; - case ASTNodeType::NamespaceDecl: sb << "namespace"; break; - case ASTNodeType::ModuleDecl: sb << "module"; break; - case ASTNodeType::FileDecl: sb << "included file"; break; - case ASTNodeType::GenericDecl: sb << "generic"; break; - case ASTNodeType::AttributeDecl: sb << "attribute"; break; - case ASTNodeType::VarDeclBase: sb << "variable definition"; break; - case ASTNodeType::VarDecl: sb << "variable definition"; break; - case ASTNodeType::LetDecl: sb << "immutable value definition"; break; - case ASTNodeType::GlobalGenericValueParamDecl: sb << "GlobalGenericValueParamDecl"; break; - case ASTNodeType::ParamDecl: sb << "parameter"; break; - case ASTNodeType::ModernParamDecl: sb << "parameter"; break; - case ASTNodeType::GenericValueParamDecl: sb << "GenericValueParamDecl"; break; - case ASTNodeType::EnumCaseDecl: sb << "enum case"; break; - case ASTNodeType::TypeConstraintDecl: sb << "TypeConstraintDecl"; break; - case ASTNodeType::ThisTypeConstraintDecl: sb << "ThisTypeConstraintDecl"; break; - case ASTNodeType::InheritanceDecl: sb << "InheritanceDecl"; break; - case ASTNodeType::GenericTypeConstraintDecl: sb << "GenericTypeConstraintDecl"; break; - case ASTNodeType::SimpleTypeDecl: sb << "SimpleTypeDecl"; break; - case ASTNodeType::TypeDefDecl: sb << "typedef"; break; - case ASTNodeType::TypeAliasDecl: sb << "typealias"; break; - case ASTNodeType::GenericTypeParamDecl: sb << "GenericTypeParamDecl"; break; - case ASTNodeType::UsingDecl: sb << "using"; break; - case ASTNodeType::FileReferenceDeclBase: sb << "FileReferenceDeclBase"; break; - case ASTNodeType::ImportDecl: sb << "import"; break; - case ASTNodeType::IncludeDeclBase: sb << "IncludeDeclBase"; break; - case ASTNodeType::IncludeDecl: sb << "__include"; break; - case ASTNodeType::ImplementingDecl: sb << "implementing"; break; - case ASTNodeType::ModuleDeclarationDecl: sb << "module"; break; - case ASTNodeType::EmptyDecl: sb << "empty"; break; - case ASTNodeType::SyntaxDecl: sb << "syntax"; break; - case ASTNodeType::DeclGroup: sb << "decl-group"; break; - case ASTNodeType::RequireCapabilityDecl: sb << "__require_capability"; break; - default: sb << "decl"; break; + case ASTNodeType::SubscriptDecl: + sb << "__subscript"; + break; + case ASTNodeType::PropertyDecl: + sb << "property"; + break; + case ASTNodeType::NamespaceDeclBase: + sb << "NamespaceDeclBase"; + break; + case ASTNodeType::NamespaceDecl: + sb << "namespace"; + break; + case ASTNodeType::ModuleDecl: + sb << "module"; + break; + case ASTNodeType::FileDecl: + sb << "included file"; + break; + case ASTNodeType::GenericDecl: + sb << "generic"; + break; + case ASTNodeType::AttributeDecl: + sb << "attribute"; + break; + case ASTNodeType::VarDeclBase: + sb << "variable definition"; + break; + case ASTNodeType::VarDecl: + sb << "variable definition"; + break; + case ASTNodeType::LetDecl: + sb << "immutable value definition"; + break; + case ASTNodeType::GlobalGenericValueParamDecl: + sb << "GlobalGenericValueParamDecl"; + break; + case ASTNodeType::ParamDecl: + sb << "parameter"; + break; + case ASTNodeType::ModernParamDecl: + sb << "parameter"; + break; + case ASTNodeType::GenericValueParamDecl: + sb << "GenericValueParamDecl"; + break; + case ASTNodeType::EnumCaseDecl: + sb << "enum case"; + break; + case ASTNodeType::TypeConstraintDecl: + sb << "TypeConstraintDecl"; + break; + case ASTNodeType::ThisTypeConstraintDecl: + sb << "ThisTypeConstraintDecl"; + break; + case ASTNodeType::InheritanceDecl: + sb << "InheritanceDecl"; + break; + case ASTNodeType::GenericTypeConstraintDecl: + sb << "GenericTypeConstraintDecl"; + break; + case ASTNodeType::SimpleTypeDecl: + sb << "SimpleTypeDecl"; + break; + case ASTNodeType::TypeDefDecl: + sb << "typedef"; + break; + case ASTNodeType::TypeAliasDecl: + sb << "typealias"; + break; + case ASTNodeType::GenericTypeParamDecl: + sb << "GenericTypeParamDecl"; + break; + case ASTNodeType::UsingDecl: + sb << "using"; + break; + case ASTNodeType::FileReferenceDeclBase: + sb << "FileReferenceDeclBase"; + break; + case ASTNodeType::ImportDecl: + sb << "import"; + break; + case ASTNodeType::IncludeDeclBase: + sb << "IncludeDeclBase"; + break; + case ASTNodeType::IncludeDecl: + sb << "__include"; + break; + case ASTNodeType::ImplementingDecl: + sb << "implementing"; + break; + case ASTNodeType::ModuleDeclarationDecl: + sb << "module"; + break; + case ASTNodeType::EmptyDecl: + sb << "empty"; + break; + case ASTNodeType::SyntaxDecl: + sb << "syntax"; + break; + case ASTNodeType::DeclGroup: + sb << "decl-group"; + break; + case ASTNodeType::RequireCapabilityDecl: + sb << "__require_capability"; + break; + default: + sb << "decl"; + break; } } @@ -380,8 +500,10 @@ RequirementWitness RequirementWitness::specialize( { switch (getFlavor()) { - default: SLANG_UNEXPECTED("unknown requirement witness flavor"); - case RequirementWitness::Flavor::none: return RequirementWitness(); + default: + SLANG_UNEXPECTED("unknown requirement witness flavor"); + case RequirementWitness::Flavor::none: + return RequirementWitness(); case RequirementWitness::Flavor::witnessTable: return RequirementWitness(this->getWitnessTable()->specialize(astBuilder, subst)); @@ -1005,11 +1127,16 @@ char const* getTryClauseTypeName(TryClauseType c) { switch (c) { - case TryClauseType::None: return "None"; - case TryClauseType::Standard: return "Standard"; - case TryClauseType::Optional: return "Optional"; - case TryClauseType::Assert: return "Assert"; - default: return "Unknown"; + case TryClauseType::None: + return "None"; + case TryClauseType::Standard: + return "Standard"; + case TryClauseType::Optional: + return "Optional"; + case TryClauseType::Assert: + return "Assert"; + default: + return "Unknown"; } } diff --git a/source/slang/slang-type-layout.cpp b/source/slang/slang-type-layout.cpp index 2b8117afa..a63d6401e 100644 --- a/source/slang/slang-type-layout.cpp +++ b/source/slang/slang-type-layout.cpp @@ -68,7 +68,8 @@ struct DefaultLayoutRulesImpl : SimpleLayoutRulesImpl { switch (baseType) { - case BaseType::Void: return SimpleLayoutInfo(); + case BaseType::Void: + return SimpleLayoutInfo(); // Note: By convention, a `bool` in a constant buffer is stored as an `int. // This default may eventually change, at which point this logic will need @@ -77,32 +78,44 @@ struct DefaultLayoutRulesImpl : SimpleLayoutRulesImpl // TODO: We should probably warn in this case, since storing a `bool` in // a constant buffer seems like a Bad Idea anyway. // - case BaseType::Bool: return SimpleLayoutInfo(LayoutResourceKind::Uniform, 4, 4); + case BaseType::Bool: + return SimpleLayoutInfo(LayoutResourceKind::Uniform, 4, 4); - case BaseType::Int8: return SimpleLayoutInfo(LayoutResourceKind::Uniform, 1, 1); - case BaseType::Int16: return SimpleLayoutInfo(LayoutResourceKind::Uniform, 2, 2); - case BaseType::Int: return SimpleLayoutInfo(LayoutResourceKind::Uniform, 4, 4); - case BaseType::Int64: return SimpleLayoutInfo(LayoutResourceKind::Uniform, 8, 8); + case BaseType::Int8: + return SimpleLayoutInfo(LayoutResourceKind::Uniform, 1, 1); + case BaseType::Int16: + return SimpleLayoutInfo(LayoutResourceKind::Uniform, 2, 2); + case BaseType::Int: + return SimpleLayoutInfo(LayoutResourceKind::Uniform, 4, 4); + case BaseType::Int64: + return SimpleLayoutInfo(LayoutResourceKind::Uniform, 8, 8); case BaseType::IntPtr: return SimpleLayoutInfo( LayoutResourceKind::Uniform, sizeof(intptr_t), sizeof(intptr_t)); - case BaseType::UInt8: return SimpleLayoutInfo(LayoutResourceKind::Uniform, 1, 1); - case BaseType::UInt16: return SimpleLayoutInfo(LayoutResourceKind::Uniform, 2, 2); - case BaseType::UInt: return SimpleLayoutInfo(LayoutResourceKind::Uniform, 4, 4); - case BaseType::UInt64: return SimpleLayoutInfo(LayoutResourceKind::Uniform, 8, 8); + case BaseType::UInt8: + return SimpleLayoutInfo(LayoutResourceKind::Uniform, 1, 1); + case BaseType::UInt16: + return SimpleLayoutInfo(LayoutResourceKind::Uniform, 2, 2); + case BaseType::UInt: + return SimpleLayoutInfo(LayoutResourceKind::Uniform, 4, 4); + case BaseType::UInt64: + return SimpleLayoutInfo(LayoutResourceKind::Uniform, 8, 8); case BaseType::UIntPtr: return SimpleLayoutInfo( LayoutResourceKind::Uniform, sizeof(intptr_t), sizeof(intptr_t)); - case BaseType::Half: return SimpleLayoutInfo(LayoutResourceKind::Uniform, 2, 2); - case BaseType::Float: return SimpleLayoutInfo(LayoutResourceKind::Uniform, 4, 4); - case BaseType::Double: return SimpleLayoutInfo(LayoutResourceKind::Uniform, 8, 8); + case BaseType::Half: + return SimpleLayoutInfo(LayoutResourceKind::Uniform, 2, 2); + case BaseType::Float: + return SimpleLayoutInfo(LayoutResourceKind::Uniform, 4, 4); + case BaseType::Double: + return SimpleLayoutInfo(LayoutResourceKind::Uniform, 8, 8); default: SLANG_UNEXPECTED("uhandled scalar type"); @@ -437,7 +450,8 @@ struct CPULayoutRulesImpl : DefaultLayoutRulesImpl } // This always returns a layout where the size is the same as the alignment. - default: return Super::GetScalarLayout(baseType); + default: + return Super::GetScalarLayout(baseType); } } @@ -527,7 +541,8 @@ struct CUDALayoutRulesImpl : DefaultLayoutRulesImpl SLANG_ALIGN_OF(uint8_t)); } - default: return Super::GetScalarLayout(baseType); + default: + return Super::GetScalarLayout(baseType); } } @@ -761,15 +776,18 @@ static LayoutResourceKind _getHLSLLayoutResourceKind(ShaderParameterKind kind) { switch (kind) { - case ShaderParameterKind::SubpassInput: return LayoutResourceKind::InputAttachmentIndex; + case ShaderParameterKind::SubpassInput: + return LayoutResourceKind::InputAttachmentIndex; - case ShaderParameterKind::ConstantBuffer: return LayoutResourceKind::ConstantBuffer; + case ShaderParameterKind::ConstantBuffer: + return LayoutResourceKind::ConstantBuffer; case ShaderParameterKind::TextureUniformBuffer: case ShaderParameterKind::StructuredBuffer: case ShaderParameterKind::RawBuffer: case ShaderParameterKind::Buffer: - case ShaderParameterKind::Texture: return LayoutResourceKind::ShaderResource; + case ShaderParameterKind::Texture: + return LayoutResourceKind::ShaderResource; case ShaderParameterKind::MutableStructuredBuffer: case ShaderParameterKind::MutableRawBuffer: @@ -778,8 +796,10 @@ static LayoutResourceKind _getHLSLLayoutResourceKind(ShaderParameterKind kind) case ShaderParameterKind::AppendConsumeStructuredBuffer: return LayoutResourceKind::UnorderedAccess; - case ShaderParameterKind::SamplerState: return LayoutResourceKind::SamplerState; - default: return LayoutResourceKind::None; + case ShaderParameterKind::SamplerState: + return LayoutResourceKind::SamplerState; + default: + return LayoutResourceKind::None; } } @@ -821,7 +841,8 @@ struct GLSLObjectLayoutRulesImpl : ObjectLayoutRulesImpl { case ShaderParameterKind::SubpassInput: return SimpleLayoutInfo(LayoutResourceKind::InputAttachmentIndex, slotCount); - default: break; + default: + break; } return SimpleLayoutInfo(LayoutResourceKind::DescriptorTableSlot, slotCount); } @@ -2075,15 +2096,18 @@ LayoutRulesFamilyImpl* getDefaultLayoutRulesFamilyForTarget(TargetRequest* targe case CodeGenTarget::DXBytecode: case CodeGenTarget::DXBytecodeAssembly: case CodeGenTarget::DXIL: - case CodeGenTarget::DXILAssembly: return &kHLSLLayoutRulesFamilyImpl; + case CodeGenTarget::DXILAssembly: + return &kHLSLLayoutRulesFamilyImpl; case CodeGenTarget::GLSL: case CodeGenTarget::SPIRV: - case CodeGenTarget::SPIRVAssembly: return &kGLSLLayoutRulesFamilyImpl; + case CodeGenTarget::SPIRVAssembly: + return &kGLSLLayoutRulesFamilyImpl; case CodeGenTarget::WGSL: case CodeGenTarget::WGSLSPIRV: - case CodeGenTarget::WGSLSPIRVAssembly: return &kWGSLLayoutRulesFamilyImpl; + case CodeGenTarget::WGSLSPIRVAssembly: + return &kWGSLLayoutRulesFamilyImpl; case CodeGenTarget::HostHostCallable: case CodeGenTarget::ShaderHostCallable: @@ -2105,7 +2129,8 @@ LayoutRulesFamilyImpl* getDefaultLayoutRulesFamilyForTarget(TargetRequest* targe } case CodeGenTarget::Metal: case CodeGenTarget::MetalLib: - case CodeGenTarget::MetalLibAssembly: return &kMetalLayoutRulesFamilyImpl; + case CodeGenTarget::MetalLibAssembly: + return &kMetalLayoutRulesFamilyImpl; case CodeGenTarget::PTX: case CodeGenTarget::CUDASource: @@ -2114,7 +2139,8 @@ LayoutRulesFamilyImpl* getDefaultLayoutRulesFamilyForTarget(TargetRequest* targe } - default: return nullptr; + default: + return nullptr; } } @@ -2129,7 +2155,9 @@ TypeLayoutContext getInitialLayoutContextForTarget( switch (rules) { case slang::LayoutRules::Default: - default: rulesFamily = getDefaultLayoutRulesFamilyForTarget(targetReq); break; + default: + rulesFamily = getDefaultLayoutRulesFamilyForTarget(targetReq); + break; case slang::LayoutRules::MetalArgumentBufferTier2: rulesFamily = &kCPULayoutRulesFamilyImpl; break; @@ -2194,9 +2222,11 @@ bool IsResourceKind(LayoutResourceKind kind) switch (kind) { case LayoutResourceKind::None: - case LayoutResourceKind::Uniform: return false; + case LayoutResourceKind::Uniform: + return false; - default: return true; + default: + return true; } } @@ -2312,9 +2342,11 @@ bool isD3DTarget(TargetRequest* targetReq) case CodeGenTarget::DXBytecode: case CodeGenTarget::DXBytecodeAssembly: case CodeGenTarget::DXIL: - case CodeGenTarget::DXILAssembly: return true; + case CodeGenTarget::DXILAssembly: + return true; - default: return false; + default: + return false; } } @@ -2322,11 +2354,13 @@ bool isMetalTarget(TargetRequest* targetReq) { switch (targetReq->getTarget()) { - default: return false; + default: + return false; case CodeGenTarget::Metal: case CodeGenTarget::MetalLib: - case CodeGenTarget::MetalLibAssembly: return true; + case CodeGenTarget::MetalLibAssembly: + return true; } } @@ -2334,11 +2368,13 @@ bool isKhronosTarget(TargetRequest* targetReq) { switch (targetReq->getTarget()) { - default: return false; + default: + return false; case CodeGenTarget::GLSL: case CodeGenTarget::SPIRV: - case CodeGenTarget::SPIRVAssembly: return true; + case CodeGenTarget::SPIRVAssembly: + return true; } } @@ -2352,10 +2388,12 @@ bool isCUDATarget(TargetRequest* targetReq) { switch (targetReq->getTarget()) { - default: return false; + default: + return false; case CodeGenTarget::CUDASource: - case CodeGenTarget::PTX: return true; + case CodeGenTarget::PTX: + return true; } } @@ -2418,7 +2456,8 @@ SourceLanguage getIntermediateSourceLanguageForTarget(TargetProgram* targetProgr { return SourceLanguage::CUDA; } - default: break; + default: + break; } return SourceLanguage::Unknown; @@ -3642,9 +3681,11 @@ bool doesResourceRequireAdjustmentForArrayOfStructs(LayoutResourceKind kind) case LayoutResourceKind::ConstantBuffer: case LayoutResourceKind::ShaderResource: case LayoutResourceKind::UnorderedAccess: - case LayoutResourceKind::SamplerState: return true; + case LayoutResourceKind::SamplerState: + return true; - default: return false; + default: + return false; } } @@ -4423,18 +4464,26 @@ static TypeLayoutResult _createTypeLayout(TypeLayoutContext& context, Type* type { switch (textureType->getAccess()) { - default: kind = ShaderParameterKind::MutableTextureSampler; break; + default: + kind = ShaderParameterKind::MutableTextureSampler; + break; - case SLANG_RESOURCE_ACCESS_READ: kind = ShaderParameterKind::TextureSampler; break; + case SLANG_RESOURCE_ACCESS_READ: + kind = ShaderParameterKind::TextureSampler; + break; } } else { switch (textureType->getAccess()) { - default: kind = ShaderParameterKind::MutableTexture; break; + default: + kind = ShaderParameterKind::MutableTexture; + break; - case SLANG_RESOURCE_ACCESS_READ: kind = ShaderParameterKind::Texture; break; + case SLANG_RESOURCE_ACCESS_READ: + kind = ShaderParameterKind::Texture; + break; } } auto objLayout = rules->GetObjectLayout(kind, context.objectLayoutOptions); @@ -4447,9 +4496,13 @@ static TypeLayoutResult _createTypeLayout(TypeLayoutContext& context, Type* type ShaderParameterKind kind; switch (imageType->getAccess()) { - default: kind = ShaderParameterKind::MutableImage; break; + default: + kind = ShaderParameterKind::MutableImage; + break; - case SLANG_RESOURCE_ACCESS_READ: kind = ShaderParameterKind::Image; break; + case SLANG_RESOURCE_ACCESS_READ: + kind = ShaderParameterKind::Image; + break; } return createSimpleTypeLayout( diff --git a/source/slang/slang.cpp b/source/slang/slang.cpp index d6e57e6f3..eb938f49c 100644 --- a/source/slang/slang.cpp +++ b/source/slang/slang.cpp @@ -99,22 +99,38 @@ namespace Slang { switch (baseType) { - case BaseType::Void: return UnownedStringSlice::fromLiteral("void"); - case BaseType::Bool: return UnownedStringSlice::fromLiteral("bool"); - case BaseType::Int8: return UnownedStringSlice::fromLiteral("int8_t"); - case BaseType::Int16: return UnownedStringSlice::fromLiteral("int16_t"); - case BaseType::Int: return UnownedStringSlice::fromLiteral("int"); - case BaseType::Int64: return UnownedStringSlice::fromLiteral("int64_t"); - case BaseType::UInt8: return UnownedStringSlice::fromLiteral("uint8_t"); - case BaseType::UInt16: return UnownedStringSlice::fromLiteral("uint16_t"); - case BaseType::UInt: return UnownedStringSlice::fromLiteral("uint"); - case BaseType::UInt64: return UnownedStringSlice::fromLiteral("uint64_t"); - case BaseType::Half: return UnownedStringSlice::fromLiteral("half"); - case BaseType::Float: return UnownedStringSlice::fromLiteral("float"); - case BaseType::Double: return UnownedStringSlice::fromLiteral("double"); - case BaseType::Char: return UnownedStringSlice::fromLiteral("char"); - case BaseType::IntPtr: return UnownedStringSlice::fromLiteral("intptr_t"); - case BaseType::UIntPtr: return UnownedStringSlice::fromLiteral("uintptr_t"); + case BaseType::Void: + return UnownedStringSlice::fromLiteral("void"); + case BaseType::Bool: + return UnownedStringSlice::fromLiteral("bool"); + case BaseType::Int8: + return UnownedStringSlice::fromLiteral("int8_t"); + case BaseType::Int16: + return UnownedStringSlice::fromLiteral("int16_t"); + case BaseType::Int: + return UnownedStringSlice::fromLiteral("int"); + case BaseType::Int64: + return UnownedStringSlice::fromLiteral("int64_t"); + case BaseType::UInt8: + return UnownedStringSlice::fromLiteral("uint8_t"); + case BaseType::UInt16: + return UnownedStringSlice::fromLiteral("uint16_t"); + case BaseType::UInt: + return UnownedStringSlice::fromLiteral("uint"); + case BaseType::UInt64: + return UnownedStringSlice::fromLiteral("uint64_t"); + case BaseType::Half: + return UnownedStringSlice::fromLiteral("half"); + case BaseType::Float: + return UnownedStringSlice::fromLiteral("float"); + case BaseType::Double: + return UnownedStringSlice::fromLiteral("double"); + case BaseType::Char: + return UnownedStringSlice::fromLiteral("char"); + case BaseType::IntPtr: + return UnownedStringSlice::fromLiteral("intptr_t"); + case BaseType::UIntPtr: + return UnownedStringSlice::fromLiteral("uintptr_t"); default: { SLANG_ASSERT(!"Unknown basic type"); @@ -984,7 +1000,8 @@ Profile getEffectiveProfile(EntryPoint* entryPoint, TargetRequest* target) // output with Shader Model 5.0... switch (target->getTarget()) { - default: break; + default: + break; case CodeGenTarget::GLSL: case CodeGenTarget::SPIRV: @@ -1041,7 +1058,8 @@ Profile getEffectiveProfile(EntryPoint* entryPoint, TargetRequest* target) case ProfileFamily::DX: switch (effectiveProfile.getStage()) { - default: break; + default: + break; case Stage::RayGeneration: case Stage::Intersection: @@ -1062,7 +1080,8 @@ Profile getEffectiveProfile(EntryPoint* entryPoint, TargetRequest* target) case ProfileFamily::GLSL: switch (effectiveProfile.getStage()) { - default: break; + default: + break; case Stage::RayGeneration: case Stage::Intersection: @@ -1077,7 +1096,8 @@ Profile getEffectiveProfile(EntryPoint* entryPoint, TargetRequest* target) } break; - default: break; + default: + break; } if (stageMinVersion > effectiveProfile.getVersion()) @@ -1609,7 +1629,9 @@ SLANG_NO_THROW slang::TypeReflection* SLANG_MCALL Linkage::getContainerType( containerTypeReflection = arrType; } break; - default: containerTypeReflection = type; break; + default: + containerTypeReflection = type; + break; } m_containerTypes.add(key, containerTypeReflection); @@ -1965,9 +1987,13 @@ CapabilitySet TargetRequest::getTargetCaps() case CodeGenTarget::DXBytecode: case CodeGenTarget::DXBytecodeAssembly: case CodeGenTarget::DXIL: - case CodeGenTarget::DXILAssembly: atoms.add(CapabilityName::hlsl); break; + case CodeGenTarget::DXILAssembly: + atoms.add(CapabilityName::hlsl); + break; - case CodeGenTarget::CSource: atoms.add(CapabilityName::c); break; + case CodeGenTarget::CSource: + atoms.add(CapabilityName::c); + break; case CodeGenTarget::CPPSource: case CodeGenTarget::PyTorchCppBinding: @@ -1975,20 +2001,29 @@ CapabilitySet TargetRequest::getTargetCaps() case CodeGenTarget::ShaderSharedLibrary: case CodeGenTarget::HostSharedLibrary: case CodeGenTarget::HostHostCallable: - case CodeGenTarget::ShaderHostCallable: atoms.add(CapabilityName::cpp); break; + case CodeGenTarget::ShaderHostCallable: + atoms.add(CapabilityName::cpp); + break; case CodeGenTarget::CUDASource: - case CodeGenTarget::PTX: atoms.add(CapabilityName::cuda); break; + case CodeGenTarget::PTX: + atoms.add(CapabilityName::cuda); + break; case CodeGenTarget::Metal: case CodeGenTarget::MetalLib: - case CodeGenTarget::MetalLibAssembly: atoms.add(CapabilityName::metal); break; + case CodeGenTarget::MetalLibAssembly: + atoms.add(CapabilityName::metal); + break; case CodeGenTarget::WGSLSPIRV: case CodeGenTarget::WGSLSPIRVAssembly: - case CodeGenTarget::WGSL: atoms.add(CapabilityName::wgsl); break; + case CodeGenTarget::WGSL: + atoms.add(CapabilityName::wgsl); + break; - default: break; + default: + break; } CapabilitySet targetCap = CapabilitySet(atoms); @@ -2077,10 +2112,14 @@ Scope* TranslationUnitRequest::getLanguageScope() Scope* languageScope = nullptr; switch (sourceLanguage) { - case SourceLanguage::HLSL: languageScope = getSession()->hlslLanguageScope; break; + case SourceLanguage::HLSL: + languageScope = getSession()->hlslLanguageScope; + break; case SourceLanguage::Slang: - default: languageScope = getSession()->slangLanguageScope; break; + default: + languageScope = getSession()->slangLanguageScope; + break; } return languageScope; } @@ -2123,7 +2162,8 @@ Dictionary<String, String> TranslationUnitRequest::getCombinedPreprocessorDefini // Used to indicate compiled as Slang language combinedPreprocessorDefinitions.addIfNotExists("__SLANG__", "1"); break; - default: break; + default: + break; } // If not set, define as 0. @@ -2284,9 +2324,12 @@ static ISlangWriter* _getDefaultWriter(WriterChannel chan) switch (chan) { - case WriterChannel::StdError: return &stdError; - case WriterChannel::StdOutput: return &stdOut; - case WriterChannel::Diagnostic: return &nullWriter; + case WriterChannel::StdError: + return &stdError; + case WriterChannel::StdOutput: + return &stdOut; + case WriterChannel::Diagnostic: + return &nullWriter; default: { SLANG_ASSERT(!"Unknown type"); @@ -2889,7 +2932,8 @@ static void _outputIncludesRec( // If any of these types we don't output return; } - default: break; + default: + break; } // Okay output this file at the current depth @@ -3035,10 +3079,14 @@ void FrontEndCompileRequest::parseTranslationUnit(TranslationUnitRequest* transl Scope* languageScope = nullptr; switch (sourceLanguage) { - case SourceLanguage::HLSL: languageScope = getSession()->hlslLanguageScope; break; + case SourceLanguage::HLSL: + languageScope = getSession()->hlslLanguageScope; + break; case SourceLanguage::Slang: - default: languageScope = getSession()->slangLanguageScope; break; + default: + languageScope = getSession()->slangLanguageScope; + break; } if (optionSet.getBoolOption(CompilerOptionName::OutputIncludes)) @@ -3392,11 +3440,16 @@ SlangResult EndToEndCompileRequest::executeActionsInner() auto language = inferSourceLanguage(getFrontEndReq()); switch (language) { - case SourceLanguage::HLSL: getLinkage()->addTarget(CodeGenTarget::DXBytecode); break; + case SourceLanguage::HLSL: + getLinkage()->addTarget(CodeGenTarget::DXBytecode); + break; - case SourceLanguage::GLSL: getLinkage()->addTarget(CodeGenTarget::SPIRV); break; + case SourceLanguage::GLSL: + getLinkage()->addTarget(CodeGenTarget::SPIRV); + break; - default: break; + default: + break; } } @@ -4515,7 +4568,8 @@ static bool _canExportDeclSymbol(ASTNodeType type) { return false; } - default: break; + default: + break; } return true; @@ -4916,9 +4970,13 @@ SLANG_NO_THROW SlangResult SLANG_MCALL ComponentType::specialize( SpecializationArg expandedArg; switch (apiArg.kind) { - case slang::SpecializationArg::Kind::Type: expandedArg.val = asInternal(apiArg.type); break; + case slang::SpecializationArg::Kind::Type: + expandedArg.val = asInternal(apiArg.type); + break; - default: sink.getBlobIfNeeded(outDiagnostics); return SLANG_FAIL; + default: + sink.getBlobIfNeeded(outDiagnostics); + return SLANG_FAIL; } expandedArgs.add(expandedArg); } |