Modified: trunk/Source/WebCore/Modules/webgpu/WHLSL/Metal/WHLSLTypeNamer.cpp (249214 => 249215)
--- trunk/Source/WebCore/Modules/webgpu/WHLSL/Metal/WHLSLTypeNamer.cpp 2019-08-28 19:46:36 UTC (rev 249214)
+++ trunk/Source/WebCore/Modules/webgpu/WHLSL/Metal/WHLSLTypeNamer.cpp 2019-08-28 19:51:06 UTC (rev 249215)
@@ -118,6 +118,10 @@
void TypeNamer::visit(AST::TypeDefinition& typeDefinition)
{
+ {
+ auto addResult = m_namedTypeMapping.add(&typeDefinition, generateNextTypeName());
+ ASSERT_UNUSED(addResult, addResult.isNewEntry);
+ }
Visitor::visit(typeDefinition);
{
auto addResult = m_dependencyGraph.add(&typeDefinition, Vector<std::reference_wrapper<AST::UnnamedType>> { typeDefinition.type() });
@@ -142,15 +146,33 @@
return writeNativeType(nativeTypeDeclaration);
}
-void TypeNamer::generateUniquedTypeName(AST::UnnamedType& unnamedType)
+static AST::UnnamedType* parent(AST::UnnamedType& unnamedType)
{
- if (is<AST::ArrayReferenceType>(unnamedType)) {
- m_arrayReferenceTypeMapping.ensure(UnnamedTypeKey { unnamedType }, [&] {
- return generateNextTypeName();
- });
+ switch (unnamedType.kind()) {
+ case AST::UnnamedType::Kind::TypeReference:
+ return nullptr;
+ case AST::UnnamedType::Kind::Pointer:
+ return &downcast<AST::PointerType>(unnamedType).elementType();
+ case AST::UnnamedType::Kind::ArrayReference:
+ return &downcast<AST::ArrayReferenceType>(unnamedType).elementType();
+ case AST::UnnamedType::Kind::Array:
+ return &downcast<AST::ArrayType>(unnamedType).type();
+ default:
+ RELEASE_ASSERT_NOT_REACHED();
}
}
+void TypeNamer::generateUniquedTypeName(AST::UnnamedType& unnamedType)
+{
+ auto* parentUnnamedType = parent(unnamedType);
+ if (parentUnnamedType)
+ generateUniquedTypeName(*parentUnnamedType);
+
+ m_unnamedTypeMapping.ensure(UnnamedTypeKey { unnamedType }, [&] {
+ return generateNextTypeName();
+ });
+}
+
class MetalTypeDeclarationWriter final : public Visitor {
WTF_MAKE_FAST_ALLOCATED;
public:
@@ -178,7 +200,7 @@
metalTypeDeclarationWriter.Visitor::visit(m_program);
}
-void TypeNamer::emitUnnamedTypeDefinition(StringBuilder& stringBuilder, AST::UnnamedType& unnamedType, MangledOrNativeTypeName mangledName, HashSet<AST::NamedType*>& emittedNamedTypes, HashSet<UnnamedTypeKey>& emittedUnnamedTypes)
+void TypeNamer::emitUnnamedTypeDefinition(StringBuilder& stringBuilder, AST::UnnamedType& unnamedType, MangledTypeName mangledName, HashSet<AST::NamedType*>& emittedNamedTypes, HashSet<UnnamedTypeKey>& emittedUnnamedTypes)
{
if (emittedUnnamedTypes.contains(UnnamedTypeKey { unnamedType }))
return;
@@ -185,29 +207,52 @@
switch (unnamedType.kind()) {
case AST::UnnamedType::Kind::TypeReference: {
+ auto& typeReference = downcast<AST::TypeReference>(unnamedType);
+
+ auto& parent = typeReference.resolvedType();
+ auto parentMangledName = mangledNameForType(typeReference.resolvedType());
+ auto iterator = m_dependencyGraph.find(&parent);
+ ASSERT(iterator != m_dependencyGraph.end());
+ emitNamedTypeDefinition(stringBuilder, parent, iterator->value, emittedNamedTypes, emittedUnnamedTypes);
+
+ stringBuilder.append("typedef ", parentMangledName, ' ', mangledName, ";\n");
break;
}
case AST::UnnamedType::Kind::Pointer: {
+ auto& pointerType = downcast<AST::PointerType>(unnamedType);
+
+ auto& parent = pointerType.elementType();
+ auto parentMangledName = mangledNameForType(parent);
+ emitUnnamedTypeDefinition(stringBuilder, parent, parentMangledName, emittedNamedTypes, emittedUnnamedTypes);
+
+ stringBuilder.append("typedef ", toString(pointerType.addressSpace()), ' ', parentMangledName, "* ", mangledName, ";\n");
break;
}
- case AST::UnnamedType::Kind::Array: {
- break;
- }
case AST::UnnamedType::Kind::ArrayReference: {
auto& arrayReferenceType = downcast<AST::ArrayReferenceType>(unnamedType);
- auto& elementType = arrayReferenceType.elementType();
- auto elementTypeMangledName = mangledNameForType(elementType);
- emitUnnamedTypeDefinition(stringBuilder, elementType, elementTypeMangledName, emittedNamedTypes, emittedUnnamedTypes);
+ auto& parent = arrayReferenceType.elementType();
+ auto parentMangledName = mangledNameForType(parent);
+ emitUnnamedTypeDefinition(stringBuilder, parent, parentMangledName, emittedNamedTypes, emittedUnnamedTypes);
stringBuilder.append(
"struct ", mangledName, " {\n"
- " ", toString(arrayReferenceType.addressSpace()), ' ', elementTypeMangledName, "* pointer;\n"
+ " ", toString(arrayReferenceType.addressSpace()), ' ', parentMangledName, "* pointer;\n"
" uint32_t length;\n"
"};\n"
);
break;
}
+ case AST::UnnamedType::Kind::Array: {
+ auto& arrayType = downcast<AST::ArrayType>(unnamedType);
+
+ auto& parent = arrayType.type();
+ auto parentMangledName = mangledNameForType(parent);
+ emitUnnamedTypeDefinition(stringBuilder, parent, parentMangledName, emittedNamedTypes, emittedUnnamedTypes);
+
+ stringBuilder.append("typedef array<", parentMangledName, ", ", arrayType.numElements(), "> ", mangledName, ";\n");
+ break;
+ }
default:
RELEASE_ASSERT_NOT_REACHED();
}
@@ -224,14 +269,6 @@
emitUnnamedTypeDefinition(stringBuilder, unnameType, mangledNameForType(unnameType), emittedNamedTypes, emittedUnnamedTypes);
switch (namedType.kind()) {
- case AST::NamedType::Kind::NativeTypeDeclaration: {
- // Native types already have definitions. There's nothing to do.
- break;
- }
- case AST::NamedType::Kind::TypeDefinition: {
- // The mangled name of a AST::TypeDefinition looks through to the underlying type. There is nothing to do.
- break;
- }
case AST::NamedType::Kind::EnumerationDefinition: {
auto& enumerationDefinition = downcast<AST::EnumerationDefinition>(namedType);
auto& baseType = enumerationDefinition.type().unifyNode();
@@ -242,6 +279,10 @@
stringBuilder.append("};\n");
break;
}
+ case AST::NamedType::Kind::NativeTypeDeclaration: {
+ // Native types already have definitions. There's nothing to do.
+ break;
+ }
case AST::NamedType::Kind::StructureDefinition: {
auto& structureDefinition = downcast<AST::StructureDefinition>(namedType);
@@ -251,6 +292,12 @@
stringBuilder.append("};\n");
break;
}
+ case AST::NamedType::Kind::TypeDefinition: {
+ auto& typeDefinition = downcast<AST::TypeDefinition>(namedType);
+
+ stringBuilder.append("typedef ", mangledNameForType(typeDefinition.type()), ' ', mangledNameForType(typeDefinition), ";\n");
+ break;
+ }
default:
RELEASE_ASSERT_NOT_REACHED();
}
@@ -264,57 +311,24 @@
HashSet<UnnamedTypeKey> emittedUnnamedTypes;
for (auto& [namedType, neighbors] : m_dependencyGraph)
emitNamedTypeDefinition(stringBuilder, *namedType, neighbors, emittedNamedTypes, emittedUnnamedTypes);
- for (auto& [unnamedTypeKey, mangledName] : m_arrayReferenceTypeMapping)
+ for (auto& [unnamedTypeKey, mangledName] : m_unnamedTypeMapping)
emitUnnamedTypeDefinition(stringBuilder, unnamedTypeKey.unnamedType(), mangledName, emittedNamedTypes, emittedUnnamedTypes);
}
-MangledOrNativeTypeName TypeNamer::mangledNameForType(AST::UnnamedType& unnamedType)
+MangledTypeName TypeNamer::mangledNameForType(AST::UnnamedType& unnamedType)
{
- switch (unnamedType.kind()) {
- case AST::UnnamedType::Kind::TypeReference: {
- auto& typeReference = downcast<AST::TypeReference>(unnamedType);
- return mangledNameForType(typeReference.resolvedType());
- }
- case AST::UnnamedType::Kind::Pointer: {
- auto& pointerType = downcast<AST::PointerType>(unnamedType);
- return m_lazyUnnamedTypeCache.ensure(UnnamedTypeKey { unnamedType }, [&] {
- return makeString(toString(pointerType.addressSpace()), ' ', mangledNameForType(pointerType.elementType()), '*');
- }).iterator->value;
- }
- case AST::UnnamedType::Kind::Array: {
- auto& arrayType = downcast<AST::ArrayType>(unnamedType);
- return m_lazyUnnamedTypeCache.ensure(UnnamedTypeKey { unnamedType }, [&] {
- return makeString("array<", mangledNameForType(arrayType.type()), ", ", arrayType.numElements(), '>');
- }).iterator->value;
- }
- case AST::UnnamedType::Kind::ArrayReference: {
- auto iterator = m_arrayReferenceTypeMapping.find(UnnamedTypeKey { unnamedType });
- ASSERT(iterator != m_arrayReferenceTypeMapping.end());
- return iterator->value;
- }
- default:
- RELEASE_ASSERT_NOT_REACHED();
- }
+ auto iterator = m_unnamedTypeMapping.find(UnnamedTypeKey { unnamedType });
+ ASSERT(iterator != m_unnamedTypeMapping.end());
+ return iterator->value;
}
MangledOrNativeTypeName TypeNamer::mangledNameForType(AST::NamedType& namedType)
{
- switch (namedType.kind()) {
- case AST::NamedType::Kind::NativeTypeDeclaration: {
+ if (is<AST::NativeTypeDeclaration>(namedType))
return mangledNameForType(downcast<AST::NativeTypeDeclaration>(namedType));
- }
- case AST::NamedType::Kind::TypeDefinition: {
- return mangledNameForType(downcast<AST::TypeDefinition>(namedType).type());
- }
- case AST::NamedType::Kind::EnumerationDefinition:
- case AST::NamedType::Kind::StructureDefinition: {
- auto iterator = m_namedTypeMapping.find(&namedType);
- ASSERT(iterator != m_namedTypeMapping.end());
- return iterator->value;
- }
- default:
- RELEASE_ASSERT_NOT_REACHED();
- }
+ auto iterator = m_namedTypeMapping.find(&namedType);
+ ASSERT(iterator != m_namedTypeMapping.end());
+ return iterator->value;
}
MangledEnumerationMemberName TypeNamer::mangledNameForEnumerationMember(AST::EnumerationMember& enumerationMember)
Modified: trunk/Source/WebCore/Modules/webgpu/WHLSL/Metal/WHLSLTypeNamer.h (249214 => 249215)
--- trunk/Source/WebCore/Modules/webgpu/WHLSL/Metal/WHLSLTypeNamer.h 2019-08-28 19:46:36 UTC (rev 249214)
+++ trunk/Source/WebCore/Modules/webgpu/WHLSL/Metal/WHLSLTypeNamer.h 2019-08-28 19:51:06 UTC (rev 249215)
@@ -64,7 +64,7 @@
// Must be called after calling emitMetalTypes().
String mangledNameForType(AST::NativeTypeDeclaration&);
- MangledOrNativeTypeName mangledNameForType(AST::UnnamedType&);
+ MangledTypeName mangledNameForType(AST::UnnamedType&);
MangledOrNativeTypeName mangledNameForType(AST::NamedType&);
MangledEnumerationMemberName mangledNameForEnumerationMember(AST::EnumerationMember&);
MangledStructureElementName mangledNameForStructureElement(AST::StructureElement&);
@@ -84,7 +84,7 @@
MangledEnumerationMemberName generateNextEnumerationMemberName() { return { m_enumerationMemberCount++ }; }
void emitNamedTypeDefinition(StringBuilder&, AST::NamedType&, Vector<std::reference_wrapper<AST::UnnamedType>>&, HashSet<AST::NamedType*>& emittedNamedTypes, HashSet<UnnamedTypeKey>& emittedUnnamedTypes);
- void emitUnnamedTypeDefinition(StringBuilder&, AST::UnnamedType&, MangledOrNativeTypeName, HashSet<AST::NamedType*>& emittedNamedTypes, HashSet<UnnamedTypeKey>& emittedUnnamedTypes);
+ void emitUnnamedTypeDefinition(StringBuilder&, AST::UnnamedType&, MangledTypeName, HashSet<AST::NamedType*>& emittedNamedTypes, HashSet<UnnamedTypeKey>& emittedUnnamedTypes);
void emitMetalTypeDeclarations(StringBuilder&);
void emitMetalTypeDefinitions(StringBuilder&);
@@ -91,8 +91,7 @@
void generateUniquedTypeName(AST::UnnamedType&);
Program& m_program;
- HashMap<UnnamedTypeKey, MangledTypeName> m_arrayReferenceTypeMapping;
- HashMap<UnnamedTypeKey, String> m_lazyUnnamedTypeCache;
+ HashMap<UnnamedTypeKey, MangledTypeName> m_unnamedTypeMapping;
HashMap<AST::NamedType*, MangledTypeName> m_namedTypeMapping;
HashMap<AST::NamedType*, Vector<std::reference_wrapper<AST::UnnamedType>>> m_dependencyGraph;
HashMap<AST::EnumerationMember*, MangledEnumerationMemberName> m_enumerationMemberMapping;
