⚠ Archived content — this site is no longer maintained.   Current WebKit documentation is at docs.webkit.org.

Changeset 249215 in webkit


Ignore:
Timestamp:
Aug 28, 2019, 12:51:06 PM (7 years ago)
Author:
Truitt Savell
Message:

Unreviewed, rolling out r249209.

Broke 19 webgpu/ tests

Reverted changeset:

"[WHLSL] Inline typedef'd types during Metal code generation
to simplify generated code while also making it easier to
read"
​https://bugs.webkit.org/show_bug.cgi?id=201185
​https://trac.webkit.org/changeset/249209

Location:
trunk/Source/WebCore
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r249214 r249215  
     12019-08-28  Truitt Savell  <tsavell@apple.com>
     2
     3        Unreviewed, rolling out r249209.
     4
     5        Broke 19 webgpu/ tests
     6
     7        Reverted changeset:
     8
     9        "[WHLSL] Inline typedef'd types during Metal code generation
     10        to simplify generated code while also making it easier to
     11        read"
     12        https://bugs.webkit.org/show_bug.cgi?id=201185
     13        https://trac.webkit.org/changeset/249209
     14
    1152019-08-28  Myles C. Maxfield  <mmaxfield@apple.com>
    216

  • trunk/Source/WebCore/Modules/webgpu/WHLSL/Metal/WHLSLFunctionWriter.cpp

    r249209 r249215  
    526526{
    527527    auto valueName = generateNextVariableName();
    528     auto mangledTypeName = m_typeNamer.mangledNameForType(globalVariableReference.resolvedType());
     528    MangledTypeName mangledTypeName = m_typeNamer.mangledNameForType(globalVariableReference.resolvedType());
    529529
    530530    checkErrorAndVisit(globalVariableReference.base());
    531531    MangledVariableName structVariable = takeLastValue();
    532532
    533     auto mangledFieldName = m_typeNamer.mangledNameForStructureElement(globalVariableReference.structField());
     533    MangledStructureElementName mangledFieldName = m_typeNamer.mangledNameForStructureElement(globalVariableReference.structField());
    534534
    535535    m_stringBuilder.append(

  • trunk/Source/WebCore/Modules/webgpu/WHLSL/Metal/WHLSLTypeNamer.cpp

    r249209 r249215  
    119119void TypeNamer::visit(AST::TypeDefinition& typeDefinition)
    120120{
     121    {
     122        auto addResult = m_namedTypeMapping.add(&typeDefinition, generateNextTypeName());
     123        ASSERT_UNUSED(addResult, addResult.isNewEntry);
     124    }
    121125    Visitor::visit(typeDefinition);
    122126    {
    … …  
    143147}
    144148
     149static AST::UnnamedType* parent(AST::UnnamedType& unnamedType)
     150{
     151    switch (unnamedType.kind()) {
     152    case AST::UnnamedType::Kind::TypeReference:
     153        return nullptr;
     154    case AST::UnnamedType::Kind::Pointer:
     155        return &downcast<AST::PointerType>(unnamedType).elementType();
     156    case AST::UnnamedType::Kind::ArrayReference:
     157        return &downcast<AST::ArrayReferenceType>(unnamedType).elementType();
     158    case AST::UnnamedType::Kind::Array:
     159        return &downcast<AST::ArrayType>(unnamedType).type();
     160    default:
     161        RELEASE_ASSERT_NOT_REACHED();
     162    }
     163}
     164
    145165void TypeNamer::generateUniquedTypeName(AST::UnnamedType& unnamedType)
    146166{
    147     if (is<AST::ArrayReferenceType>(unnamedType)) {
    148         m_arrayReferenceTypeMapping.ensure(UnnamedTypeKey { unnamedType }, [&] {
    149             return generateNextTypeName();
    150         });
    151     }
     167    auto* parentUnnamedType = parent(unnamedType);
     168    if (parentUnnamedType)
     169        generateUniquedTypeName(*parentUnnamedType);
     170
     171    m_unnamedTypeMapping.ensure(UnnamedTypeKey { unnamedType }, [&] {
     172        return generateNextTypeName();
     173    });
    152174}
    153175
    … …  
    179201}
    180202
    181 void TypeNamer::emitUnnamedTypeDefinition(StringBuilder& stringBuilder, AST::UnnamedType& unnamedType, MangledOrNativeTypeName mangledName, HashSet<AST::NamedType*>& emittedNamedTypes, HashSet<UnnamedTypeKey>& emittedUnnamedTypes)
     203void TypeNamer::emitUnnamedTypeDefinition(StringBuilder& stringBuilder, AST::UnnamedType& unnamedType, MangledTypeName mangledName, HashSet<AST::NamedType*>& emittedNamedTypes, HashSet<UnnamedTypeKey>& emittedUnnamedTypes)
    182204{
    183205    if (emittedUnnamedTypes.contains(UnnamedTypeKey { unnamedType }))
    … …  
    186208    switch (unnamedType.kind()) {
    187209    case AST::UnnamedType::Kind::TypeReference: {
     210        auto& typeReference = downcast<AST::TypeReference>(unnamedType);
     211
     212        auto& parent = typeReference.resolvedType();
     213        auto parentMangledName = mangledNameForType(typeReference.resolvedType());
     214        auto iterator = m_dependencyGraph.find(&parent);
     215        ASSERT(iterator != m_dependencyGraph.end());
     216        emitNamedTypeDefinition(stringBuilder, parent, iterator->value, emittedNamedTypes, emittedUnnamedTypes);
     217
     218        stringBuilder.append("typedef ", parentMangledName, ' ', mangledName, ";\n");
    188219        break;
    189220    }
    190221    case AST::UnnamedType::Kind::Pointer: {
    191         break;
    192     }
    193     case AST::UnnamedType::Kind::Array: {
     222        auto& pointerType = downcast<AST::PointerType>(unnamedType);
     223
     224        auto& parent = pointerType.elementType();
     225        auto parentMangledName = mangledNameForType(parent);
     226        emitUnnamedTypeDefinition(stringBuilder, parent, parentMangledName, emittedNamedTypes, emittedUnnamedTypes);
     227
     228        stringBuilder.append("typedef ", toString(pointerType.addressSpace()), ' ', parentMangledName, "* ", mangledName, ";\n");
    194229        break;
    195230    }
    … …  
    197232        auto& arrayReferenceType = downcast<AST::ArrayReferenceType>(unnamedType);
    198233
    199         auto& elementType = arrayReferenceType.elementType();
    200         auto elementTypeMangledName = mangledNameForType(elementType);
    201         emitUnnamedTypeDefinition(stringBuilder, elementType, elementTypeMangledName, emittedNamedTypes, emittedUnnamedTypes);
     234        auto& parent = arrayReferenceType.elementType();
     235        auto parentMangledName = mangledNameForType(parent);
     236        emitUnnamedTypeDefinition(stringBuilder, parent, parentMangledName, emittedNamedTypes, emittedUnnamedTypes);
    202237
    203238        stringBuilder.append(
    204239            "struct ", mangledName, " {\n"
    205             "    ", toString(arrayReferenceType.addressSpace()), ' ', elementTypeMangledName, "* pointer;\n"
     240            "    ", toString(arrayReferenceType.addressSpace()), ' ', parentMangledName, "* pointer;\n"
    206241            "    uint32_t length;\n"
    207242            "};\n"
    … …  
    209244        break;
    210245    }
     246    case AST::UnnamedType::Kind::Array: {
     247        auto& arrayType = downcast<AST::ArrayType>(unnamedType);
     248
     249        auto& parent = arrayType.type();
     250        auto parentMangledName = mangledNameForType(parent);
     251        emitUnnamedTypeDefinition(stringBuilder, parent, parentMangledName, emittedNamedTypes, emittedUnnamedTypes);
     252
     253        stringBuilder.append("typedef array<", parentMangledName, ", ", arrayType.numElements(), "> ", mangledName, ";\n");
     254        break;
     255    }
    211256    default:
    212257        RELEASE_ASSERT_NOT_REACHED();
    … …  
    225270
    226271    switch (namedType.kind()) {
    227     case AST::NamedType::Kind::NativeTypeDeclaration: {
    228         // Native types already have definitions. There's nothing to do.
    229         break;
    230     }
    231     case AST::NamedType::Kind::TypeDefinition: {
    232         // The mangled name of a AST::TypeDefinition looks through to the underlying type. There is nothing to do.
    233         break;
    234     }
    235272    case AST::NamedType::Kind::EnumerationDefinition: {
    236273        auto& enumerationDefinition = downcast<AST::EnumerationDefinition>(namedType);
    … …  
    243280        break;
    244281    }
     282    case AST::NamedType::Kind::NativeTypeDeclaration: {
     283        // Native types already have definitions. There's nothing to do.
     284        break;
     285    }
    245286    case AST::NamedType::Kind::StructureDefinition: {
    246287        auto& structureDefinition = downcast<AST::StructureDefinition>(namedType);
    … …  
    252293        break;
    253294    }
     295    case AST::NamedType::Kind::TypeDefinition: {
     296        auto& typeDefinition = downcast<AST::TypeDefinition>(namedType);
     297
     298        stringBuilder.append("typedef ", mangledNameForType(typeDefinition.type()), ' ', mangledNameForType(typeDefinition), ";\n");
     299        break;
     300    }
    254301    default:
    255302        RELEASE_ASSERT_NOT_REACHED();
    … …  
    265312    for (auto& [namedType, neighbors] : m_dependencyGraph)
    266313        emitNamedTypeDefinition(stringBuilder, *namedType, neighbors, emittedNamedTypes, emittedUnnamedTypes);
    267     for (auto& [unnamedTypeKey, mangledName] : m_arrayReferenceTypeMapping)
     314    for (auto& [unnamedTypeKey, mangledName] : m_unnamedTypeMapping)
    268315        emitUnnamedTypeDefinition(stringBuilder, unnamedTypeKey.unnamedType(), mangledName, emittedNamedTypes, emittedUnnamedTypes);
    269316}
    270317
    271 MangledOrNativeTypeName TypeNamer::mangledNameForType(AST::UnnamedType& unnamedType)
    272 {
    273     switch (unnamedType.kind()) {
    274     case AST::UnnamedType::Kind::TypeReference: {
    275         auto& typeReference = downcast<AST::TypeReference>(unnamedType);
    276         return mangledNameForType(typeReference.resolvedType());
    277     }
    278     case AST::UnnamedType::Kind::Pointer: {
    279         auto& pointerType = downcast<AST::PointerType>(unnamedType);
    280         return m_lazyUnnamedTypeCache.ensure(UnnamedTypeKey { unnamedType }, [&] {
    281             return makeString(toString(pointerType.addressSpace()), ' ', mangledNameForType(pointerType.elementType()), '*');
    282         }).iterator->value;
    283     }
    284     case AST::UnnamedType::Kind::Array: {
    285         auto& arrayType = downcast<AST::ArrayType>(unnamedType);
    286         return m_lazyUnnamedTypeCache.ensure(UnnamedTypeKey { unnamedType }, [&] {
    287             return makeString("array<", mangledNameForType(arrayType.type()), ", ", arrayType.numElements(), '>');
    288         }).iterator->value;
    289     }
    290     case AST::UnnamedType::Kind::ArrayReference: {
    291         auto iterator = m_arrayReferenceTypeMapping.find(UnnamedTypeKey { unnamedType });
    292         ASSERT(iterator != m_arrayReferenceTypeMapping.end());
    293         return iterator->value;
    294     }
    295     default:
    296         RELEASE_ASSERT_NOT_REACHED();
    297     }
     318MangledTypeName TypeNamer::mangledNameForType(AST::UnnamedType& unnamedType)
     319{
     320    auto iterator = m_unnamedTypeMapping.find(UnnamedTypeKey { unnamedType });
     321    ASSERT(iterator != m_unnamedTypeMapping.end());
     322    return iterator->value;
    298323}
    299324
    300325MangledOrNativeTypeName TypeNamer::mangledNameForType(AST::NamedType& namedType)
    301326{
    302     switch (namedType.kind()) {
    303     case AST::NamedType::Kind::NativeTypeDeclaration: {
     327    if (is<AST::NativeTypeDeclaration>(namedType))
    304328        return mangledNameForType(downcast<AST::NativeTypeDeclaration>(namedType));
    305     }
    306     case AST::NamedType::Kind::TypeDefinition: {
    307         return mangledNameForType(downcast<AST::TypeDefinition>(namedType).type());
    308     }
    309     case AST::NamedType::Kind::EnumerationDefinition:
    310     case AST::NamedType::Kind::StructureDefinition: {
    311         auto iterator = m_namedTypeMapping.find(&namedType);
    312         ASSERT(iterator != m_namedTypeMapping.end());
    313         return iterator->value;
    314     }
    315     default:
    316         RELEASE_ASSERT_NOT_REACHED();
    317     }
     329    auto iterator = m_namedTypeMapping.find(&namedType);
     330    ASSERT(iterator != m_namedTypeMapping.end());
     331    return iterator->value;
    318332}
    319333

  • trunk/Source/WebCore/Modules/webgpu/WHLSL/Metal/WHLSLTypeNamer.h

    r249209 r249215  
    6565    // Must be called after calling emitMetalTypes().
    6666    String mangledNameForType(AST::NativeTypeDeclaration&);
    67     MangledOrNativeTypeName mangledNameForType(AST::UnnamedType&);
     67    MangledTypeName mangledNameForType(AST::UnnamedType&);
    6868    MangledOrNativeTypeName mangledNameForType(AST::NamedType&);
    6969    MangledEnumerationMemberName mangledNameForEnumerationMember(AST::EnumerationMember&);
    … …  
    8585
    8686    void emitNamedTypeDefinition(StringBuilder&, AST::NamedType&, Vector<std::reference_wrapper<AST::UnnamedType>>&, HashSet<AST::NamedType*>& emittedNamedTypes, HashSet<UnnamedTypeKey>& emittedUnnamedTypes);
    87     void emitUnnamedTypeDefinition(StringBuilder&, AST::UnnamedType&, MangledOrNativeTypeName, HashSet<AST::NamedType*>& emittedNamedTypes, HashSet<UnnamedTypeKey>& emittedUnnamedTypes);
     87    void emitUnnamedTypeDefinition(StringBuilder&, AST::UnnamedType&, MangledTypeName, HashSet<AST::NamedType*>& emittedNamedTypes, HashSet<UnnamedTypeKey>& emittedUnnamedTypes);
    8888    void emitMetalTypeDeclarations(StringBuilder&);
    8989    void emitMetalTypeDefinitions(StringBuilder&);
    … …  
    9292
    9393    Program& m_program;
    94     HashMap<UnnamedTypeKey, MangledTypeName> m_arrayReferenceTypeMapping;
    95     HashMap<UnnamedTypeKey, String> m_lazyUnnamedTypeCache;
     94    HashMap<UnnamedTypeKey, MangledTypeName> m_unnamedTypeMapping;
    9695    HashMap<AST::NamedType*, MangledTypeName> m_namedTypeMapping;
    9796    HashMap<AST::NamedType*, Vector<std::reference_wrapper<AST::UnnamedType>>> m_dependencyGraph;
Note: See TracChangeset for help on using the changeset viewer.