Changeset 248266 in webkit
- Timestamp:
- Aug 4, 2019 8:26:33 PM (5 years ago)
- Location:
- trunk/Source/WebCore
- Files:
-
- 1 added
- 14 edited
Legend:
- Unmodified
- Added
- Removed
-
trunk/Source/WebCore/ChangeLog
r248265 r248266 1 2019-08-04 Sam Weinig <weinig@apple.com> 2 3 Mangled WHLSL names don't need to allocate Strings 4 https://bugs.webkit.org/show_bug.cgi?id=200429 5 6 Reviewed by Saam Barati. 7 8 To avoid allocating strings for each mangled name used to transform WHLSL to Metal, which we'd 9 like to avoid since it is both unnecessarily expensive in time and space, we can instead just 10 store the unique integer identifier that was being used to construct the String. 11 12 Since the existing mangled names were all of the form "prefix" + unsigned integer value (where 13 prefix could be "type", "enumerationMember", "structureElement", "variable" or "function") we 14 strongly type the integer by storing it in a struct (MangledVariableName, MangledTypeName, etc.) 15 When the full name is actually needed, StringTypeAdapter's specialized for the structs are 16 used to write directly into the preallocated buffers of StringBuilders or makeString(). 17 18 * Modules/webgpu/WHLSL/Metal/WHLSLMangledNames.h: Added. 19 (WebCore::WHLSL::Metal::MangledVariableName): 20 (WebCore::WHLSL::Metal::MangledTypeName): 21 (WebCore::WHLSL::Metal::MangledStructureElementName): 22 (WebCore::WHLSL::Metal::MangledEnumerationMemberName): 23 (WebCore::WHLSL::Metal::MangledFunctionName): 24 Adds structs for each type of mangled name and StringTypeAdapter specializations for 25 each to allow their use in StringBuilder.flexibleAppend() or makeString(). 26 27 Additionally, a Variant, MangledOrNativeTypeName, of MangledTypeName and String is 28 declared to allow for the few cases where a native type (e.g. float4) is needed. The 29 StringTypeAdapter for MangledOrNativeTypeName could be generalized for any Variant 30 in the future, but I left it non-general for now, as it is non-obvious if one would 31 want to store Variant<Types...>, and have each member function construct a temporary 32 StringTypeAdapter, or store a Variant<StringTypeAdapter<Types>...> and perform conversion 33 in the construction. 34 35 * Modules/webgpu/WHLSL/Metal/WHLSLEntryPointScaffolding.cpp: 36 (WebCore::WHLSL::Metal::EntryPointScaffolding::EntryPointScaffolding): 37 (WebCore::WHLSL::Metal::internalTypeForSemantic): 38 (WebCore::WHLSL::Metal::EntryPointScaffolding::builtInsSignature): 39 (WebCore::WHLSL::Metal::EntryPointScaffolding::mangledInputPath): 40 (WebCore::WHLSL::Metal::VertexEntryPointScaffolding::VertexEntryPointScaffolding): 41 (WebCore::WHLSL::Metal::VertexEntryPointScaffolding::signature): 42 (WebCore::WHLSL::Metal::VertexEntryPointScaffolding::pack): 43 (WebCore::WHLSL::Metal::FragmentEntryPointScaffolding::FragmentEntryPointScaffolding): 44 (WebCore::WHLSL::Metal::FragmentEntryPointScaffolding::signature): 45 (WebCore::WHLSL::Metal::FragmentEntryPointScaffolding::pack): 46 (WebCore::WHLSL::Metal::ComputeEntryPointScaffolding::ComputeEntryPointScaffolding): 47 (WebCore::WHLSL::Metal::ComputeEntryPointScaffolding::signature): 48 (WebCore::WHLSL::Metal::ComputeEntryPointScaffolding::pack): 49 * Modules/webgpu/WHLSL/Metal/WHLSLEntryPointScaffolding.h: 50 (WebCore::WHLSL::Metal::EntryPointScaffolding::parameterVariables): 51 * Modules/webgpu/WHLSL/Metal/WHLSLFunctionWriter.cpp: 52 (WebCore::WHLSL::Metal::FunctionDeclarationWriter::FunctionDeclarationWriter): 53 (WebCore::WHLSL::Metal::FunctionDeclarationWriter::visit): 54 (WebCore::WHLSL::Metal::FunctionDefinitionWriter::FunctionDefinitionWriter): 55 (WebCore::WHLSL::Metal::FunctionDefinitionWriter::generateNextVariableName): 56 (WebCore::WHLSL::Metal::FunctionDefinitionWriter::appendRightValueWithNullability): 57 (WebCore::WHLSL::Metal::FunctionDefinitionWriter::appendRightValue): 58 (WebCore::WHLSL::Metal::FunctionDefinitionWriter::appendLeftValue): 59 (WebCore::WHLSL::Metal::FunctionDefinitionWriter::takeLastValue): 60 (WebCore::WHLSL::Metal::FunctionDefinitionWriter::takeLastValueAndNullability): 61 (WebCore::WHLSL::Metal::FunctionDefinitionWriter::takeLastLeftValue): 62 (WebCore::WHLSL::Metal::FunctionDefinitionWriter::visit): 63 (WebCore::WHLSL::Metal::FunctionDefinitionWriter::emitLoop): 64 (WebCore::WHLSL::Metal::RenderFunctionDefinitionWriter::RenderFunctionDefinitionWriter): 65 (WebCore::WHLSL::Metal::RenderFunctionDefinitionWriter::createEntryPointScaffolding): 66 (WebCore::WHLSL::Metal::ComputeFunctionDefinitionWriter::ComputeFunctionDefinitionWriter): 67 (WebCore::WHLSL::Metal::ComputeFunctionDefinitionWriter::createEntryPointScaffolding): 68 (WebCore::WHLSL::Metal::sharedMetalFunctions): 69 * Modules/webgpu/WHLSL/Metal/WHLSLFunctionWriter.h: 70 * Modules/webgpu/WHLSL/Metal/WHLSLMetalCodeGenerator.h: 71 * Modules/webgpu/WHLSL/Metal/WHLSLNativeFunctionWriter.cpp: 72 (WebCore::WHLSL::Metal::writeNativeFunction): 73 * Modules/webgpu/WHLSL/Metal/WHLSLNativeFunctionWriter.h: 74 * Modules/webgpu/WHLSL/Metal/WHLSLTypeNamer.cpp: 75 (WebCore::WHLSL::Metal::BaseTypeNameNode::BaseTypeNameNode): 76 (WebCore::WHLSL::Metal::BaseTypeNameNode::mangledName const): 77 (WebCore::WHLSL::Metal::ArrayTypeNameNode::ArrayTypeNameNode): 78 (WebCore::WHLSL::Metal::ArrayReferenceTypeNameNode::ArrayReferenceTypeNameNode): 79 (WebCore::WHLSL::Metal::PointerTypeNameNode::PointerTypeNameNode): 80 (WebCore::WHLSL::Metal::ReferenceTypeNameNode::ReferenceTypeNameNode): 81 (WebCore::WHLSL::Metal::MetalTypeDeclarationWriter::MetalTypeDeclarationWriter): 82 (WebCore::WHLSL::Metal::TypeNamer::metalTypeDeclarations): 83 (WebCore::WHLSL::Metal::TypeNamer::emitNamedTypeDefinition): 84 (WebCore::WHLSL::Metal::TypeNamer::mangledNameForType): 85 (WebCore::WHLSL::Metal::TypeNamer::mangledNameForEnumerationMember): 86 (WebCore::WHLSL::Metal::TypeNamer::mangledNameForStructureElement): 87 * Modules/webgpu/WHLSL/Metal/WHLSLTypeNamer.h: 88 (WebCore::WHLSL::Metal::TypeNamer::generateNextTypeName): 89 (WebCore::WHLSL::Metal::TypeNamer::generateNextStructureElementName): 90 (WebCore::WHLSL::Metal::TypeNamer::generateNextEnumerationMemberName): 91 * Modules/webgpu/WHLSL/WHLSLPrepare.h: 92 Replace uses of String with the appropriate mangled name type. 93 94 * WebCore.xcodeproj/project.pbxproj: 95 Add WHLSLMangledNames.h 96 97 * platform/graphics/gpu/cocoa/GPUComputePipelineMetal.mm: 98 (WebCore::trySetFunctions): 99 * platform/graphics/gpu/cocoa/GPURenderPipelineMetal.mm: 100 (WebCore::trySetFunctions): 101 Convert the mangled names to Strings for passing to Metal API. NOTE: We could avoid having the 102 toString() member function on MangledFunctionName if we allowed makeString() to take a single 103 argument. 104 1 105 2019-08-04 Chris Dumez <cdumez@apple.com> 2 106 -
trunk/Source/WebCore/Modules/webgpu/WHLSL/Metal/WHLSLEntryPointScaffolding.cpp
r247917 r248266 92 92 } 93 93 94 EntryPointScaffolding::EntryPointScaffolding(AST::FunctionDefinition& functionDefinition, Intrinsics& intrinsics, TypeNamer& typeNamer, EntryPointItems& entryPointItems, HashMap<Binding*, size_t>& resourceMap, Layout& layout, std::function< String()>&& generateNextVariableName)94 EntryPointScaffolding::EntryPointScaffolding(AST::FunctionDefinition& functionDefinition, Intrinsics& intrinsics, TypeNamer& typeNamer, EntryPointItems& entryPointItems, HashMap<Binding*, size_t>& resourceMap, Layout& layout, std::function<MangledVariableName()>&& generateNextVariableName) 95 95 : m_functionDefinition(functionDefinition) 96 96 , m_intrinsics(intrinsics) … … 193 193 } 194 194 195 static String internalTypeForSemantic(const AST::BuiltInSemantic& builtInSemantic)195 static StringView internalTypeForSemantic(const AST::BuiltInSemantic& builtInSemantic) 196 196 { 197 197 switch (builtInSemantic.variable()) { 198 198 case AST::BuiltInSemantic::Variable::SVInstanceID: 199 return "uint" _str;199 return "uint"; 200 200 case AST::BuiltInSemantic::Variable::SVVertexID: 201 return "uint" _str;201 return "uint"; 202 202 case AST::BuiltInSemantic::Variable::PSize: 203 return "float" _str;203 return "float"; 204 204 case AST::BuiltInSemantic::Variable::SVPosition: 205 return "float4" _str;205 return "float4"; 206 206 case AST::BuiltInSemantic::Variable::SVIsFrontFace: 207 return "bool" _str;207 return "bool"; 208 208 case AST::BuiltInSemantic::Variable::SVSampleIndex: 209 return "uint" _str;209 return "uint"; 210 210 case AST::BuiltInSemantic::Variable::SVInnerCoverage: 211 return "uint" _str;211 return "uint"; 212 212 case AST::BuiltInSemantic::Variable::SVTarget: 213 return String();213 return { }; 214 214 case AST::BuiltInSemantic::Variable::SVDepth: 215 return "float" _str;215 return "float"; 216 216 case AST::BuiltInSemantic::Variable::SVCoverage: 217 return "uint" _str;217 return "uint"; 218 218 case AST::BuiltInSemantic::Variable::SVDispatchThreadID: 219 return "uint3" _str;219 return "uint3"; 220 220 case AST::BuiltInSemantic::Variable::SVGroupID: 221 return "uint3" _str;221 return "uint3"; 222 222 case AST::BuiltInSemantic::Variable::SVGroupIndex: 223 return "uint" _str;223 return "uint"; 224 224 default: 225 225 ASSERT(builtInSemantic.variable() == AST::BuiltInSemantic::Variable::SVGroupThreadID); 226 return "uint3" _str;226 return "uint3"; 227 227 } 228 228 } … … 241 241 auto& builtInSemantic = WTF::get<AST::BuiltInSemantic>(*item.semantic); 242 242 auto internalType = internalTypeForSemantic(builtInSemantic); 243 if (internalType.isNull()) 244 internalType = m_typeNamer.mangledNameForType(*item.unnamedType); 245 auto variableName = namedBuiltIn.variableName; 246 stringBuilder.flexibleAppend(internalType, ' ', variableName, ' ', attributeForSemantic(builtInSemantic)); 243 if (!internalType.isNull()) 244 stringBuilder.flexibleAppend(internalType); 245 else 246 stringBuilder.flexibleAppend(m_typeNamer.mangledNameForType(*item.unnamedType)); 247 stringBuilder.flexibleAppend(' ', namedBuiltIn.variableName, ' ', attributeForSemantic(builtInSemantic)); 247 248 } 248 249 return stringBuilder.toString(); … … 257 258 for (size_t i = 0; i < m_functionDefinition.parameters().size(); ++i) { 258 259 if (m_functionDefinition.parameters()[i]->name() == path[0]) { 259 stringBuilder. append(m_parameterVariables[i]);260 stringBuilder.flexibleAppend(m_parameterVariables[i]); 260 261 auto& unifyNode = m_functionDefinition.parameters()[i]->type()->unifyNode(); 261 262 if (is<AST::NamedType>(unifyNode)) { … … 357 358 } 358 359 359 VertexEntryPointScaffolding::VertexEntryPointScaffolding(AST::FunctionDefinition& functionDefinition, Intrinsics& intrinsics, TypeNamer& typeNamer, EntryPointItems& entryPointItems, HashMap<Binding*, size_t>& resourceMap, Layout& layout, std::function< String()>&& generateNextVariableName, HashMap<VertexAttribute*, size_t>& matchedVertexAttributes)360 VertexEntryPointScaffolding::VertexEntryPointScaffolding(AST::FunctionDefinition& functionDefinition, Intrinsics& intrinsics, TypeNamer& typeNamer, EntryPointItems& entryPointItems, HashMap<Binding*, size_t>& resourceMap, Layout& layout, std::function<MangledVariableName()>&& generateNextVariableName, HashMap<VertexAttribute*, size_t>& matchedVertexAttributes) 360 361 : EntryPointScaffolding(functionDefinition, intrinsics, typeNamer, entryPointItems, resourceMap, layout, WTFMove(generateNextVariableName)) 361 362 , m_matchedVertexAttributes(matchedVertexAttributes) … … 378 379 NamedOutput namedOutput; 379 380 namedOutput.elementName = m_typeNamer.generateNextStructureElementName(); 381 StringView internalType; 380 382 if (WTF::holds_alternative<AST::BuiltInSemantic>(*outputItem.semantic)) 381 namedOutput.internalTypeName = internalTypeForSemantic(WTF::get<AST::BuiltInSemantic>(*outputItem.semantic)); 382 if (namedOutput.internalTypeName.isNull()) 383 internalType = internalTypeForSemantic(WTF::get<AST::BuiltInSemantic>(*outputItem.semantic)); 384 if (!internalType.isNull()) 385 namedOutput.internalTypeName = internalType.toString(); 386 else 383 387 namedOutput.internalTypeName = m_typeNamer.mangledNameForType(*outputItem.unnamedType); 384 388 m_namedOutputs.uncheckedAppend(WTFMove(namedOutput)); … … 416 420 } 417 421 418 String VertexEntryPointScaffolding::signature( String&functionName)422 String VertexEntryPointScaffolding::signature(MangledFunctionName functionName) 419 423 { 420 424 StringBuilder stringBuilder; … … 445 449 } 446 450 447 String VertexEntryPointScaffolding::pack( const String& inputVariableName, const String&outputVariableName)451 String VertexEntryPointScaffolding::pack(MangledVariableName inputVariableName, MangledVariableName outputVariableName) 448 452 { 449 453 StringBuilder stringBuilder; … … 464 468 } 465 469 466 FragmentEntryPointScaffolding::FragmentEntryPointScaffolding(AST::FunctionDefinition& functionDefinition, Intrinsics& intrinsics, TypeNamer& typeNamer, EntryPointItems& entryPointItems, HashMap<Binding*, size_t>& resourceMap, Layout& layout, std::function< String()>&& generateNextVariableName, HashMap<AttachmentDescriptor*, size_t>&)470 FragmentEntryPointScaffolding::FragmentEntryPointScaffolding(AST::FunctionDefinition& functionDefinition, Intrinsics& intrinsics, TypeNamer& typeNamer, EntryPointItems& entryPointItems, HashMap<Binding*, size_t>& resourceMap, Layout& layout, std::function<MangledVariableName()>&& generateNextVariableName, HashMap<AttachmentDescriptor*, size_t>&) 467 471 : EntryPointScaffolding(functionDefinition, intrinsics, typeNamer, entryPointItems, resourceMap, layout, WTFMove(generateNextVariableName)) 468 472 , m_stageInStructName(typeNamer.generateNextTypeName()) … … 487 491 NamedOutput namedOutput; 488 492 namedOutput.elementName = m_typeNamer.generateNextStructureElementName(); 493 StringView internalType; 489 494 if (WTF::holds_alternative<AST::BuiltInSemantic>(*outputItem.semantic)) 490 namedOutput.internalTypeName = internalTypeForSemantic(WTF::get<AST::BuiltInSemantic>(*outputItem.semantic)); 491 if (namedOutput.internalTypeName.isNull()) 495 internalType = internalTypeForSemantic(WTF::get<AST::BuiltInSemantic>(*outputItem.semantic)); 496 if (!internalType.isNull()) 497 namedOutput.internalTypeName = internalType.toString(); 498 else 492 499 namedOutput.internalTypeName = m_typeNamer.mangledNameForType(*outputItem.unnamedType); 493 500 m_namedOutputs.uncheckedAppend(WTFMove(namedOutput)); … … 525 532 } 526 533 527 String FragmentEntryPointScaffolding::signature( String&functionName)534 String FragmentEntryPointScaffolding::signature(MangledFunctionName functionName) 528 535 { 529 536 StringBuilder stringBuilder; … … 554 561 } 555 562 556 String FragmentEntryPointScaffolding::pack( const String& inputVariableName, const String&outputVariableName)563 String FragmentEntryPointScaffolding::pack(MangledVariableName inputVariableName, MangledVariableName outputVariableName) 557 564 { 558 565 StringBuilder stringBuilder; … … 573 580 } 574 581 575 ComputeEntryPointScaffolding::ComputeEntryPointScaffolding(AST::FunctionDefinition& functionDefinition, Intrinsics& intrinsics, TypeNamer& typeNamer, EntryPointItems& entryPointItems, HashMap<Binding*, size_t>& resourceMap, Layout& layout, std::function< String()>&& generateNextVariableName)582 ComputeEntryPointScaffolding::ComputeEntryPointScaffolding(AST::FunctionDefinition& functionDefinition, Intrinsics& intrinsics, TypeNamer& typeNamer, EntryPointItems& entryPointItems, HashMap<Binding*, size_t>& resourceMap, Layout& layout, std::function<MangledVariableName()>&& generateNextVariableName) 576 583 : EntryPointScaffolding(functionDefinition, intrinsics, typeNamer, entryPointItems, resourceMap, layout, WTFMove(generateNextVariableName)) 577 584 { … … 583 590 } 584 591 585 String ComputeEntryPointScaffolding::signature( String&functionName)592 String ComputeEntryPointScaffolding::signature(MangledFunctionName functionName) 586 593 { 587 594 StringBuilder stringBuilder; … … 608 615 } 609 616 610 String ComputeEntryPointScaffolding::pack( const String&, const String&)617 String ComputeEntryPointScaffolding::pack(MangledVariableName, MangledVariableName) 611 618 { 612 619 ASSERT_NOT_REACHED(); -
trunk/Source/WebCore/Modules/webgpu/WHLSL/Metal/WHLSLEntryPointScaffolding.h
r246427 r248266 28 28 #if ENABLE(WEBGPU) 29 29 30 #include "WHLSLMangledNames.h" 30 31 #include "WHLSLPipelineDescriptor.h" 31 32 #include <wtf/HashMap.h> … … 51 52 class EntryPointScaffolding { 52 53 public: 53 EntryPointScaffolding(AST::FunctionDefinition&, Intrinsics&, TypeNamer&, EntryPointItems&, HashMap<Binding*, size_t>& resourceMap, Layout&, std::function<String()>&& generateNextVariableName);54 54 virtual ~EntryPointScaffolding() = default; 55 55 56 56 virtual String helperTypes() = 0; 57 virtual String signature( String& functionName) = 0;57 virtual String signature(MangledFunctionName) = 0; 58 58 virtual String unpack() = 0; 59 virtual String pack( const String& existingVariableName, const String& variableName) = 0;59 virtual String pack(MangledVariableName existingVariableName, MangledVariableName) = 0; 60 60 61 Vector< String>& parameterVariables() { return m_parameterVariables; }61 Vector<MangledVariableName>& parameterVariables() { return m_parameterVariables; } 62 62 63 63 protected: 64 EntryPointScaffolding(AST::FunctionDefinition&, Intrinsics&, TypeNamer&, EntryPointItems&, HashMap<Binding*, size_t>& resourceMap, Layout&, std::function<MangledVariableName()>&& generateNextVariableName); 65 64 66 String resourceHelperTypes(); 65 67 Optional<String> resourceSignature(); … … 76 78 HashMap<Binding*, size_t>& m_resourceMap; 77 79 Layout& m_layout; 78 std::function< String()> m_generateNextVariableName;80 std::function<MangledVariableName()> m_generateNextVariableName; 79 81 80 82 struct LengthInformation { 81 StringelementName;82 StringtemporaryName;83 MangledStructureElementName elementName; 84 MangledVariableName temporaryName; 83 85 unsigned index; 84 86 }; 85 87 struct NamedBinding { 86 StringelementName;88 MangledStructureElementName elementName; 87 89 unsigned index; 88 90 Optional<LengthInformation> lengthInformation; 89 91 }; 90 92 struct NamedBindGroup { 91 StringstructName;92 StringvariableName;93 MangledTypeName structName; 94 MangledVariableName variableName; 93 95 Vector<NamedBinding> namedBindings; 94 96 unsigned argumentBufferIndex; … … 98 100 struct NamedBuiltIn { 99 101 size_t indexInEntryPointItems; 100 StringvariableName;102 MangledVariableName variableName; 101 103 }; 102 104 Vector<NamedBuiltIn> m_namedBuiltIns; 103 105 104 Vector< String> m_parameterVariables;106 Vector<MangledVariableName> m_parameterVariables; 105 107 }; 106 108 107 109 class VertexEntryPointScaffolding : public EntryPointScaffolding { 108 110 public: 109 VertexEntryPointScaffolding(AST::FunctionDefinition&, Intrinsics&, TypeNamer&, EntryPointItems&, HashMap<Binding*, size_t>& resourceMap, Layout&, std::function< String()>&& generateNextVariableName, HashMap<VertexAttribute*, size_t>& matchedVertexAttributes);111 VertexEntryPointScaffolding(AST::FunctionDefinition&, Intrinsics&, TypeNamer&, EntryPointItems&, HashMap<Binding*, size_t>& resourceMap, Layout&, std::function<MangledVariableName()>&& generateNextVariableName, HashMap<VertexAttribute*, size_t>& matchedVertexAttributes); 110 112 virtual ~VertexEntryPointScaffolding() = default; 111 113 112 114 String helperTypes() override; 113 String signature( String& functionName) override;115 String signature(MangledFunctionName) override; 114 116 String unpack() override; 115 String pack( const String& existingVariableName, const String& variableName) override;117 String pack(MangledVariableName existingVariableName, MangledVariableName) override; 116 118 117 119 private: 118 120 HashMap<VertexAttribute*, size_t>& m_matchedVertexAttributes; 119 Stringm_stageInStructName;120 Stringm_returnStructName;121 Stringm_stageInParameterName;121 MangledTypeName m_stageInStructName; 122 MangledTypeName m_returnStructName; 123 MangledVariableName m_stageInParameterName; 122 124 123 125 struct NamedStageIn { 124 126 size_t indexInEntryPointItems; 125 StringelementName;127 MangledStructureElementName elementName; 126 128 unsigned attributeIndex; 127 129 }; … … 129 131 130 132 struct NamedOutput { 131 StringelementName;132 StringinternalTypeName;133 MangledStructureElementName elementName; 134 MangledOrNativeTypeName internalTypeName; 133 135 }; 134 136 Vector<NamedOutput> m_namedOutputs; … … 137 139 class FragmentEntryPointScaffolding : public EntryPointScaffolding { 138 140 public: 139 FragmentEntryPointScaffolding(AST::FunctionDefinition&, Intrinsics&, TypeNamer&, EntryPointItems&, HashMap<Binding*, size_t>& resourceMap, Layout&, std::function< String()>&& generateNextVariableName, HashMap<AttachmentDescriptor*, size_t>& matchedColorAttachments);141 FragmentEntryPointScaffolding(AST::FunctionDefinition&, Intrinsics&, TypeNamer&, EntryPointItems&, HashMap<Binding*, size_t>& resourceMap, Layout&, std::function<MangledVariableName()>&& generateNextVariableName, HashMap<AttachmentDescriptor*, size_t>& matchedColorAttachments); 140 142 virtual ~FragmentEntryPointScaffolding() = default; 141 143 142 144 String helperTypes() override; 143 String signature( String& functionName) override;145 String signature(MangledFunctionName) override; 144 146 String unpack() override; 145 String pack( const String& existingVariableName, const String& variableName) override;147 String pack(MangledVariableName existingVariableName, MangledVariableName) override; 146 148 147 149 private: 148 Stringm_stageInStructName;149 Stringm_returnStructName;150 Stringm_stageInParameterName;150 MangledTypeName m_stageInStructName; 151 MangledTypeName m_returnStructName; 152 MangledVariableName m_stageInParameterName; 151 153 152 154 struct NamedStageIn { 153 155 size_t indexInEntryPointItems; 154 StringelementName;156 MangledStructureElementName elementName; 155 157 unsigned attributeIndex; 156 158 }; … … 158 160 159 161 struct NamedOutput { 160 StringelementName;161 StringinternalTypeName;162 MangledStructureElementName elementName; 163 MangledOrNativeTypeName internalTypeName; 162 164 }; 163 165 Vector<NamedOutput> m_namedOutputs; … … 166 168 class ComputeEntryPointScaffolding : public EntryPointScaffolding { 167 169 public: 168 ComputeEntryPointScaffolding(AST::FunctionDefinition&, Intrinsics&, TypeNamer&, EntryPointItems&, HashMap<Binding*, size_t>& resourceMap, Layout&, std::function< String()>&& generateNextVariableName);170 ComputeEntryPointScaffolding(AST::FunctionDefinition&, Intrinsics&, TypeNamer&, EntryPointItems&, HashMap<Binding*, size_t>& resourceMap, Layout&, std::function<MangledVariableName()>&& generateNextVariableName); 169 171 virtual ~ComputeEntryPointScaffolding() = default; 170 172 171 173 String helperTypes() override; 172 String signature( String& functionName) override;174 String signature(MangledFunctionName) override; 173 175 String unpack() override; 174 String pack(const String& existingVariableName, const String& variableName) override; 175 176 private: 176 String pack(MangledVariableName existingVariableName, MangledVariableName) override; 177 177 }; 178 178 -
trunk/Source/WebCore/Modules/webgpu/WHLSL/Metal/WHLSLFunctionWriter.cpp
r248141 r248266 50 50 class FunctionDeclarationWriter : public Visitor { 51 51 public: 52 FunctionDeclarationWriter(TypeNamer& typeNamer, HashMap<AST::FunctionDeclaration*, String>& functionMapping)52 FunctionDeclarationWriter(TypeNamer& typeNamer, HashMap<AST::FunctionDeclaration*, MangledFunctionName>& functionMapping) 53 53 : m_typeNamer(typeNamer) 54 54 , m_functionMapping(functionMapping) … … 64 64 private: 65 65 TypeNamer& m_typeNamer; 66 HashMap<AST::FunctionDeclaration*, String>& m_functionMapping;66 HashMap<AST::FunctionDeclaration*, MangledFunctionName>& m_functionMapping; 67 67 StringBuilder m_stringBuilder; 68 68 }; … … 79 79 if (i) 80 80 m_stringBuilder.append(", "); 81 m_stringBuilder. append(m_typeNamer.mangledNameForType(*functionDeclaration.parameters()[i]->type()));81 m_stringBuilder.flexibleAppend(m_typeNamer.mangledNameForType(*functionDeclaration.parameters()[i]->type())); 82 82 } 83 83 m_stringBuilder.append(");\n"); … … 86 86 class FunctionDefinitionWriter : public Visitor { 87 87 public: 88 FunctionDefinitionWriter(Intrinsics& intrinsics, TypeNamer& typeNamer, HashMap<AST::FunctionDeclaration*, String>& functionMapping, Layout& layout)88 FunctionDefinitionWriter(Intrinsics& intrinsics, TypeNamer& typeNamer, HashMap<AST::FunctionDeclaration*, MangledFunctionName>& functionMapping, Layout& layout) 89 89 : m_intrinsics(intrinsics) 90 90 , m_typeNamer(typeNamer) … … 151 151 String constantExpressionString(AST::ConstantExpression&); 152 152 153 String generateNextVariableName() 154 { 155 return makeString("variable", m_variableCount++); 156 } 153 MangledVariableName generateNextVariableName() { return { m_variableCount++ }; } 157 154 158 155 enum class Nullability : uint8_t { … … 162 159 163 160 struct StackItem { 164 Stringvalue;165 StringleftValue;161 MangledVariableName value; 162 Optional<MangledVariableName> leftValue; 166 163 Nullability valueNullability; 167 164 Nullability leftValueNullability; … … 169 166 170 167 struct StackValue { 171 Stringvalue;168 MangledVariableName value; 172 169 Nullability nullability; 173 170 }; … … 178 175 // non-null, and DereferenceExpression will take a non-null rvalue and try to produce 179 176 // a non-null lvalue. 180 void appendRightValueWithNullability(AST::Expression&, Stringvalue, Nullability nullability)181 { 182 m_stack.append({ WTFMove(value), String(), nullability, Nullability::CanBeNull });183 } 184 185 void appendRightValue(AST::Expression& expression, Stringvalue)177 void appendRightValueWithNullability(AST::Expression&, MangledVariableName value, Nullability nullability) 178 { 179 m_stack.append({ WTFMove(value), WTF::nullopt, nullability, Nullability::CanBeNull }); 180 } 181 182 void appendRightValue(AST::Expression& expression, MangledVariableName value) 186 183 { 187 184 appendRightValueWithNullability(expression, WTFMove(value), Nullability::CanBeNull); 188 185 } 189 186 190 void appendLeftValue(AST::Expression& expression, String value, StringleftValue, Nullability nullability)187 void appendLeftValue(AST::Expression& expression, MangledVariableName value, MangledVariableName leftValue, Nullability nullability) 191 188 { 192 189 ASSERT_UNUSED(expression, expression.typeAnnotation().leftAddressSpace()); … … 194 191 } 195 192 196 String takeLastValue() 197 { 198 ASSERT(m_stack.last().value); 193 MangledVariableName takeLastValue() 194 { 199 195 return m_stack.takeLast().value; 200 196 } … … 202 198 StackValue takeLastValueAndNullability() 203 199 { 204 ASSERT(m_stack.last().value);205 200 auto last = m_stack.takeLast(); 206 201 return { last.value, last.valueNullability }; … … 211 206 ASSERT(m_stack.last().leftValue); 212 207 auto last = m_stack.takeLast(); 213 return { last.leftValue, last.leftValueNullability };208 return { *last.leftValue, last.leftValueNullability }; 214 209 } 215 210 … … 223 218 Intrinsics& m_intrinsics; 224 219 TypeNamer& m_typeNamer; 225 HashMap<AST::FunctionDeclaration*, String>& m_functionMapping;226 HashMap<AST::VariableDeclaration*, String> m_variableMapping;220 HashMap<AST::FunctionDeclaration*, MangledFunctionName>& m_functionMapping; 221 HashMap<AST::VariableDeclaration*, MangledVariableName> m_variableMapping; 227 222 StringBuilder m_stringBuilder; 228 223 … … 231 226 Layout& m_layout; 232 227 unsigned m_variableCount { 0 }; 233 Stringm_breakOutOfCurrentLoopEarlyVariable;228 Optional<MangledVariableName> m_breakOutOfCurrentLoopEarlyVariable; 234 229 }; 235 230 … … 308 303 break; 309 304 case BreakContext::Loop: 310 ASSERT(m_breakOutOfCurrentLoopEarlyVariable .length());305 ASSERT(m_breakOutOfCurrentLoopEarlyVariable); 311 306 m_stringBuilder.flexibleAppend( 312 m_breakOutOfCurrentLoopEarlyVariable, " = true;\n"307 *m_breakOutOfCurrentLoopEarlyVariable, " = true;\n" 313 308 "break;\n" 314 309 ); … … 319 314 void FunctionDefinitionWriter::visit(AST::Continue&) 320 315 { 321 ASSERT(m_breakOutOfCurrentLoopEarlyVariable .length());316 ASSERT(m_breakOutOfCurrentLoopEarlyVariable); 322 317 m_stringBuilder.append("break;\n"); 323 318 } … … 336 331 void FunctionDefinitionWriter::emitLoop(LoopConditionLocation loopConditionLocation, AST::Expression* conditionExpression, AST::Expression* increment, AST::Statement& body) 337 332 { 338 SetForScope< String> loopVariableScope(m_breakOutOfCurrentLoopEarlyVariable, generateNextVariableName());333 SetForScope<Optional<MangledVariableName>> loopVariableScope(m_breakOutOfCurrentLoopEarlyVariable, generateNextVariableName()); 339 334 340 335 m_stringBuilder.flexibleAppend( 341 "bool ", m_breakOutOfCurrentLoopEarlyVariable, " = false;\n",336 "bool ", *m_breakOutOfCurrentLoopEarlyVariable, " = false;\n", 342 337 "while (true) {\n" 343 338 ); … … 353 348 m_stringBuilder.flexibleAppend( 354 349 "} while(false); \n" 355 "if (", m_breakOutOfCurrentLoopEarlyVariable, ") break;\n"350 "if (", *m_breakOutOfCurrentLoopEarlyVariable, ") break;\n" 356 351 ); 357 352 … … 517 512 // FIXME: https://bugs.webkit.org/show_bug.cgi?id=195788 Replace this with ASSERT_NOT_REACHED(). 518 513 notImplemented(); 519 appendRightValue(dotExpression, "dummy");514 appendRightValue(dotExpression, generateNextVariableName()); 520 515 } 521 516 … … 538 533 // FIXME: https://bugs.webkit.org/show_bug.cgi?id=195788 Replace this with ASSERT_NOT_REACHED(). 539 534 notImplemented(); 540 appendRightValue(indexExpression, "dummy");535 appendRightValue(indexExpression, generateNextVariableName()); 541 536 } 542 537 … … 546 541 // FIXME: https://bugs.webkit.org/show_bug.cgi?id=195788 Replace this with ASSERT_NOT_REACHED(). 547 542 notImplemented(); 548 appendRightValue(propertyAccessExpression, "dummy");543 appendRightValue(propertyAccessExpression, generateNextVariableName()); 549 544 } 550 545 … … 578 573 void FunctionDefinitionWriter::visit(AST::CallExpression& callExpression) 579 574 { 580 Vector< String> argumentNames;575 Vector<MangledVariableName> argumentNames; 581 576 for (auto& argument : callExpression.arguments()) { 582 577 checkErrorAndVisit(argument); … … 592 587 if (i) 593 588 m_stringBuilder.append(", "); 594 m_stringBuilder. append(argumentNames[i]);589 m_stringBuilder.flexibleAppend(argumentNames[i]); 595 590 } 596 591 m_stringBuilder.append(");\n"); … … 600 595 void FunctionDefinitionWriter::visit(AST::CommaExpression& commaExpression) 601 596 { 602 Stringresult;597 Optional<MangledVariableName> result; 603 598 for (auto& expression : commaExpression.list()) { 604 599 checkErrorAndVisit(expression); 605 600 result = takeLastValue(); 606 601 } 607 appendRightValue(commaExpression, result); 602 ASSERT(result); 603 appendRightValue(commaExpression, *result); 608 604 } 609 605 … … 751 747 class RenderFunctionDefinitionWriter : public FunctionDefinitionWriter { 752 748 public: 753 RenderFunctionDefinitionWriter(Intrinsics& intrinsics, TypeNamer& typeNamer, HashMap<AST::FunctionDeclaration*, String>& functionMapping, MatchedRenderSemantics&& matchedSemantics, Layout& layout)749 RenderFunctionDefinitionWriter(Intrinsics& intrinsics, TypeNamer& typeNamer, HashMap<AST::FunctionDeclaration*, MangledFunctionName>& functionMapping, MatchedRenderSemantics&& matchedSemantics, Layout& layout) 754 750 : FunctionDefinitionWriter(intrinsics, typeNamer, functionMapping, layout) 755 751 , m_matchedSemantics(WTFMove(matchedSemantics)) … … 765 761 std::unique_ptr<EntryPointScaffolding> RenderFunctionDefinitionWriter::createEntryPointScaffolding(AST::FunctionDefinition& functionDefinition) 766 762 { 767 auto generateNextVariableName = [this]() -> String{763 auto generateNextVariableName = [this]() -> MangledVariableName { 768 764 return this->generateNextVariableName(); 769 765 }; … … 777 773 class ComputeFunctionDefinitionWriter : public FunctionDefinitionWriter { 778 774 public: 779 ComputeFunctionDefinitionWriter(Intrinsics& intrinsics, TypeNamer& typeNamer, HashMap<AST::FunctionDeclaration*, String>& functionMapping, MatchedComputeSemantics&& matchedSemantics, Layout& layout)775 ComputeFunctionDefinitionWriter(Intrinsics& intrinsics, TypeNamer& typeNamer, HashMap<AST::FunctionDeclaration*, MangledFunctionName>& functionMapping, MatchedComputeSemantics&& matchedSemantics, Layout& layout) 780 776 : FunctionDefinitionWriter(intrinsics, typeNamer, functionMapping, layout) 781 777 , m_matchedSemantics(WTFMove(matchedSemantics)) … … 791 787 std::unique_ptr<EntryPointScaffolding> ComputeFunctionDefinitionWriter::createEntryPointScaffolding(AST::FunctionDefinition& functionDefinition) 792 788 { 793 auto generateNextVariableName = [this]() -> String{789 auto generateNextVariableName = [this]() -> MangledVariableName { 794 790 return this->generateNextVariableName(); 795 791 }; … … 800 796 801 797 struct SharedMetalFunctionsResult { 802 HashMap<AST::FunctionDeclaration*, String> functionMapping;798 HashMap<AST::FunctionDeclaration*, MangledFunctionName> functionMapping; 803 799 String metalFunctions; 804 800 }; … … 808 804 809 805 unsigned numFunctions = 0; 810 HashMap<AST::FunctionDeclaration*, String> functionMapping;806 HashMap<AST::FunctionDeclaration*, MangledFunctionName> functionMapping; 811 807 for (auto& nativeFunctionDeclaration : program.nativeFunctionDeclarations()) { 812 auto addResult = functionMapping.add(&nativeFunctionDeclaration, makeString("function", numFunctions++));808 auto addResult = functionMapping.add(&nativeFunctionDeclaration, MangledFunctionName { numFunctions++ }); 813 809 ASSERT_UNUSED(addResult, addResult.isNewEntry); 814 810 } 815 811 for (auto& functionDefinition : program.functionDefinitions()) { 816 auto addResult = functionMapping.add(&functionDefinition, makeString("function", numFunctions++));812 auto addResult = functionMapping.add(&functionDefinition, MangledFunctionName { numFunctions++ }); 817 813 ASSERT_UNUSED(addResult, addResult.isNewEntry); 818 814 } -
trunk/Source/WebCore/Modules/webgpu/WHLSL/Metal/WHLSLFunctionWriter.h
r243091 r248266 28 28 #if ENABLE(WEBGPU) 29 29 30 #include "WHLSLMangledNames.h" 30 31 #include "WHLSLSemanticMatcher.h" 31 32 … … 42 43 struct RenderMetalFunctions { 43 44 String metalSource; 44 StringmangledVertexEntryPointName;45 StringmangledFragmentEntryPointName;45 MangledFunctionName mangledVertexEntryPointName; 46 MangledFunctionName mangledFragmentEntryPointName; 46 47 }; 47 48 RenderMetalFunctions metalFunctions(Program&, TypeNamer&, MatchedRenderSemantics&&, Layout&); … … 49 50 struct ComputeMetalFunctions { 50 51 String metalSource; 51 StringmangledEntryPointName;52 MangledFunctionName mangledEntryPointName; 52 53 }; 53 54 ComputeMetalFunctions metalFunctions(Program&, TypeNamer&, MatchedComputeSemantics&&, Layout&); -
trunk/Source/WebCore/Modules/webgpu/WHLSL/Metal/WHLSLMetalCodeGenerator.h
r243091 r248266 28 28 #if ENABLE(WEBGPU) 29 29 30 #include "WHLSLMangledNames.h" 30 31 #include "WHLSLPipelineDescriptor.h" 31 32 #include "WHLSLSemanticMatcher.h" … … 43 44 struct RenderMetalCode { 44 45 String metalSource; 45 StringmangledVertexEntryPointName;46 StringmangledFragmentEntryPointName;46 MangledFunctionName mangledVertexEntryPointName; 47 MangledFunctionName mangledFragmentEntryPointName; 47 48 }; 48 49 // Can't fail. Any failure checks need to be done earlier, in the backend-agnostic part of the compiler. … … 51 52 struct ComputeMetalCode { 52 53 String metalSource; 53 StringmangledEntryPointName;54 MangledFunctionName mangledEntryPointName; 54 55 }; 55 56 // Can't fail. Any failure checks need to be done earlier, in the backend-agnostic part of the compiler. -
trunk/Source/WebCore/Modules/webgpu/WHLSL/Metal/WHLSLNativeFunctionWriter.cpp
r248096 r248266 121 121 } 122 122 123 String writeNativeFunction(AST::NativeFunctionDeclaration& nativeFunctionDeclaration, String&outputFunctionName, Intrinsics& intrinsics, TypeNamer& typeNamer)123 String writeNativeFunction(AST::NativeFunctionDeclaration& nativeFunctionDeclaration, MangledFunctionName outputFunctionName, Intrinsics& intrinsics, TypeNamer& typeNamer) 124 124 { 125 125 StringBuilder stringBuilder; … … 206 206 207 207 if (nativeFunctionDeclaration.name().startsWith("operator."_str)) { 208 auto mangledFieldName = [&](const String& fieldName) -> String{208 auto appendMangledFieldName = [&](StringBuilder& stringBuilder, const String& fieldName) { 209 209 auto& unifyNode = nativeFunctionDeclaration.parameters()[0]->type()->unifyNode(); 210 210 auto& namedType = downcast<AST::NamedType>(unifyNode); … … 213 213 auto* structureElement = structureDefinition.find(fieldName); 214 214 ASSERT(structureElement); 215 return typeNamer.mangledNameForStructureElement(*structureElement); 215 stringBuilder.flexibleAppend(typeNamer.mangledNameForStructureElement(*structureElement)); 216 return; 216 217 } 217 218 ASSERT(is<AST::NativeTypeDeclaration>(namedType)); 218 return fieldName;219 stringBuilder.append(fieldName); 219 220 }; 220 221 … … 224 225 auto metalParameter2Name = typeNamer.mangledNameForType(*nativeFunctionDeclaration.parameters()[1]->type()); 225 226 auto metalReturnName = typeNamer.mangledNameForType(nativeFunctionDeclaration.type()); 227 stringBuilder.flexibleAppend( 228 metalReturnName, ' ', outputFunctionName, '(', metalParameter1Name, " v, ", metalParameter2Name, " n) {\n" 229 " v." 230 ); 231 226 232 auto fieldName = nativeFunctionDeclaration.name().substring("operator."_str.length()); 227 233 fieldName = fieldName.substring(0, fieldName.length() - 1); 228 auto metalFieldName = mangledFieldName(fieldName); 229 stringBuilder.flexibleAppend( 230 metalReturnName, ' ', outputFunctionName, '(', metalParameter1Name, " v, ", metalParameter2Name, " n) {\n" 231 " v.", metalFieldName, " = n;\n" 234 appendMangledFieldName(stringBuilder, fieldName); 235 236 stringBuilder.append(" = n;\n" 232 237 " return v;\n" 233 238 "}\n" … … 237 242 238 243 ASSERT(nativeFunctionDeclaration.parameters().size() == 1); 244 auto metalParameterName = typeNamer.mangledNameForType(*nativeFunctionDeclaration.parameters()[0]->type()); 245 auto metalReturnName = typeNamer.mangledNameForType(nativeFunctionDeclaration.type()); 246 stringBuilder.flexibleAppend( 247 metalReturnName, ' ', outputFunctionName, '(', metalParameterName, " v) {\n" 248 " return v." 249 ); 250 239 251 auto fieldName = nativeFunctionDeclaration.name().substring("operator."_str.length()); 240 auto metalParameterName = typeNamer.mangledNameForType(*nativeFunctionDeclaration.parameters()[0]->type()); 241 auto metalReturnName = typeNamer.mangledNameForType(nativeFunctionDeclaration.type()); 242 auto metalFieldName = mangledFieldName(fieldName); 243 stringBuilder.flexibleAppend( 244 metalReturnName, ' ', outputFunctionName, '(', metalParameterName, " v) {\n" 245 " return v.", metalFieldName, ";\n" 252 appendMangledFieldName(stringBuilder, fieldName); 253 254 stringBuilder.append(";\n" 246 255 "}\n" 247 256 ); … … 253 262 auto metalParameterName = typeNamer.mangledNameForType(*nativeFunctionDeclaration.parameters()[0]->type()); 254 263 auto metalReturnName = typeNamer.mangledNameForType(nativeFunctionDeclaration.type()); 264 265 stringBuilder.flexibleAppend( 266 metalReturnName, ' ', outputFunctionName, '(', metalParameterName, " v) {\n" 267 " return &(v->" 268 ); 269 255 270 auto fieldName = nativeFunctionDeclaration.name().substring("operator&."_str.length()); 256 257 String metalFieldName;258 271 auto& unnamedType = *nativeFunctionDeclaration.parameters()[0]->type(); 259 272 auto& unifyNode = downcast<AST::PointerType>(unnamedType).elementType().unifyNode(); … … 263 276 auto* structureElement = structureDefinition.find(fieldName); 264 277 ASSERT(structureElement); 265 metalFieldName = typeNamer.mangledNameForStructureElement(*structureElement);278 stringBuilder.flexibleAppend(typeNamer.mangledNameForStructureElement(*structureElement)); 266 279 } else 267 metalFieldName = fieldName; 268 269 stringBuilder.flexibleAppend( 270 metalReturnName, ' ', outputFunctionName, '(', metalParameterName, " v) {\n" 271 " return &(v->", metalFieldName, ");\n" 280 stringBuilder.flexibleAppend(fieldName); 281 282 stringBuilder.append( 283 ");\n" 272 284 "}\n" 273 285 ); … … 513 525 auto metalParameter2Name = typeNamer.mangledNameForType(*nativeFunctionDeclaration.parameters()[1]->type()); 514 526 auto metalParameter3Name = typeNamer.mangledNameForType(locationType); 515 StringmetalParameter4Name;527 Optional<MangledTypeName> metalParameter4Name; 516 528 if (nativeFunctionDeclaration.parameters().size() == 4) 517 529 metalParameter4Name = typeNamer.mangledNameForType(*nativeFunctionDeclaration.parameters()[3]->type()); 518 530 auto metalReturnName = typeNamer.mangledNameForType(returnType); 519 531 stringBuilder.flexibleAppend(metalReturnName, ' ', outputFunctionName, '(', metalParameter1Name, " theTexture, ", metalParameter2Name, " theSampler, ", metalParameter3Name, " location"); 520 if ( !metalParameter4Name.isNull())521 stringBuilder.flexibleAppend(", ", metalParameter4Name, " offset");532 if (metalParameter4Name) 533 stringBuilder.flexibleAppend(", ", *metalParameter4Name, " offset"); 522 534 stringBuilder.append( 523 535 ") {\n" … … 529 541 } else 530 542 stringBuilder.append("location"); 531 if ( !metalParameter4Name.isNull())543 if (metalParameter4Name) 532 544 stringBuilder.append(", offset"); 533 545 stringBuilder.append(")"); … … 621 633 auto widthTypeName = typeNamer.mangledNameForType(*nativeFunctionDeclaration.parameters()[index]->type()); 622 634 ++index; 623 StringheightTypeName;635 Optional<MangledTypeName> heightTypeName; 624 636 if (textureType.textureDimension() >= 2) { 625 637 heightTypeName = typeNamer.mangledNameForType(*nativeFunctionDeclaration.parameters()[index]->type()); 626 638 ++index; 627 639 } 628 StringdepthTypeName;640 Optional<MangledTypeName> depthTypeName; 629 641 if (textureType.textureDimension() >= 3) { 630 642 depthTypeName = typeNamer.mangledNameForType(*nativeFunctionDeclaration.parameters()[index]->type()); 631 643 ++index; 632 644 } 633 StringelementsTypeName;645 Optional<MangledTypeName> elementsTypeName; 634 646 if (textureType.isTextureArray()) { 635 647 elementsTypeName = typeNamer.mangledNameForType(*nativeFunctionDeclaration.parameters()[index]->type()); 636 648 ++index; 637 649 } 638 StringnumberOfLevelsTypeName;650 Optional<MangledTypeName> numberOfLevelsTypeName; 639 651 if (!textureType.isWritableTexture() && textureType.textureDimension() != 1) { 640 652 numberOfLevelsTypeName = typeNamer.mangledNameForType(*nativeFunctionDeclaration.parameters()[index]->type()); … … 648 660 stringBuilder.append(", uint mipLevel"); 649 661 stringBuilder.flexibleAppend(", ", widthTypeName, " width"); 650 if ( !heightTypeName.isNull())651 stringBuilder.flexibleAppend(", ", heightTypeName, " height");652 if ( !depthTypeName.isNull())653 stringBuilder.flexibleAppend(", ", depthTypeName, " depth");654 if ( !elementsTypeName.isNull())655 stringBuilder.flexibleAppend(", ", elementsTypeName, " elements");656 if ( !numberOfLevelsTypeName.isNull())657 stringBuilder.flexibleAppend(", ", numberOfLevelsTypeName, " numberOfLevels");662 if (heightTypeName) 663 stringBuilder.flexibleAppend(", ", *heightTypeName, " height"); 664 if (depthTypeName) 665 stringBuilder.flexibleAppend(", ", *depthTypeName, " depth"); 666 if (elementsTypeName) 667 stringBuilder.flexibleAppend(", ", *elementsTypeName, " elements"); 668 if (numberOfLevelsTypeName) 669 stringBuilder.flexibleAppend(", ", *numberOfLevelsTypeName, " numberOfLevels"); 658 670 stringBuilder.append( 659 671 ") {\n" … … 664 676 stringBuilder.append("mipLevel"); 665 677 stringBuilder.append(");\n"); 666 if ( !heightTypeName.isNull()) {678 if (heightTypeName) { 667 679 stringBuilder.append( 668 680 " if (height)\n" … … 673 685 stringBuilder.append(");\n"); 674 686 } 675 if ( !depthTypeName.isNull()) {687 if (depthTypeName) { 676 688 stringBuilder.append( 677 689 " if (depth)\n" … … 682 694 stringBuilder.append(");\n"); 683 695 } 684 if ( !elementsTypeName.isNull()) {696 if (elementsTypeName) { 685 697 stringBuilder.append( 686 698 " if (elements)\n" … … 688 700 ); 689 701 } 690 if ( !numberOfLevelsTypeName.isNull()) {702 if (numberOfLevelsTypeName) { 691 703 stringBuilder.append( 692 704 " if (numberOfLevels)\n" -
trunk/Source/WebCore/Modules/webgpu/WHLSL/Metal/WHLSLNativeFunctionWriter.h
r248096 r248266 28 28 #if ENABLE(WEBGPU) 29 29 30 #include <wtf/text/WTFString.h>30 #include "WHLSLMangledNames.h" 31 31 32 32 namespace WebCore { … … 46 46 class TypeNamer; 47 47 48 String writeNativeFunction(AST::NativeFunctionDeclaration&, String&outputFunctionName, Intrinsics&, TypeNamer&);48 String writeNativeFunction(AST::NativeFunctionDeclaration&, MangledFunctionName outputFunctionName, Intrinsics&, TypeNamer&); 49 49 50 50 } -
trunk/Source/WebCore/Modules/webgpu/WHLSL/Metal/WHLSLTypeNamer.cpp
r248025 r248266 62 62 WTF_MAKE_FAST_ALLOCATED; 63 63 public: 64 BaseTypeNameNode(BaseTypeNameNode* parent, String&& mangledName)64 BaseTypeNameNode(BaseTypeNameNode* parent, MangledTypeName&& mangledName) 65 65 : m_parent(parent) 66 66 , m_mangledName(mangledName) … … 78 78 } 79 79 BaseTypeNameNode* parent() { return m_parent; } 80 const String&mangledName() const { return m_mangledName; }80 MangledTypeName mangledName() const { return m_mangledName; } 81 81 82 82 private: 83 83 Vector<UniqueRef<BaseTypeNameNode>> m_children; 84 84 BaseTypeNameNode* m_parent; 85 Stringm_mangledName;85 MangledTypeName m_mangledName; 86 86 }; 87 87 … … 89 89 WTF_MAKE_FAST_ALLOCATED; 90 90 public: 91 ArrayTypeNameNode(BaseTypeNameNode* parent, String&& mangledName, unsigned numElements)91 ArrayTypeNameNode(BaseTypeNameNode* parent, MangledTypeName&& mangledName, unsigned numElements) 92 92 : BaseTypeNameNode(parent, WTFMove(mangledName)) 93 93 , m_numElements(numElements) … … 105 105 WTF_MAKE_FAST_ALLOCATED; 106 106 public: 107 ArrayReferenceTypeNameNode(BaseTypeNameNode* parent, String&& mangledName, AST::AddressSpace addressSpace)107 ArrayReferenceTypeNameNode(BaseTypeNameNode* parent, MangledTypeName&& mangledName, AST::AddressSpace addressSpace) 108 108 : BaseTypeNameNode(parent, WTFMove(mangledName)) 109 109 , m_addressSpace(addressSpace) … … 121 121 WTF_MAKE_FAST_ALLOCATED; 122 122 public: 123 PointerTypeNameNode(BaseTypeNameNode* parent, String&& mangledName, AST::AddressSpace addressSpace)123 PointerTypeNameNode(BaseTypeNameNode* parent, MangledTypeName&& mangledName, AST::AddressSpace addressSpace) 124 124 : BaseTypeNameNode(parent, WTFMove(mangledName)) 125 125 , m_addressSpace(addressSpace) … … 137 137 WTF_MAKE_FAST_ALLOCATED; 138 138 public: 139 ReferenceTypeNameNode(BaseTypeNameNode* parent, String&& mangledName, AST::NamedType& namedType)139 ReferenceTypeNameNode(BaseTypeNameNode* parent, MangledTypeName&& mangledName, AST::NamedType& namedType) 140 140 : BaseTypeNameNode(parent, WTFMove(mangledName)) 141 141 , m_namedType(namedType) … … 355 355 WTF_MAKE_FAST_ALLOCATED; 356 356 public: 357 MetalTypeDeclarationWriter(std::function< String(AST::NamedType&)>&& mangledNameForNamedType)357 MetalTypeDeclarationWriter(std::function<MangledOrNativeTypeName(AST::NamedType&)>&& mangledNameForNamedType) 358 358 : m_mangledNameForNamedType(WTFMove(mangledNameForNamedType)) 359 359 { … … 368 368 } 369 369 370 std::function< String(AST::NamedType&)> m_mangledNameForNamedType;370 std::function<MangledOrNativeTypeName(AST::NamedType&)> m_mangledNameForNamedType; 371 371 StringBuilder m_stringBuilder; 372 372 }; … … 374 374 String TypeNamer::metalTypeDeclarations() 375 375 { 376 MetalTypeDeclarationWriter metalTypeDeclarationWriter([&](AST::NamedType& namedType) -> String{376 MetalTypeDeclarationWriter metalTypeDeclarationWriter([&](AST::NamedType& namedType) -> MangledOrNativeTypeName { 377 377 return mangledNameForType(namedType); 378 378 }); … … 461 461 } 462 462 463 StringTypeNamer::mangledNameForType(AST::UnnamedType& unnamedType)463 MangledTypeName TypeNamer::mangledNameForType(AST::UnnamedType& unnamedType) 464 464 { 465 465 return find(unnamedType, m_trie).mangledName(); 466 466 } 467 467 468 StringTypeNamer::mangledNameForType(AST::NamedType& namedType)468 MangledOrNativeTypeName TypeNamer::mangledNameForType(AST::NamedType& namedType) 469 469 { 470 470 if (is<AST::NativeTypeDeclaration>(namedType)) … … 476 476 477 477 478 StringTypeNamer::mangledNameForEnumerationMember(AST::EnumerationMember& enumerationMember)478 MangledEnumerationMemberName TypeNamer::mangledNameForEnumerationMember(AST::EnumerationMember& enumerationMember) 479 479 { 480 480 auto iterator = m_enumerationMemberMapping.find(&enumerationMember); … … 483 483 } 484 484 485 StringTypeNamer::mangledNameForStructureElement(AST::StructureElement& structureElement)485 MangledStructureElementName TypeNamer::mangledNameForStructureElement(AST::StructureElement& structureElement) 486 486 { 487 487 auto iterator = m_structureElementMapping.find(&structureElement); -
trunk/Source/WebCore/Modules/webgpu/WHLSL/Metal/WHLSLTypeNamer.h
r246875 r248266 28 28 #if ENABLE(WEBGPU) 29 29 30 #include "WHLSLMangledNames.h" 30 31 #include "WHLSLVisitor.h" 31 32 #include <wtf/HashMap.h> 32 #include <wtf/text/StringConcatenate.h>33 #include <wtf/text/StringConcatenateNumbers.h>34 33 #include <wtf/text/WTFString.h> 35 34 … … 65 64 // Must be called after calling metalTypes(). 66 65 String mangledNameForType(AST::NativeTypeDeclaration&); 67 StringmangledNameForType(AST::UnnamedType&);68 StringmangledNameForType(AST::NamedType&);69 StringmangledNameForEnumerationMember(AST::EnumerationMember&);70 StringmangledNameForStructureElement(AST::StructureElement&);66 MangledTypeName mangledNameForType(AST::UnnamedType&); 67 MangledOrNativeTypeName mangledNameForType(AST::NamedType&); 68 MangledEnumerationMemberName mangledNameForEnumerationMember(AST::EnumerationMember&); 69 MangledStructureElementName mangledNameForStructureElement(AST::StructureElement&); 71 70 72 String generateNextTypeName() 73 { 74 return makeString("type", m_typeCount++); 75 } 76 77 String generateNextStructureElementName() 78 { 79 return makeString("structureElement", m_structureElementCount++); 80 } 71 MangledTypeName generateNextTypeName() { return { m_typeCount++ }; } 72 MangledStructureElementName generateNextStructureElementName() { return { m_structureElementCount++ }; } 81 73 82 74 private: … … 89 81 void visit(AST::CallExpression&) override; 90 82 91 String generateNextEnumerationMemberName() 92 { 93 return makeString("enumerationMember", m_enumerationMemberCount++); 94 } 83 MangledEnumerationMemberName generateNextEnumerationMemberName() { return { m_enumerationMemberCount++ }; } 95 84 96 85 void emitNamedTypeDefinition(AST::NamedType&, HashSet<AST::NamedType*>& emittedNamedTypes, HashSet<BaseTypeNameNode*>& emittedUnnamedTypes, StringBuilder&); … … 106 95 Vector<UniqueRef<BaseTypeNameNode>> m_trie; 107 96 HashMap<AST::UnnamedType*, BaseTypeNameNode*> m_unnamedTypeMapping; 108 HashMap<AST::NamedType*, String> m_namedTypeMapping;97 HashMap<AST::NamedType*, MangledTypeName> m_namedTypeMapping; 109 98 HashMap<AST::NamedType*, Vector<std::reference_wrapper<BaseTypeNameNode>>> m_dependencyGraph; 110 HashMap<AST::EnumerationMember*, String> m_enumerationMemberMapping;111 HashMap<AST::StructureElement*, String> m_structureElementMapping;99 HashMap<AST::EnumerationMember*, MangledEnumerationMemberName> m_enumerationMemberMapping; 100 HashMap<AST::StructureElement*, MangledStructureElementName> m_structureElementMapping; 112 101 unsigned m_typeCount { 0 }; 113 102 unsigned m_enumerationMemberCount { 0 }; -
trunk/Source/WebCore/Modules/webgpu/WHLSL/WHLSLPrepare.h
r247834 r248266 29 29 30 30 #include "WHLSLError.h" 31 #include "WHLSLMangledNames.h" 31 32 #include "WHLSLPipelineDescriptor.h" 32 33 #include <wtf/text/WTFString.h> … … 38 39 struct RenderPrepareResult { 39 40 String metalSource; 40 StringmangledVertexEntryPointName;41 StringmangledFragmentEntryPointName;41 Metal::MangledFunctionName mangledVertexEntryPointName; 42 Metal::MangledFunctionName mangledFragmentEntryPointName; 42 43 }; 43 44 Expected<RenderPrepareResult, String> prepare(String& whlslSource, RenderPipelineDescriptor&); … … 51 52 struct ComputePrepareResult { 52 53 String metalSource; 53 StringmangledEntryPointName;54 Metal::MangledFunctionName mangledEntryPointName; 54 55 ComputeDimensions computeDimensions; 55 56 }; -
trunk/Source/WebCore/WebCore.xcodeproj/project.pbxproj
r248200 r248266 9735 9735 7C7941E21C56C29300A4C58E /* DataDetectorsCoreSoftLink.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = DataDetectorsCoreSoftLink.mm; sourceTree = "<group>"; }; 9736 9736 7C7941E31C56C29300A4C58E /* DataDetectorsCoreSoftLink.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = DataDetectorsCoreSoftLink.h; sourceTree = "<group>"; }; 9737 7C7C769C22F67ECD0032BCCD /* WHLSLMangledNames.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLMangledNames.h; sourceTree = "<group>"; }; 9737 9738 7C8139A31ED6281D00CE26E8 /* JSDOMAttribute.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSDOMAttribute.h; sourceTree = "<group>"; }; 9738 9739 7C8139A41ED6281D00CE26E8 /* JSDOMOperation.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSDOMOperation.h; sourceTree = "<group>"; }; … … 17173 17174 1CECB3AF21F2B98400F44542 /* WHLSLFunctionWriter.cpp */, 17174 17175 1CECB3B221F2B98600F44542 /* WHLSLFunctionWriter.h */, 17176 7C7C769C22F67ECD0032BCCD /* WHLSLMangledNames.h */, 17175 17177 1CECB3B521F50AC700F44542 /* WHLSLMetalCodeGenerator.cpp */, 17176 17178 1CECB3B621F50AC700F44542 /* WHLSLMetalCodeGenerator.h */, -
trunk/Source/WebCore/platform/graphics/gpu/cocoa/GPUComputePipelineMetal.mm
r247892 r248266 95 95 // FIXME: https://bugs.webkit.org/show_bug.cgi?id=195771 Once we zero-fill variables, there should be no warnings, so we should be able to ASSERT(!error) here. 96 96 97 computeEntryPoint = whlslCompileResult->mangledEntryPointName ;97 computeEntryPoint = whlslCompileResult->mangledEntryPointName.toString(); 98 98 } else { 99 99 computeLibrary = computeStage.module->platformShaderModule(); -
trunk/Source/WebCore/platform/graphics/gpu/cocoa/GPURenderPipelineMetal.mm
r248078 r248266 412 412 413 413 fragmentLibrary = vertexLibrary; 414 vertexEntryPoint = whlslCompileResult->mangledVertexEntryPointName ;415 fragmentEntryPoint = whlslCompileResult->mangledFragmentEntryPointName ;414 vertexEntryPoint = whlslCompileResult->mangledVertexEntryPointName.toString(); 415 fragmentEntryPoint = whlslCompileResult->mangledFragmentEntryPointName.toString(); 416 416 } else { 417 417 vertexLibrary = vertexStage.module->platformShaderModule();
Note: See TracChangeset
for help on using the changeset viewer.