Changeset 248266 in webkit


Ignore:
Timestamp:
Aug 4, 2019 8:26:33 PM (5 years ago)
Author:
weinig@apple.com
Message:

Mangled WHLSL names don't need to allocate Strings
https://bugs.webkit.org/show_bug.cgi?id=200429

Reviewed by Saam Barati.

To avoid allocating strings for each mangled name used to transform WHLSL to Metal, which we'd
like to avoid since it is both unnecessarily expensive in time and space, we can instead just
store the unique integer identifier that was being used to construct the String.

Since the existing mangled names were all of the form "prefix" + unsigned integer value (where
prefix could be "type", "enumerationMember", "structureElement", "variable" or "function") we
strongly type the integer by storing it in a struct (MangledVariableName, MangledTypeName, etc.)
When the full name is actually needed, StringTypeAdapter's specialized for the structs are
used to write directly into the preallocated buffers of StringBuilders or makeString().

  • Modules/webgpu/WHLSL/Metal/WHLSLMangledNames.h: Added.

(WebCore::WHLSL::Metal::MangledVariableName):
(WebCore::WHLSL::Metal::MangledTypeName):
(WebCore::WHLSL::Metal::MangledStructureElementName):
(WebCore::WHLSL::Metal::MangledEnumerationMemberName):
(WebCore::WHLSL::Metal::MangledFunctionName):
Adds structs for each type of mangled name and StringTypeAdapter specializations for
each to allow their use in StringBuilder.flexibleAppend() or makeString().

Additionally, a Variant, MangledOrNativeTypeName, of MangledTypeName and String is
declared to allow for the few cases where a native type (e.g. float4) is needed. The
StringTypeAdapter for MangledOrNativeTypeName could be generalized for any Variant
in the future, but I left it non-general for now, as it is non-obvious if one would
want to store Variant<Types...>, and have each member function construct a temporary
StringTypeAdapter, or store a Variant<StringTypeAdapter<Types>...> and perform conversion
in the construction.

  • Modules/webgpu/WHLSL/Metal/WHLSLEntryPointScaffolding.cpp:

(WebCore::WHLSL::Metal::EntryPointScaffolding::EntryPointScaffolding):
(WebCore::WHLSL::Metal::internalTypeForSemantic):
(WebCore::WHLSL::Metal::EntryPointScaffolding::builtInsSignature):
(WebCore::WHLSL::Metal::EntryPointScaffolding::mangledInputPath):
(WebCore::WHLSL::Metal::VertexEntryPointScaffolding::VertexEntryPointScaffolding):
(WebCore::WHLSL::Metal::VertexEntryPointScaffolding::signature):
(WebCore::WHLSL::Metal::VertexEntryPointScaffolding::pack):
(WebCore::WHLSL::Metal::FragmentEntryPointScaffolding::FragmentEntryPointScaffolding):
(WebCore::WHLSL::Metal::FragmentEntryPointScaffolding::signature):
(WebCore::WHLSL::Metal::FragmentEntryPointScaffolding::pack):
(WebCore::WHLSL::Metal::ComputeEntryPointScaffolding::ComputeEntryPointScaffolding):
(WebCore::WHLSL::Metal::ComputeEntryPointScaffolding::signature):
(WebCore::WHLSL::Metal::ComputeEntryPointScaffolding::pack):

  • Modules/webgpu/WHLSL/Metal/WHLSLEntryPointScaffolding.h:

(WebCore::WHLSL::Metal::EntryPointScaffolding::parameterVariables):

  • Modules/webgpu/WHLSL/Metal/WHLSLFunctionWriter.cpp:

(WebCore::WHLSL::Metal::FunctionDeclarationWriter::FunctionDeclarationWriter):
(WebCore::WHLSL::Metal::FunctionDeclarationWriter::visit):
(WebCore::WHLSL::Metal::FunctionDefinitionWriter::FunctionDefinitionWriter):
(WebCore::WHLSL::Metal::FunctionDefinitionWriter::generateNextVariableName):
(WebCore::WHLSL::Metal::FunctionDefinitionWriter::appendRightValueWithNullability):
(WebCore::WHLSL::Metal::FunctionDefinitionWriter::appendRightValue):
(WebCore::WHLSL::Metal::FunctionDefinitionWriter::appendLeftValue):
(WebCore::WHLSL::Metal::FunctionDefinitionWriter::takeLastValue):
(WebCore::WHLSL::Metal::FunctionDefinitionWriter::takeLastValueAndNullability):
(WebCore::WHLSL::Metal::FunctionDefinitionWriter::takeLastLeftValue):
(WebCore::WHLSL::Metal::FunctionDefinitionWriter::visit):
(WebCore::WHLSL::Metal::FunctionDefinitionWriter::emitLoop):
(WebCore::WHLSL::Metal::RenderFunctionDefinitionWriter::RenderFunctionDefinitionWriter):
(WebCore::WHLSL::Metal::RenderFunctionDefinitionWriter::createEntryPointScaffolding):
(WebCore::WHLSL::Metal::ComputeFunctionDefinitionWriter::ComputeFunctionDefinitionWriter):
(WebCore::WHLSL::Metal::ComputeFunctionDefinitionWriter::createEntryPointScaffolding):
(WebCore::WHLSL::Metal::sharedMetalFunctions):

  • Modules/webgpu/WHLSL/Metal/WHLSLFunctionWriter.h:
  • Modules/webgpu/WHLSL/Metal/WHLSLMetalCodeGenerator.h:
  • Modules/webgpu/WHLSL/Metal/WHLSLNativeFunctionWriter.cpp:

(WebCore::WHLSL::Metal::writeNativeFunction):

  • Modules/webgpu/WHLSL/Metal/WHLSLNativeFunctionWriter.h:
  • Modules/webgpu/WHLSL/Metal/WHLSLTypeNamer.cpp:

(WebCore::WHLSL::Metal::BaseTypeNameNode::BaseTypeNameNode):
(WebCore::WHLSL::Metal::BaseTypeNameNode::mangledName const):
(WebCore::WHLSL::Metal::ArrayTypeNameNode::ArrayTypeNameNode):
(WebCore::WHLSL::Metal::ArrayReferenceTypeNameNode::ArrayReferenceTypeNameNode):
(WebCore::WHLSL::Metal::PointerTypeNameNode::PointerTypeNameNode):
(WebCore::WHLSL::Metal::ReferenceTypeNameNode::ReferenceTypeNameNode):
(WebCore::WHLSL::Metal::MetalTypeDeclarationWriter::MetalTypeDeclarationWriter):
(WebCore::WHLSL::Metal::TypeNamer::metalTypeDeclarations):
(WebCore::WHLSL::Metal::TypeNamer::emitNamedTypeDefinition):
(WebCore::WHLSL::Metal::TypeNamer::mangledNameForType):
(WebCore::WHLSL::Metal::TypeNamer::mangledNameForEnumerationMember):
(WebCore::WHLSL::Metal::TypeNamer::mangledNameForStructureElement):

  • Modules/webgpu/WHLSL/Metal/WHLSLTypeNamer.h:

(WebCore::WHLSL::Metal::TypeNamer::generateNextTypeName):
(WebCore::WHLSL::Metal::TypeNamer::generateNextStructureElementName):
(WebCore::WHLSL::Metal::TypeNamer::generateNextEnumerationMemberName):

  • Modules/webgpu/WHLSL/WHLSLPrepare.h:

Replace uses of String with the appropriate mangled name type.

  • WebCore.xcodeproj/project.pbxproj:

Add WHLSLMangledNames.h

  • platform/graphics/gpu/cocoa/GPUComputePipelineMetal.mm:

(WebCore::trySetFunctions):

  • platform/graphics/gpu/cocoa/GPURenderPipelineMetal.mm:

(WebCore::trySetFunctions):
Convert the mangled names to Strings for passing to Metal API. NOTE: We could avoid having the
toString() member function on MangledFunctionName if we allowed makeString() to take a single
argument.

Location:
trunk/Source/WebCore
Files:
1 added
14 edited

Legend:

Unmodified
Added
Removed
  • trunk/Source/WebCore/ChangeLog

    r248265 r248266  
     12019-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
    11052019-08-04  Chris Dumez  <cdumez@apple.com>
    2106
  • trunk/Source/WebCore/Modules/webgpu/WHLSL/Metal/WHLSLEntryPointScaffolding.cpp

    r247917 r248266  
    9292}
    9393
    94 EntryPointScaffolding::EntryPointScaffolding(AST::FunctionDefinition& functionDefinition, Intrinsics& intrinsics, TypeNamer& typeNamer, EntryPointItems& entryPointItems, HashMap<Binding*, size_t>& resourceMap, Layout& layout, std::function<String()>&& generateNextVariableName)
     94EntryPointScaffolding::EntryPointScaffolding(AST::FunctionDefinition& functionDefinition, Intrinsics& intrinsics, TypeNamer& typeNamer, EntryPointItems& entryPointItems, HashMap<Binding*, size_t>& resourceMap, Layout& layout, std::function<MangledVariableName()>&& generateNextVariableName)
    9595    : m_functionDefinition(functionDefinition)
    9696    , m_intrinsics(intrinsics)
     
    193193}
    194194
    195 static String internalTypeForSemantic(const AST::BuiltInSemantic& builtInSemantic)
     195static StringView internalTypeForSemantic(const AST::BuiltInSemantic& builtInSemantic)
    196196{
    197197    switch (builtInSemantic.variable()) {
    198198    case AST::BuiltInSemantic::Variable::SVInstanceID:
    199         return "uint"_str;
     199        return "uint";
    200200    case AST::BuiltInSemantic::Variable::SVVertexID:
    201         return "uint"_str;
     201        return "uint";
    202202    case AST::BuiltInSemantic::Variable::PSize:
    203         return "float"_str;
     203        return "float";
    204204    case AST::BuiltInSemantic::Variable::SVPosition:
    205         return "float4"_str;
     205        return "float4";
    206206    case AST::BuiltInSemantic::Variable::SVIsFrontFace:
    207         return "bool"_str;
     207        return "bool";
    208208    case AST::BuiltInSemantic::Variable::SVSampleIndex:
    209         return "uint"_str;
     209        return "uint";
    210210    case AST::BuiltInSemantic::Variable::SVInnerCoverage:
    211         return "uint"_str;
     211        return "uint";
    212212    case AST::BuiltInSemantic::Variable::SVTarget:
    213         return String();
     213        return { };
    214214    case AST::BuiltInSemantic::Variable::SVDepth:
    215         return "float"_str;
     215        return "float";
    216216    case AST::BuiltInSemantic::Variable::SVCoverage:
    217         return "uint"_str;
     217        return "uint";
    218218    case AST::BuiltInSemantic::Variable::SVDispatchThreadID:
    219         return "uint3"_str;
     219        return "uint3";
    220220    case AST::BuiltInSemantic::Variable::SVGroupID:
    221         return "uint3"_str;
     221        return "uint3";
    222222    case AST::BuiltInSemantic::Variable::SVGroupIndex:
    223         return "uint"_str;
     223        return "uint";
    224224    default:
    225225        ASSERT(builtInSemantic.variable() == AST::BuiltInSemantic::Variable::SVGroupThreadID);
    226         return "uint3"_str;
     226        return "uint3";
    227227    }
    228228}
     
    241241        auto& builtInSemantic = WTF::get<AST::BuiltInSemantic>(*item.semantic);
    242242        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));
    247248    }
    248249    return stringBuilder.toString();
     
    257258    for (size_t i = 0; i < m_functionDefinition.parameters().size(); ++i) {
    258259        if (m_functionDefinition.parameters()[i]->name() == path[0]) {
    259             stringBuilder.append(m_parameterVariables[i]);
     260            stringBuilder.flexibleAppend(m_parameterVariables[i]);
    260261            auto& unifyNode = m_functionDefinition.parameters()[i]->type()->unifyNode();
    261262            if (is<AST::NamedType>(unifyNode)) {
     
    357358}
    358359
    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)
     360VertexEntryPointScaffolding::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)
    360361    : EntryPointScaffolding(functionDefinition, intrinsics, typeNamer, entryPointItems, resourceMap, layout, WTFMove(generateNextVariableName))
    361362    , m_matchedVertexAttributes(matchedVertexAttributes)
     
    378379        NamedOutput namedOutput;
    379380        namedOutput.elementName = m_typeNamer.generateNextStructureElementName();
     381        StringView internalType;
    380382        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
    383387            namedOutput.internalTypeName = m_typeNamer.mangledNameForType(*outputItem.unnamedType);
    384388        m_namedOutputs.uncheckedAppend(WTFMove(namedOutput));
     
    416420}
    417421
    418 String VertexEntryPointScaffolding::signature(String& functionName)
     422String VertexEntryPointScaffolding::signature(MangledFunctionName functionName)
    419423{
    420424    StringBuilder stringBuilder;
     
    445449}
    446450
    447 String VertexEntryPointScaffolding::pack(const String& inputVariableName, const String& outputVariableName)
     451String VertexEntryPointScaffolding::pack(MangledVariableName inputVariableName, MangledVariableName outputVariableName)
    448452{
    449453    StringBuilder stringBuilder;
     
    464468}
    465469
    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>&)
     470FragmentEntryPointScaffolding::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>&)
    467471    : EntryPointScaffolding(functionDefinition, intrinsics, typeNamer, entryPointItems, resourceMap, layout, WTFMove(generateNextVariableName))
    468472    , m_stageInStructName(typeNamer.generateNextTypeName())
     
    487491        NamedOutput namedOutput;
    488492        namedOutput.elementName = m_typeNamer.generateNextStructureElementName();
     493        StringView internalType;
    489494        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
    492499            namedOutput.internalTypeName = m_typeNamer.mangledNameForType(*outputItem.unnamedType);
    493500        m_namedOutputs.uncheckedAppend(WTFMove(namedOutput));
     
    525532}
    526533
    527 String FragmentEntryPointScaffolding::signature(String& functionName)
     534String FragmentEntryPointScaffolding::signature(MangledFunctionName functionName)
    528535{
    529536    StringBuilder stringBuilder;
     
    554561}
    555562
    556 String FragmentEntryPointScaffolding::pack(const String& inputVariableName, const String& outputVariableName)
     563String FragmentEntryPointScaffolding::pack(MangledVariableName inputVariableName, MangledVariableName outputVariableName)
    557564{
    558565    StringBuilder stringBuilder;
     
    573580}
    574581
    575 ComputeEntryPointScaffolding::ComputeEntryPointScaffolding(AST::FunctionDefinition& functionDefinition, Intrinsics& intrinsics, TypeNamer& typeNamer, EntryPointItems& entryPointItems, HashMap<Binding*, size_t>& resourceMap, Layout& layout, std::function<String()>&& generateNextVariableName)
     582ComputeEntryPointScaffolding::ComputeEntryPointScaffolding(AST::FunctionDefinition& functionDefinition, Intrinsics& intrinsics, TypeNamer& typeNamer, EntryPointItems& entryPointItems, HashMap<Binding*, size_t>& resourceMap, Layout& layout, std::function<MangledVariableName()>&& generateNextVariableName)
    576583    : EntryPointScaffolding(functionDefinition, intrinsics, typeNamer, entryPointItems, resourceMap, layout, WTFMove(generateNextVariableName))
    577584{
     
    583590}
    584591
    585 String ComputeEntryPointScaffolding::signature(String& functionName)
     592String ComputeEntryPointScaffolding::signature(MangledFunctionName functionName)
    586593{
    587594    StringBuilder stringBuilder;
     
    608615}
    609616
    610 String ComputeEntryPointScaffolding::pack(const String&, const String&)
     617String ComputeEntryPointScaffolding::pack(MangledVariableName, MangledVariableName)
    611618{
    612619    ASSERT_NOT_REACHED();
  • trunk/Source/WebCore/Modules/webgpu/WHLSL/Metal/WHLSLEntryPointScaffolding.h

    r246427 r248266  
    2828#if ENABLE(WEBGPU)
    2929
     30#include "WHLSLMangledNames.h"
    3031#include "WHLSLPipelineDescriptor.h"
    3132#include <wtf/HashMap.h>
     
    5152class EntryPointScaffolding {
    5253public:
    53     EntryPointScaffolding(AST::FunctionDefinition&, Intrinsics&, TypeNamer&, EntryPointItems&, HashMap<Binding*, size_t>& resourceMap, Layout&, std::function<String()>&& generateNextVariableName);
    5454    virtual ~EntryPointScaffolding() = default;
    5555
    5656    virtual String helperTypes() = 0;
    57     virtual String signature(String& functionName) = 0;
     57    virtual String signature(MangledFunctionName) = 0;
    5858    virtual String unpack() = 0;
    59     virtual String pack(const String& existingVariableName, const String& variableName) = 0;
     59    virtual String pack(MangledVariableName existingVariableName, MangledVariableName) = 0;
    6060
    61     Vector<String>& parameterVariables() { return m_parameterVariables; }
     61    Vector<MangledVariableName>& parameterVariables() { return m_parameterVariables; }
    6262
    6363protected:
     64    EntryPointScaffolding(AST::FunctionDefinition&, Intrinsics&, TypeNamer&, EntryPointItems&, HashMap<Binding*, size_t>& resourceMap, Layout&, std::function<MangledVariableName()>&& generateNextVariableName);
     65
    6466    String resourceHelperTypes();
    6567    Optional<String> resourceSignature();
     
    7678    HashMap<Binding*, size_t>& m_resourceMap;
    7779    Layout& m_layout;
    78     std::function<String()> m_generateNextVariableName;
     80    std::function<MangledVariableName()> m_generateNextVariableName;
    7981
    8082    struct LengthInformation {
    81         String elementName;
    82         String temporaryName;
     83        MangledStructureElementName elementName;
     84        MangledVariableName temporaryName;
    8385        unsigned index;
    8486    };
    8587    struct NamedBinding {
    86         String elementName;
     88        MangledStructureElementName elementName;
    8789        unsigned index;
    8890        Optional<LengthInformation> lengthInformation;
    8991    };
    9092    struct NamedBindGroup {
    91         String structName;
    92         String variableName;
     93        MangledTypeName structName;
     94        MangledVariableName variableName;
    9395        Vector<NamedBinding> namedBindings;
    9496        unsigned argumentBufferIndex;
     
    98100    struct NamedBuiltIn {
    99101        size_t indexInEntryPointItems;
    100         String variableName;
     102        MangledVariableName variableName;
    101103    };
    102104    Vector<NamedBuiltIn> m_namedBuiltIns;
    103105
    104     Vector<String> m_parameterVariables;
     106    Vector<MangledVariableName> m_parameterVariables;
    105107};
    106108
    107109class VertexEntryPointScaffolding : public EntryPointScaffolding {
    108110public:
    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);
    110112    virtual ~VertexEntryPointScaffolding() = default;
    111113
    112114    String helperTypes() override;
    113     String signature(String& functionName) override;
     115    String signature(MangledFunctionName) override;
    114116    String unpack() override;
    115     String pack(const String& existingVariableName, const String& variableName) override;
     117    String pack(MangledVariableName existingVariableName, MangledVariableName) override;
    116118
    117119private:
    118120    HashMap<VertexAttribute*, size_t>& m_matchedVertexAttributes;
    119     String m_stageInStructName;
    120     String m_returnStructName;
    121     String m_stageInParameterName;
     121    MangledTypeName m_stageInStructName;
     122    MangledTypeName m_returnStructName;
     123    MangledVariableName m_stageInParameterName;
    122124
    123125    struct NamedStageIn {
    124126        size_t indexInEntryPointItems;
    125         String elementName;
     127        MangledStructureElementName elementName;
    126128        unsigned attributeIndex;
    127129    };
     
    129131
    130132    struct NamedOutput {
    131         String elementName;
    132         String internalTypeName;
     133        MangledStructureElementName elementName;
     134        MangledOrNativeTypeName internalTypeName;
    133135    };
    134136    Vector<NamedOutput> m_namedOutputs;
     
    137139class FragmentEntryPointScaffolding : public EntryPointScaffolding {
    138140public:
    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);
    140142    virtual ~FragmentEntryPointScaffolding() = default;
    141143
    142144    String helperTypes() override;
    143     String signature(String& functionName) override;
     145    String signature(MangledFunctionName) override;
    144146    String unpack() override;
    145     String pack(const String& existingVariableName, const String& variableName) override;
     147    String pack(MangledVariableName existingVariableName, MangledVariableName) override;
    146148
    147149private:
    148     String m_stageInStructName;
    149     String m_returnStructName;
    150     String m_stageInParameterName;
     150    MangledTypeName m_stageInStructName;
     151    MangledTypeName m_returnStructName;
     152    MangledVariableName m_stageInParameterName;
    151153
    152154    struct NamedStageIn {
    153155        size_t indexInEntryPointItems;
    154         String elementName;
     156        MangledStructureElementName elementName;
    155157        unsigned attributeIndex;
    156158    };
     
    158160
    159161    struct NamedOutput {
    160         String elementName;
    161         String internalTypeName;
     162        MangledStructureElementName elementName;
     163        MangledOrNativeTypeName internalTypeName;
    162164    };
    163165    Vector<NamedOutput> m_namedOutputs;
     
    166168class ComputeEntryPointScaffolding : public EntryPointScaffolding {
    167169public:
    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);
    169171    virtual ~ComputeEntryPointScaffolding() = default;
    170172
    171173    String helperTypes() override;
    172     String signature(String& functionName) override;
     174    String signature(MangledFunctionName) override;
    173175    String unpack() override;
    174     String pack(const String& existingVariableName, const String& variableName) override;
    175 
    176 private:
     176    String pack(MangledVariableName existingVariableName, MangledVariableName) override;
    177177};
    178178
  • trunk/Source/WebCore/Modules/webgpu/WHLSL/Metal/WHLSLFunctionWriter.cpp

    r248141 r248266  
    5050class FunctionDeclarationWriter : public Visitor {
    5151public:
    52     FunctionDeclarationWriter(TypeNamer& typeNamer, HashMap<AST::FunctionDeclaration*, String>& functionMapping)
     52    FunctionDeclarationWriter(TypeNamer& typeNamer, HashMap<AST::FunctionDeclaration*, MangledFunctionName>& functionMapping)
    5353        : m_typeNamer(typeNamer)
    5454        , m_functionMapping(functionMapping)
     
    6464private:
    6565    TypeNamer& m_typeNamer;
    66     HashMap<AST::FunctionDeclaration*, String>& m_functionMapping;
     66    HashMap<AST::FunctionDeclaration*, MangledFunctionName>& m_functionMapping;
    6767    StringBuilder m_stringBuilder;
    6868};
     
    7979        if (i)
    8080            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()));
    8282    }
    8383    m_stringBuilder.append(");\n");
     
    8686class FunctionDefinitionWriter : public Visitor {
    8787public:
    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)
    8989        : m_intrinsics(intrinsics)
    9090        , m_typeNamer(typeNamer)
     
    151151    String constantExpressionString(AST::ConstantExpression&);
    152152
    153     String generateNextVariableName()
    154     {
    155         return makeString("variable", m_variableCount++);
    156     }
     153    MangledVariableName generateNextVariableName() { return { m_variableCount++ }; }
    157154
    158155    enum class Nullability : uint8_t {
     
    162159
    163160    struct StackItem {
    164         String value;
    165         String leftValue;
     161        MangledVariableName value;
     162        Optional<MangledVariableName> leftValue;
    166163        Nullability valueNullability;
    167164        Nullability leftValueNullability;
     
    169166
    170167    struct StackValue {
    171         String value;
     168        MangledVariableName value;
    172169        Nullability nullability;
    173170    };
     
    178175    // non-null, and DereferenceExpression will take a non-null rvalue and try to produce
    179176    // a non-null lvalue.
    180     void appendRightValueWithNullability(AST::Expression&, String value, Nullability nullability)
    181     {
    182         m_stack.append({ WTFMove(value), String(), nullability, Nullability::CanBeNull });
    183     }
    184 
    185     void appendRightValue(AST::Expression& expression, String value)
     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)
    186183    {
    187184        appendRightValueWithNullability(expression, WTFMove(value), Nullability::CanBeNull);
    188185    }
    189186
    190     void appendLeftValue(AST::Expression& expression, String value, String leftValue, Nullability nullability)
     187    void appendLeftValue(AST::Expression& expression, MangledVariableName value, MangledVariableName leftValue, Nullability nullability)
    191188    {
    192189        ASSERT_UNUSED(expression, expression.typeAnnotation().leftAddressSpace());
     
    194191    }
    195192
    196     String takeLastValue()
    197     {
    198         ASSERT(m_stack.last().value);
     193    MangledVariableName takeLastValue()
     194    {
    199195        return m_stack.takeLast().value;
    200196    }
     
    202198    StackValue takeLastValueAndNullability()
    203199    {
    204         ASSERT(m_stack.last().value);
    205200        auto last = m_stack.takeLast();
    206201        return { last.value, last.valueNullability };
     
    211206        ASSERT(m_stack.last().leftValue);
    212207        auto last = m_stack.takeLast();
    213         return { last.leftValue, last.leftValueNullability };
     208        return { *last.leftValue, last.leftValueNullability };
    214209    }
    215210
     
    223218    Intrinsics& m_intrinsics;
    224219    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;
    227222    StringBuilder m_stringBuilder;
    228223
     
    231226    Layout& m_layout;
    232227    unsigned m_variableCount { 0 };
    233     String m_breakOutOfCurrentLoopEarlyVariable;
     228    Optional<MangledVariableName> m_breakOutOfCurrentLoopEarlyVariable;
    234229};
    235230
     
    308303        break;
    309304    case BreakContext::Loop:
    310         ASSERT(m_breakOutOfCurrentLoopEarlyVariable.length());
     305        ASSERT(m_breakOutOfCurrentLoopEarlyVariable);
    311306        m_stringBuilder.flexibleAppend(
    312             m_breakOutOfCurrentLoopEarlyVariable, " = true;\n"
     307            *m_breakOutOfCurrentLoopEarlyVariable, " = true;\n"
    313308            "break;\n"
    314309        );
     
    319314void FunctionDefinitionWriter::visit(AST::Continue&)
    320315{
    321     ASSERT(m_breakOutOfCurrentLoopEarlyVariable.length());
     316    ASSERT(m_breakOutOfCurrentLoopEarlyVariable);
    322317    m_stringBuilder.append("break;\n");
    323318}
     
    336331void FunctionDefinitionWriter::emitLoop(LoopConditionLocation loopConditionLocation, AST::Expression* conditionExpression, AST::Expression* increment, AST::Statement& body)
    337332{
    338     SetForScope<String> loopVariableScope(m_breakOutOfCurrentLoopEarlyVariable, generateNextVariableName());
     333    SetForScope<Optional<MangledVariableName>> loopVariableScope(m_breakOutOfCurrentLoopEarlyVariable, generateNextVariableName());
    339334
    340335    m_stringBuilder.flexibleAppend(
    341         "bool ", m_breakOutOfCurrentLoopEarlyVariable, " = false;\n",
     336        "bool ", *m_breakOutOfCurrentLoopEarlyVariable, " = false;\n",
    342337        "while (true) {\n"
    343338    );
     
    353348    m_stringBuilder.flexibleAppend(
    354349        "} while(false); \n"
    355         "if (", m_breakOutOfCurrentLoopEarlyVariable, ") break;\n"
     350        "if (", *m_breakOutOfCurrentLoopEarlyVariable, ") break;\n"
    356351    );
    357352
     
    517512    // FIXME: https://bugs.webkit.org/show_bug.cgi?id=195788 Replace this with ASSERT_NOT_REACHED().
    518513    notImplemented();
    519     appendRightValue(dotExpression, "dummy");
     514    appendRightValue(dotExpression, generateNextVariableName());
    520515}
    521516
     
    538533    // FIXME: https://bugs.webkit.org/show_bug.cgi?id=195788 Replace this with ASSERT_NOT_REACHED().
    539534    notImplemented();
    540     appendRightValue(indexExpression, "dummy");
     535    appendRightValue(indexExpression, generateNextVariableName());
    541536}
    542537
     
    546541    // FIXME: https://bugs.webkit.org/show_bug.cgi?id=195788 Replace this with ASSERT_NOT_REACHED().
    547542    notImplemented();
    548     appendRightValue(propertyAccessExpression, "dummy");
     543    appendRightValue(propertyAccessExpression, generateNextVariableName());
    549544}
    550545
     
    578573void FunctionDefinitionWriter::visit(AST::CallExpression& callExpression)
    579574{
    580     Vector<String> argumentNames;
     575    Vector<MangledVariableName> argumentNames;
    581576    for (auto& argument : callExpression.arguments()) {
    582577        checkErrorAndVisit(argument);
     
    592587        if (i)
    593588            m_stringBuilder.append(", ");
    594         m_stringBuilder.append(argumentNames[i]);
     589        m_stringBuilder.flexibleAppend(argumentNames[i]);
    595590    }
    596591    m_stringBuilder.append(");\n");
     
    600595void FunctionDefinitionWriter::visit(AST::CommaExpression& commaExpression)
    601596{
    602     String result;
     597    Optional<MangledVariableName> result;
    603598    for (auto& expression : commaExpression.list()) {
    604599        checkErrorAndVisit(expression);
    605600        result = takeLastValue();
    606601    }
    607     appendRightValue(commaExpression, result);
     602    ASSERT(result);
     603    appendRightValue(commaExpression, *result);
    608604}
    609605
     
    751747class RenderFunctionDefinitionWriter : public FunctionDefinitionWriter {
    752748public:
    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)
    754750        : FunctionDefinitionWriter(intrinsics, typeNamer, functionMapping, layout)
    755751        , m_matchedSemantics(WTFMove(matchedSemantics))
     
    765761std::unique_ptr<EntryPointScaffolding> RenderFunctionDefinitionWriter::createEntryPointScaffolding(AST::FunctionDefinition& functionDefinition)
    766762{
    767     auto generateNextVariableName = [this]() -> String {
     763    auto generateNextVariableName = [this]() -> MangledVariableName {
    768764        return this->generateNextVariableName();
    769765    };
     
    777773class ComputeFunctionDefinitionWriter : public FunctionDefinitionWriter {
    778774public:
    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)
    780776        : FunctionDefinitionWriter(intrinsics, typeNamer, functionMapping, layout)
    781777        , m_matchedSemantics(WTFMove(matchedSemantics))
     
    791787std::unique_ptr<EntryPointScaffolding> ComputeFunctionDefinitionWriter::createEntryPointScaffolding(AST::FunctionDefinition& functionDefinition)
    792788{
    793     auto generateNextVariableName = [this]() -> String {
     789    auto generateNextVariableName = [this]() -> MangledVariableName {
    794790        return this->generateNextVariableName();
    795791    };
     
    800796
    801797struct SharedMetalFunctionsResult {
    802     HashMap<AST::FunctionDeclaration*, String> functionMapping;
     798    HashMap<AST::FunctionDeclaration*, MangledFunctionName> functionMapping;
    803799    String metalFunctions;
    804800};
     
    808804
    809805    unsigned numFunctions = 0;
    810     HashMap<AST::FunctionDeclaration*, String> functionMapping;
     806    HashMap<AST::FunctionDeclaration*, MangledFunctionName> functionMapping;
    811807    for (auto& nativeFunctionDeclaration : program.nativeFunctionDeclarations()) {
    812         auto addResult = functionMapping.add(&nativeFunctionDeclaration, makeString("function", numFunctions++));
     808        auto addResult = functionMapping.add(&nativeFunctionDeclaration, MangledFunctionName { numFunctions++ });
    813809        ASSERT_UNUSED(addResult, addResult.isNewEntry);
    814810    }
    815811    for (auto& functionDefinition : program.functionDefinitions()) {
    816         auto addResult = functionMapping.add(&functionDefinition, makeString("function", numFunctions++));
     812        auto addResult = functionMapping.add(&functionDefinition, MangledFunctionName { numFunctions++ });
    817813        ASSERT_UNUSED(addResult, addResult.isNewEntry);
    818814    }
  • trunk/Source/WebCore/Modules/webgpu/WHLSL/Metal/WHLSLFunctionWriter.h

    r243091 r248266  
    2828#if ENABLE(WEBGPU)
    2929
     30#include "WHLSLMangledNames.h"
    3031#include "WHLSLSemanticMatcher.h"
    3132
     
    4243struct RenderMetalFunctions {
    4344    String metalSource;
    44     String mangledVertexEntryPointName;
    45     String mangledFragmentEntryPointName;
     45    MangledFunctionName mangledVertexEntryPointName;
     46    MangledFunctionName mangledFragmentEntryPointName;
    4647};
    4748RenderMetalFunctions metalFunctions(Program&, TypeNamer&, MatchedRenderSemantics&&, Layout&);
     
    4950struct ComputeMetalFunctions {
    5051    String metalSource;
    51     String mangledEntryPointName;
     52    MangledFunctionName mangledEntryPointName;
    5253};
    5354ComputeMetalFunctions metalFunctions(Program&, TypeNamer&, MatchedComputeSemantics&&, Layout&);
  • trunk/Source/WebCore/Modules/webgpu/WHLSL/Metal/WHLSLMetalCodeGenerator.h

    r243091 r248266  
    2828#if ENABLE(WEBGPU)
    2929
     30#include "WHLSLMangledNames.h"
    3031#include "WHLSLPipelineDescriptor.h"
    3132#include "WHLSLSemanticMatcher.h"
     
    4344struct RenderMetalCode {
    4445    String metalSource;
    45     String mangledVertexEntryPointName;
    46     String mangledFragmentEntryPointName;
     46    MangledFunctionName mangledVertexEntryPointName;
     47    MangledFunctionName mangledFragmentEntryPointName;
    4748};
    4849// Can't fail. Any failure checks need to be done earlier, in the backend-agnostic part of the compiler.
     
    5152struct ComputeMetalCode {
    5253    String metalSource;
    53     String mangledEntryPointName;
     54    MangledFunctionName mangledEntryPointName;
    5455};
    5556// 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  
    121121}
    122122
    123 String writeNativeFunction(AST::NativeFunctionDeclaration& nativeFunctionDeclaration, String& outputFunctionName, Intrinsics& intrinsics, TypeNamer& typeNamer)
     123String writeNativeFunction(AST::NativeFunctionDeclaration& nativeFunctionDeclaration, MangledFunctionName outputFunctionName, Intrinsics& intrinsics, TypeNamer& typeNamer)
    124124{
    125125    StringBuilder stringBuilder;
     
    206206
    207207    if (nativeFunctionDeclaration.name().startsWith("operator."_str)) {
    208         auto mangledFieldName = [&](const String& fieldName) -> String {
     208        auto appendMangledFieldName = [&](StringBuilder& stringBuilder, const String& fieldName) {
    209209            auto& unifyNode = nativeFunctionDeclaration.parameters()[0]->type()->unifyNode();
    210210            auto& namedType = downcast<AST::NamedType>(unifyNode);
     
    213213                auto* structureElement = structureDefinition.find(fieldName);
    214214                ASSERT(structureElement);
    215                 return typeNamer.mangledNameForStructureElement(*structureElement);
     215                stringBuilder.flexibleAppend(typeNamer.mangledNameForStructureElement(*structureElement));
     216                return;
    216217            }
    217218            ASSERT(is<AST::NativeTypeDeclaration>(namedType));
    218             return fieldName;
     219            stringBuilder.append(fieldName);
    219220        };
    220221
     
    224225            auto metalParameter2Name = typeNamer.mangledNameForType(*nativeFunctionDeclaration.parameters()[1]->type());
    225226            auto metalReturnName = typeNamer.mangledNameForType(nativeFunctionDeclaration.type());
     227            stringBuilder.flexibleAppend(
     228                metalReturnName, ' ', outputFunctionName, '(', metalParameter1Name, " v, ", metalParameter2Name, " n) {\n"
     229                "    v."
     230            );
     231
    226232            auto fieldName = nativeFunctionDeclaration.name().substring("operator."_str.length());
    227233            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"
    232237                "    return v;\n"
    233238                "}\n"
     
    237242
    238243        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
    239251        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"
    246255            "}\n"
    247256        );
     
    253262        auto metalParameterName = typeNamer.mangledNameForType(*nativeFunctionDeclaration.parameters()[0]->type());
    254263        auto metalReturnName = typeNamer.mangledNameForType(nativeFunctionDeclaration.type());
     264
     265        stringBuilder.flexibleAppend(
     266            metalReturnName, ' ', outputFunctionName, '(', metalParameterName, " v) {\n"
     267            "    return &(v->"
     268        );
     269
    255270        auto fieldName = nativeFunctionDeclaration.name().substring("operator&."_str.length());
    256 
    257         String metalFieldName;
    258271        auto& unnamedType = *nativeFunctionDeclaration.parameters()[0]->type();
    259272        auto& unifyNode = downcast<AST::PointerType>(unnamedType).elementType().unifyNode();
     
    263276            auto* structureElement = structureDefinition.find(fieldName);
    264277            ASSERT(structureElement);
    265             metalFieldName = typeNamer.mangledNameForStructureElement(*structureElement);
     278            stringBuilder.flexibleAppend(typeNamer.mangledNameForStructureElement(*structureElement));
    266279        } 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"
    272284            "}\n"
    273285        );
     
    513525        auto metalParameter2Name = typeNamer.mangledNameForType(*nativeFunctionDeclaration.parameters()[1]->type());
    514526        auto metalParameter3Name = typeNamer.mangledNameForType(locationType);
    515         String metalParameter4Name;
     527        Optional<MangledTypeName> metalParameter4Name;
    516528        if (nativeFunctionDeclaration.parameters().size() == 4)
    517529            metalParameter4Name = typeNamer.mangledNameForType(*nativeFunctionDeclaration.parameters()[3]->type());
    518530        auto metalReturnName = typeNamer.mangledNameForType(returnType);
    519531        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");
    522534        stringBuilder.append(
    523535            ") {\n"
     
    529541        } else
    530542            stringBuilder.append("location");
    531         if (!metalParameter4Name.isNull())
     543        if (metalParameter4Name)
    532544            stringBuilder.append(", offset");
    533545        stringBuilder.append(")");
     
    621633        auto widthTypeName = typeNamer.mangledNameForType(*nativeFunctionDeclaration.parameters()[index]->type());
    622634        ++index;
    623         String heightTypeName;
     635        Optional<MangledTypeName> heightTypeName;
    624636        if (textureType.textureDimension() >= 2) {
    625637            heightTypeName = typeNamer.mangledNameForType(*nativeFunctionDeclaration.parameters()[index]->type());
    626638            ++index;
    627639        }
    628         String depthTypeName;
     640        Optional<MangledTypeName> depthTypeName;
    629641        if (textureType.textureDimension() >= 3) {
    630642            depthTypeName = typeNamer.mangledNameForType(*nativeFunctionDeclaration.parameters()[index]->type());
    631643            ++index;
    632644        }
    633         String elementsTypeName;
     645        Optional<MangledTypeName> elementsTypeName;
    634646        if (textureType.isTextureArray()) {
    635647            elementsTypeName = typeNamer.mangledNameForType(*nativeFunctionDeclaration.parameters()[index]->type());
    636648            ++index;
    637649        }
    638         String numberOfLevelsTypeName;
     650        Optional<MangledTypeName> numberOfLevelsTypeName;
    639651        if (!textureType.isWritableTexture() && textureType.textureDimension() != 1) {
    640652            numberOfLevelsTypeName = typeNamer.mangledNameForType(*nativeFunctionDeclaration.parameters()[index]->type());
     
    648660            stringBuilder.append(", uint mipLevel");
    649661        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");
    658670        stringBuilder.append(
    659671            ") {\n"
     
    664676            stringBuilder.append("mipLevel");
    665677        stringBuilder.append(");\n");
    666         if (!heightTypeName.isNull()) {
     678        if (heightTypeName) {
    667679            stringBuilder.append(
    668680                "    if (height)\n"
     
    673685            stringBuilder.append(");\n");
    674686        }
    675         if (!depthTypeName.isNull()) {
     687        if (depthTypeName) {
    676688            stringBuilder.append(
    677689                "    if (depth)\n"
     
    682694            stringBuilder.append(");\n");
    683695        }
    684         if (!elementsTypeName.isNull()) {
     696        if (elementsTypeName) {
    685697            stringBuilder.append(
    686698                "    if (elements)\n"
     
    688700            );
    689701        }
    690         if (!numberOfLevelsTypeName.isNull()) {
     702        if (numberOfLevelsTypeName) {
    691703            stringBuilder.append(
    692704                "    if (numberOfLevels)\n"
  • trunk/Source/WebCore/Modules/webgpu/WHLSL/Metal/WHLSLNativeFunctionWriter.h

    r248096 r248266  
    2828#if ENABLE(WEBGPU)
    2929
    30 #include <wtf/text/WTFString.h>
     30#include "WHLSLMangledNames.h"
    3131
    3232namespace WebCore {
     
    4646class TypeNamer;
    4747
    48 String writeNativeFunction(AST::NativeFunctionDeclaration&, String& outputFunctionName, Intrinsics&, TypeNamer&);
     48String writeNativeFunction(AST::NativeFunctionDeclaration&, MangledFunctionName outputFunctionName, Intrinsics&, TypeNamer&);
    4949
    5050}
  • trunk/Source/WebCore/Modules/webgpu/WHLSL/Metal/WHLSLTypeNamer.cpp

    r248025 r248266  
    6262    WTF_MAKE_FAST_ALLOCATED;
    6363public:
    64     BaseTypeNameNode(BaseTypeNameNode* parent, String&& mangledName)
     64    BaseTypeNameNode(BaseTypeNameNode* parent, MangledTypeName&& mangledName)
    6565        : m_parent(parent)
    6666        , m_mangledName(mangledName)
     
    7878    }
    7979    BaseTypeNameNode* parent() { return m_parent; }
    80     const String& mangledName() const { return m_mangledName; }
     80    MangledTypeName mangledName() const { return m_mangledName; }
    8181
    8282private:
    8383    Vector<UniqueRef<BaseTypeNameNode>> m_children;
    8484    BaseTypeNameNode* m_parent;
    85     String m_mangledName;
     85    MangledTypeName m_mangledName;
    8686};
    8787
     
    8989    WTF_MAKE_FAST_ALLOCATED;
    9090public:
    91     ArrayTypeNameNode(BaseTypeNameNode* parent, String&& mangledName, unsigned numElements)
     91    ArrayTypeNameNode(BaseTypeNameNode* parent, MangledTypeName&& mangledName, unsigned numElements)
    9292        : BaseTypeNameNode(parent, WTFMove(mangledName))
    9393        , m_numElements(numElements)
     
    105105    WTF_MAKE_FAST_ALLOCATED;
    106106public:
    107     ArrayReferenceTypeNameNode(BaseTypeNameNode* parent, String&& mangledName, AST::AddressSpace addressSpace)
     107    ArrayReferenceTypeNameNode(BaseTypeNameNode* parent, MangledTypeName&& mangledName, AST::AddressSpace addressSpace)
    108108        : BaseTypeNameNode(parent, WTFMove(mangledName))
    109109        , m_addressSpace(addressSpace)
     
    121121    WTF_MAKE_FAST_ALLOCATED;
    122122public:
    123     PointerTypeNameNode(BaseTypeNameNode* parent, String&& mangledName, AST::AddressSpace addressSpace)
     123    PointerTypeNameNode(BaseTypeNameNode* parent, MangledTypeName&& mangledName, AST::AddressSpace addressSpace)
    124124        : BaseTypeNameNode(parent, WTFMove(mangledName))
    125125        , m_addressSpace(addressSpace)
     
    137137    WTF_MAKE_FAST_ALLOCATED;
    138138public:
    139     ReferenceTypeNameNode(BaseTypeNameNode* parent, String&& mangledName, AST::NamedType& namedType)
     139    ReferenceTypeNameNode(BaseTypeNameNode* parent, MangledTypeName&& mangledName, AST::NamedType& namedType)
    140140        : BaseTypeNameNode(parent, WTFMove(mangledName))
    141141        , m_namedType(namedType)
     
    355355    WTF_MAKE_FAST_ALLOCATED;
    356356public:
    357     MetalTypeDeclarationWriter(std::function<String(AST::NamedType&)>&& mangledNameForNamedType)
     357    MetalTypeDeclarationWriter(std::function<MangledOrNativeTypeName(AST::NamedType&)>&& mangledNameForNamedType)
    358358        : m_mangledNameForNamedType(WTFMove(mangledNameForNamedType))
    359359    {
     
    368368    }
    369369
    370     std::function<String(AST::NamedType&)> m_mangledNameForNamedType;
     370    std::function<MangledOrNativeTypeName(AST::NamedType&)> m_mangledNameForNamedType;
    371371    StringBuilder m_stringBuilder;
    372372};
     
    374374String TypeNamer::metalTypeDeclarations()
    375375{
    376     MetalTypeDeclarationWriter metalTypeDeclarationWriter([&](AST::NamedType& namedType) -> String {
     376    MetalTypeDeclarationWriter metalTypeDeclarationWriter([&](AST::NamedType& namedType) -> MangledOrNativeTypeName {
    377377        return mangledNameForType(namedType);
    378378    });
     
    461461}
    462462
    463 String TypeNamer::mangledNameForType(AST::UnnamedType& unnamedType)
     463MangledTypeName TypeNamer::mangledNameForType(AST::UnnamedType& unnamedType)
    464464{
    465465    return find(unnamedType, m_trie).mangledName();
    466466}
    467467
    468 String TypeNamer::mangledNameForType(AST::NamedType& namedType)
     468MangledOrNativeTypeName TypeNamer::mangledNameForType(AST::NamedType& namedType)
    469469{
    470470    if (is<AST::NativeTypeDeclaration>(namedType))
     
    476476
    477477
    478 String TypeNamer::mangledNameForEnumerationMember(AST::EnumerationMember& enumerationMember)
     478MangledEnumerationMemberName TypeNamer::mangledNameForEnumerationMember(AST::EnumerationMember& enumerationMember)
    479479{
    480480    auto iterator = m_enumerationMemberMapping.find(&enumerationMember);
     
    483483}
    484484
    485 String TypeNamer::mangledNameForStructureElement(AST::StructureElement& structureElement)
     485MangledStructureElementName TypeNamer::mangledNameForStructureElement(AST::StructureElement& structureElement)
    486486{
    487487    auto iterator = m_structureElementMapping.find(&structureElement);
  • trunk/Source/WebCore/Modules/webgpu/WHLSL/Metal/WHLSLTypeNamer.h

    r246875 r248266  
    2828#if ENABLE(WEBGPU)
    2929
     30#include "WHLSLMangledNames.h"
    3031#include "WHLSLVisitor.h"
    3132#include <wtf/HashMap.h>
    32 #include <wtf/text/StringConcatenate.h>
    33 #include <wtf/text/StringConcatenateNumbers.h>
    3433#include <wtf/text/WTFString.h>
    3534
     
    6564    // Must be called after calling metalTypes().
    6665    String mangledNameForType(AST::NativeTypeDeclaration&);
    67     String mangledNameForType(AST::UnnamedType&);
    68     String mangledNameForType(AST::NamedType&);
    69     String mangledNameForEnumerationMember(AST::EnumerationMember&);
    70     String mangledNameForStructureElement(AST::StructureElement&);
     66    MangledTypeName mangledNameForType(AST::UnnamedType&);
     67    MangledOrNativeTypeName mangledNameForType(AST::NamedType&);
     68    MangledEnumerationMemberName mangledNameForEnumerationMember(AST::EnumerationMember&);
     69    MangledStructureElementName mangledNameForStructureElement(AST::StructureElement&);
    7170
    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++ }; }
    8173
    8274private:
     
    8981    void visit(AST::CallExpression&) override;
    9082
    91     String generateNextEnumerationMemberName()
    92     {
    93         return makeString("enumerationMember", m_enumerationMemberCount++);
    94     }
     83    MangledEnumerationMemberName generateNextEnumerationMemberName() { return { m_enumerationMemberCount++ }; }
    9584
    9685    void emitNamedTypeDefinition(AST::NamedType&, HashSet<AST::NamedType*>& emittedNamedTypes, HashSet<BaseTypeNameNode*>& emittedUnnamedTypes, StringBuilder&);
     
    10695    Vector<UniqueRef<BaseTypeNameNode>> m_trie;
    10796    HashMap<AST::UnnamedType*, BaseTypeNameNode*> m_unnamedTypeMapping;
    108     HashMap<AST::NamedType*, String> m_namedTypeMapping;
     97    HashMap<AST::NamedType*, MangledTypeName> m_namedTypeMapping;
    10998    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;
    112101    unsigned m_typeCount { 0 };
    113102    unsigned m_enumerationMemberCount { 0 };
  • trunk/Source/WebCore/Modules/webgpu/WHLSL/WHLSLPrepare.h

    r247834 r248266  
    2929
    3030#include "WHLSLError.h"
     31#include "WHLSLMangledNames.h"
    3132#include "WHLSLPipelineDescriptor.h"
    3233#include <wtf/text/WTFString.h>
     
    3839struct RenderPrepareResult {
    3940    String metalSource;
    40     String mangledVertexEntryPointName;
    41     String mangledFragmentEntryPointName;
     41    Metal::MangledFunctionName mangledVertexEntryPointName;
     42    Metal::MangledFunctionName mangledFragmentEntryPointName;
    4243};
    4344Expected<RenderPrepareResult, String> prepare(String& whlslSource, RenderPipelineDescriptor&);
     
    5152struct ComputePrepareResult {
    5253    String metalSource;
    53     String mangledEntryPointName;
     54    Metal::MangledFunctionName mangledEntryPointName;
    5455    ComputeDimensions computeDimensions;
    5556};
  • trunk/Source/WebCore/WebCore.xcodeproj/project.pbxproj

    r248200 r248266  
    97359735                7C7941E21C56C29300A4C58E /* DataDetectorsCoreSoftLink.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = DataDetectorsCoreSoftLink.mm; sourceTree = "<group>"; };
    97369736                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>"; };
    97379738                7C8139A31ED6281D00CE26E8 /* JSDOMAttribute.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSDOMAttribute.h; sourceTree = "<group>"; };
    97389739                7C8139A41ED6281D00CE26E8 /* JSDOMOperation.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSDOMOperation.h; sourceTree = "<group>"; };
     
    1717317174                                1CECB3AF21F2B98400F44542 /* WHLSLFunctionWriter.cpp */,
    1717417175                                1CECB3B221F2B98600F44542 /* WHLSLFunctionWriter.h */,
     17176                                7C7C769C22F67ECD0032BCCD /* WHLSLMangledNames.h */,
    1717517177                                1CECB3B521F50AC700F44542 /* WHLSLMetalCodeGenerator.cpp */,
    1717617178                                1CECB3B621F50AC700F44542 /* WHLSLMetalCodeGenerator.h */,
  • trunk/Source/WebCore/platform/graphics/gpu/cocoa/GPUComputePipelineMetal.mm

    r247892 r248266  
    9595        // 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.
    9696
    97         computeEntryPoint = whlslCompileResult->mangledEntryPointName;
     97        computeEntryPoint = whlslCompileResult->mangledEntryPointName.toString();
    9898    } else {
    9999        computeLibrary = computeStage.module->platformShaderModule();
  • trunk/Source/WebCore/platform/graphics/gpu/cocoa/GPURenderPipelineMetal.mm

    r248078 r248266  
    412412
    413413        fragmentLibrary = vertexLibrary;
    414         vertexEntryPoint = whlslCompileResult->mangledVertexEntryPointName;
    415         fragmentEntryPoint = whlslCompileResult->mangledFragmentEntryPointName;
     414        vertexEntryPoint = whlslCompileResult->mangledVertexEntryPointName.toString();
     415        fragmentEntryPoint = whlslCompileResult->mangledFragmentEntryPointName.toString();
    416416    } else {
    417417        vertexLibrary = vertexStage.module->platformShaderModule();
Note: See TracChangeset for help on using the changeset viewer.