Diff
Modified: trunk/Source/WebCore/ChangeLog (239892 => 239893)
--- trunk/Source/WebCore/ChangeLog 2019-01-12 01:50:27 UTC (rev 239892)
+++ trunk/Source/WebCore/ChangeLog 2019-01-12 02:46:08 UTC (rev 239893)
@@ -1,3 +1,25 @@
+2019-01-11 Myles C. Maxfield <[email protected]>
+
+ [WHLSL] Add a Visitor class
+ https://bugs.webkit.org/show_bug.cgi?id=192826
+
+ Reviewed by Dean Jackson.
+
+ This patch exposes a bunch of the private members of WHLSL's AST nodes so that Visitor can recurse on constituent nodes.
+ It also writes the recursion in Visitor.h. This is a virtual base class that gets subclassed for compiler passes.
+
+ I've split this part into its own patch to aid reviewing of the compiler.
+
+ * Modules/webgpu/WHLSL/AST/WHLSLStageInOutSemantic.cpp:
+ * Modules/webgpu/WHLSL/WHLSLVisitor.cpp: Added.
+ (WebCore::WHLSL::Visitor::visit):
+ (WebCore::WHLSL::Visitor::checkErrorAndVisit):
+ * Modules/webgpu/WHLSL/WHLSLVisitor.h: Added.
+ (WebCore::WHLSL::Visitor::setError):
+ (WebCore::WHLSL::Visitor::error const):
+ * Sources.txt:
+ * WebCore.xcodeproj/project.pbxproj:
+
2019-01-11 Jer Noble <[email protected]>
REGRESSION(r239419): Crash in AudioSourceProviderAVFObjC::~AudioSourceProviderAVFObjC()
Added: trunk/Source/WebCore/Modules/webgpu/WHLSL/WHLSLVisitor.cpp (0 => 239893)
--- trunk/Source/WebCore/Modules/webgpu/WHLSL/WHLSLVisitor.cpp (rev 0)
+++ trunk/Source/WebCore/Modules/webgpu/WHLSL/WHLSLVisitor.cpp 2019-01-12 02:46:08 UTC (rev 239893)
@@ -0,0 +1,625 @@
+/*
+ * Copyright (C) 2019 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "config.h"
+#include "WHLSLVisitor.h"
+
+#if ENABLE(WEBGPU)
+
+#include "WHLSLArrayReferenceType.h"
+#include "WHLSLArrayType.h"
+#include "WHLSLAssignmentExpression.h"
+#include "WHLSLBaseFunctionAttribute.h"
+#include "WHLSLBaseSemantic.h"
+#include "WHLSLBlock.h"
+#include "WHLSLBooleanLiteral.h"
+#include "WHLSLBreak.h"
+#include "WHLSLBuiltInSemantic.h"
+#include "WHLSLCallExpression.h"
+#include "WHLSLCommaExpression.h"
+#include "WHLSLConstantExpression.h"
+#include "WHLSLConstantExpressionEnumerationMemberReference.h"
+#include "WHLSLContinue.h"
+#include "WHLSLDereferenceExpression.h"
+#include "WHLSLDoWhileLoop.h"
+#include "WHLSLDotExpression.h"
+#include "WHLSLEffectfulExpressionStatement.h"
+#include "WHLSLEnumerationDefinition.h"
+#include "WHLSLEnumerationMember.h"
+#include "WHLSLExpression.h"
+#include "WHLSLFallthrough.h"
+#include "WHLSLFloatLiteral.h"
+#include "WHLSLForLoop.h"
+#include "WHLSLFunctionAttribute.h"
+#include "WHLSLFunctionDeclaration.h"
+#include "WHLSLFunctionDefinition.h"
+#include "WHLSLIfStatement.h"
+#include "WHLSLIndexExpression.h"
+#include "WHLSLIntegerLiteral.h"
+#include "WHLSLLogicalExpression.h"
+#include "WHLSLLogicalNotExpression.h"
+#include "WHLSLMakeArrayReferenceExpression.h"
+#include "WHLSLMakePointerExpression.h"
+#include "WHLSLNativeFunctionDeclaration.h"
+#include "WHLSLNativeTypeDeclaration.h"
+#include "WHLSLNode.h"
+#include "WHLSLNullLiteral.h"
+#include "WHLSLNumThreadsFunctionAttribute.h"
+#include "WHLSLPointerType.h"
+#include "WHLSLProgram.h"
+#include "WHLSLPropertyAccessExpression.h"
+#include "WHLSLQualifier.h"
+#include "WHLSLReadModifyWriteExpression.h"
+#include "WHLSLReferenceType.h"
+#include "WHLSLResourceSemantic.h"
+#include "WHLSLReturn.h"
+#include "WHLSLSemantic.h"
+#include "WHLSLSpecializationConstantSemantic.h"
+#include "WHLSLStageInOutSemantic.h"
+#include "WHLSLStatement.h"
+#include "WHLSLStructureDefinition.h"
+#include "WHLSLStructureElement.h"
+#include "WHLSLSwitchCase.h"
+#include "WHLSLSwitchStatement.h"
+#include "WHLSLTernaryExpression.h"
+#include "WHLSLTrap.h"
+#include "WHLSLType.h"
+#include "WHLSLTypeArgument.h"
+#include "WHLSLTypeDefinition.h"
+#include "WHLSLTypeReference.h"
+#include "WHLSLUnsignedIntegerLiteral.h"
+#include "WHLSLValue.h"
+#include "WHLSLVariableDeclaration.h"
+#include "WHLSLVariableDeclarationsStatement.h"
+#include "WHLSLVariableReference.h"
+#include "WHLSLWhileLoop.h"
+
+namespace WebCore {
+
+namespace WHLSL {
+
+void Visitor::visit(Program& program)
+{
+ // These visiting functions might add new global statements, so don't use foreach syntax.
+ for (size_t i = 0; i < program.typeDefinitions().size(); ++i)
+ checkErrorAndVisit(static_cast<AST::TypeDefinition&>(program.typeDefinitions()[i]));
+ for (size_t i = 0; i < program.structureDefinitions().size(); ++i)
+ checkErrorAndVisit(static_cast<AST::StructureDefinition&>(program.structureDefinitions()[i]));
+ for (size_t i = 0; i < program.enumerationDefinitions().size(); ++i)
+ checkErrorAndVisit(static_cast<AST::EnumerationDefinition&>(program.enumerationDefinitions()[i]));
+ for (size_t i = 0; i < program.functionDefinitions().size(); ++i)
+ checkErrorAndVisit(static_cast<AST::FunctionDefinition&>(program.functionDefinitions()[i]));
+ for (size_t i = 0; i < program.nativeFunctionDeclarations().size(); ++i)
+ checkErrorAndVisit(static_cast<AST::NativeFunctionDeclaration&>(program.nativeFunctionDeclarations()[i]));
+ for (size_t i = 0; i < program.nativeTypeDeclarations().size(); ++i)
+ checkErrorAndVisit(static_cast<AST::NativeTypeDeclaration&>(program.nativeTypeDeclarations()[i]));
+}
+
+void Visitor::visit(AST::UnnamedType& unnamedType)
+{
+ if (is<AST::TypeReference>(unnamedType))
+ checkErrorAndVisit(downcast<AST::TypeReference>(unnamedType));
+ else if (is<AST::PointerType>(unnamedType))
+ checkErrorAndVisit(downcast<AST::PointerType>(unnamedType));
+ else if (is<AST::ArrayReferenceType>(unnamedType))
+ checkErrorAndVisit(downcast<AST::ArrayReferenceType>(unnamedType));
+ else {
+ ASSERT(is<AST::ArrayType>(unnamedType));
+ checkErrorAndVisit(downcast<AST::ArrayType>(unnamedType));
+ }
+}
+
+void Visitor::visit(AST::NamedType& namedType)
+{
+ if (is<AST::TypeDefinition>(namedType))
+ checkErrorAndVisit(downcast<AST::TypeDefinition>(namedType));
+ else if (is<AST::StructureDefinition>(namedType))
+ checkErrorAndVisit(downcast<AST::StructureDefinition>(namedType));
+ else if (is<AST::EnumerationDefinition>(namedType))
+ checkErrorAndVisit(downcast<AST::EnumerationDefinition>(namedType));
+ else {
+ ASSERT(is<AST::NativeTypeDeclaration>(namedType));
+ checkErrorAndVisit(downcast<AST::NativeTypeDeclaration>(namedType));
+ }
+}
+
+void Visitor::visit(AST::TypeDefinition& typeDefinition)
+{
+ checkErrorAndVisit(typeDefinition.type());
+}
+
+void Visitor::visit(AST::StructureDefinition& structureDefinition)
+{
+ for (auto& structureElement : structureDefinition.structureElements())
+ checkErrorAndVisit(structureElement);
+}
+
+void Visitor::visit(AST::EnumerationDefinition& enumerationDefinition)
+{
+ if (enumerationDefinition.type())
+ checkErrorAndVisit(static_cast<AST::UnnamedType&>(*enumerationDefinition.type()));
+ for (auto& enumerationMember : enumerationDefinition.enumerationMembers())
+ checkErrorAndVisit(enumerationMember);
+}
+
+void Visitor::visit(AST::FunctionDefinition& functionDefinition)
+{
+ checkErrorAndVisit(static_cast<AST::FunctionDeclaration&>(functionDefinition));
+ checkErrorAndVisit(functionDefinition.block());
+}
+
+void Visitor::visit(AST::NativeFunctionDeclaration& nativeFunctionDeclaration)
+{
+ checkErrorAndVisit(static_cast<AST::FunctionDeclaration&>(nativeFunctionDeclaration));
+}
+
+void Visitor::visit(AST::NativeTypeDeclaration& nativeTypeDeclaration)
+{
+ for (auto& typeArgument : nativeTypeDeclaration.typeArguments())
+ checkErrorAndVisit(typeArgument);
+}
+
+void Visitor::visit(AST::TypeReference& typeReference)
+{
+ for (auto& typeArgument : typeReference.typeArguments())
+ checkErrorAndVisit(typeArgument);
+ if (typeReference.resolvedType() && is<AST::TypeDefinition>(*typeReference.resolvedType())) {
+ auto& typeDefinition = downcast<AST::TypeDefinition>(*typeReference.resolvedType());
+ checkErrorAndVisit(typeDefinition.type());
+ }
+}
+
+void Visitor::visit(AST::PointerType& pointerType)
+{
+ checkErrorAndVisit(static_cast<AST::ReferenceType&>(pointerType));
+}
+
+void Visitor::visit(AST::ArrayReferenceType& arrayReferenceType)
+{
+ checkErrorAndVisit(static_cast<AST::ReferenceType&>(arrayReferenceType));
+}
+
+void Visitor::visit(AST::ArrayType& arrayType)
+{
+ checkErrorAndVisit(arrayType.type());
+}
+
+void Visitor::visit(AST::StructureElement& structureElement)
+{
+ checkErrorAndVisit(structureElement.type());
+ if (structureElement.semantic())
+ checkErrorAndVisit(*structureElement.semantic());
+}
+
+void Visitor::visit(AST::EnumerationMember& enumerationMember)
+{
+ if (enumerationMember.value())
+ checkErrorAndVisit(*enumerationMember.value());
+}
+
+void Visitor::visit(AST::FunctionDeclaration& functionDeclaration)
+{
+ checkErrorAndVisit(functionDeclaration.attributeBlock());
+ checkErrorAndVisit(functionDeclaration.type());
+ for (auto& parameter : functionDeclaration.parameters())
+ checkErrorAndVisit(parameter);
+ if (functionDeclaration.semantic())
+ checkErrorAndVisit(*functionDeclaration.semantic());
+}
+
+void Visitor::visit(AST::TypeArgument& typeArgument)
+{
+ WTF::visit(WTF::makeVisitor([&](AST::ConstantExpression& constantExpression) {
+ checkErrorAndVisit(constantExpression);
+ }, [&](UniqueRef<AST::TypeReference>& typeReference) {
+ checkErrorAndVisit(static_cast<AST::TypeReference&>(typeReference));
+ }), typeArgument);
+}
+
+void Visitor::visit(AST::ReferenceType& referenceType)
+{
+ checkErrorAndVisit(referenceType.elementType());
+}
+
+void Visitor::visit(AST::Semantic& semantic)
+{
+ WTF::visit(WTF::makeVisitor([&](AST::BuiltInSemantic& builtInSemantic) {
+ checkErrorAndVisit(builtInSemantic);
+ }, [&](AST::ResourceSemantic& resourceSemantic) {
+ checkErrorAndVisit(resourceSemantic);
+ }, [&](AST::SpecializationConstantSemantic& specializationConstantSemantic) {
+ checkErrorAndVisit(specializationConstantSemantic);
+ }, [&](AST::StageInOutSemantic& stageInOutSemantic) {
+ checkErrorAndVisit(stageInOutSemantic);
+ }), semantic);
+}
+
+void Visitor::visit(AST::ConstantExpression& constantExpression)
+{
+ constantExpression.visit(WTF::makeVisitor([&](AST::IntegerLiteral& integerLiteral) {
+ checkErrorAndVisit(integerLiteral);
+ }, [&](AST::UnsignedIntegerLiteral& unsignedIntegerLiteral) {
+ checkErrorAndVisit(unsignedIntegerLiteral);
+ }, [&](AST::FloatLiteral& floatLiteral) {
+ checkErrorAndVisit(floatLiteral);
+ }, [&](AST::NullLiteral& nullLiteral) {
+ checkErrorAndVisit(nullLiteral);
+ }, [&](AST::BooleanLiteral& booleanLiteral) {
+ checkErrorAndVisit(booleanLiteral);
+ }, [&](AST::ConstantExpressionEnumerationMemberReference& constantExpressionEnumerationMemberReference) {
+ checkErrorAndVisit(constantExpressionEnumerationMemberReference);
+ }));
+}
+
+void Visitor::visit(AST::AttributeBlock& attributeBlock)
+{
+ for (auto& functionAttribute : attributeBlock)
+ checkErrorAndVisit(functionAttribute);
+}
+
+void Visitor::visit(AST::BuiltInSemantic&)
+{
+}
+
+void Visitor::visit(AST::ResourceSemantic&)
+{
+}
+
+void Visitor::visit(AST::SpecializationConstantSemantic&)
+{
+}
+
+void Visitor::visit(AST::StageInOutSemantic&)
+{
+}
+
+void Visitor::visit(AST::IntegerLiteral& integerLiteral)
+{
+ checkErrorAndVisit(integerLiteral.type());
+}
+
+void Visitor::visit(AST::UnsignedIntegerLiteral& unsignedIntegerLiteral)
+{
+ checkErrorAndVisit(unsignedIntegerLiteral.type());
+}
+
+void Visitor::visit(AST::FloatLiteral& floatLiteral)
+{
+ checkErrorAndVisit(floatLiteral.type());
+}
+
+void Visitor::visit(AST::NullLiteral& nullLiteral)
+{
+ checkErrorAndVisit(nullLiteral.type());
+}
+
+void Visitor::visit(AST::BooleanLiteral&)
+{
+}
+
+void Visitor::visit(AST::IntegerLiteralType& integerLiteralType)
+{
+ if (integerLiteralType.resolvedType())
+ checkErrorAndVisit(*integerLiteralType.resolvedType());
+ checkErrorAndVisit(integerLiteralType.preferredType());
+}
+
+void Visitor::visit(AST::UnsignedIntegerLiteralType& unsignedIntegerLiteralType)
+{
+ if (unsignedIntegerLiteralType.resolvedType())
+ checkErrorAndVisit(*unsignedIntegerLiteralType.resolvedType());
+ checkErrorAndVisit(unsignedIntegerLiteralType.preferredType());
+}
+
+void Visitor::visit(AST::FloatLiteralType& floatLiteralType)
+{
+ if (floatLiteralType.resolvedType())
+ checkErrorAndVisit(*floatLiteralType.resolvedType());
+ checkErrorAndVisit(floatLiteralType.preferredType());
+}
+
+void Visitor::visit(AST::NullLiteralType& nullLiteralType)
+{
+ if (nullLiteralType.resolvedType())
+ checkErrorAndVisit(*nullLiteralType.resolvedType());
+}
+
+void Visitor::visit(AST::ConstantExpressionEnumerationMemberReference&)
+{
+}
+
+void Visitor::visit(AST::FunctionAttribute& functionAttribute)
+{
+ WTF::visit(WTF::makeVisitor([&](AST::NumThreadsFunctionAttribute& numThreadsFunctionAttribute) {
+ checkErrorAndVisit(numThreadsFunctionAttribute);
+ }), functionAttribute);
+}
+
+void Visitor::visit(AST::NumThreadsFunctionAttribute&)
+{
+}
+
+void Visitor::visit(AST::Block& block)
+{
+ for (auto& statement : block.statements())
+ checkErrorAndVisit(static_cast<AST::Statement&>(statement));
+}
+
+void Visitor::visit(AST::Statement& statement)
+{
+ if (is<AST::Block>(statement))
+ checkErrorAndVisit(downcast<AST::Block>(statement));
+ else if (is<AST::Break>(statement))
+ checkErrorAndVisit(downcast<AST::Break>(statement));
+ else if (is<AST::Continue>(statement))
+ checkErrorAndVisit(downcast<AST::Continue>(statement));
+ else if (is<AST::DoWhileLoop>(statement))
+ checkErrorAndVisit(downcast<AST::DoWhileLoop>(statement));
+ else if (is<AST::EffectfulExpressionStatement>(statement))
+ checkErrorAndVisit(downcast<AST::EffectfulExpressionStatement>(statement));
+ else if (is<AST::Fallthrough>(statement))
+ checkErrorAndVisit(downcast<AST::Fallthrough>(statement));
+ else if (is<AST::ForLoop>(statement))
+ checkErrorAndVisit(downcast<AST::ForLoop>(statement));
+ else if (is<AST::IfStatement>(statement))
+ checkErrorAndVisit(downcast<AST::IfStatement>(statement));
+ else if (is<AST::Return>(statement))
+ checkErrorAndVisit(downcast<AST::Return>(statement));
+ else if (is<AST::SwitchCase>(statement))
+ checkErrorAndVisit(downcast<AST::SwitchCase>(statement));
+ else if (is<AST::SwitchStatement>(statement))
+ checkErrorAndVisit(downcast<AST::SwitchStatement>(statement));
+ else if (is<AST::Trap>(statement))
+ checkErrorAndVisit(downcast<AST::Trap>(statement));
+ else if (is<AST::VariableDeclarationsStatement>(statement))
+ checkErrorAndVisit(downcast<AST::VariableDeclarationsStatement>(statement));
+ else {
+ ASSERT(is<AST::WhileLoop>(statement));
+ checkErrorAndVisit(downcast<AST::WhileLoop>(statement));
+ }
+}
+
+void Visitor::visit(AST::Break&)
+{
+}
+
+void Visitor::visit(AST::Continue&)
+{
+}
+
+void Visitor::visit(AST::DoWhileLoop& doWhileLoop)
+{
+ checkErrorAndVisit(doWhileLoop.body());
+ checkErrorAndVisit(doWhileLoop.conditional());
+}
+
+void Visitor::visit(AST::_expression_& _expression_)
+{
+ if (is<AST::AssignmentExpression>(_expression_))
+ checkErrorAndVisit(downcast<AST::AssignmentExpression>(_expression_));
+ else if (is<AST::BooleanLiteral>(_expression_))
+ checkErrorAndVisit(downcast<AST::BooleanLiteral>(_expression_));
+ else if (is<AST::CallExpression>(_expression_))
+ checkErrorAndVisit(downcast<AST::CallExpression>(_expression_));
+ else if (is<AST::CommaExpression>(_expression_))
+ checkErrorAndVisit(downcast<AST::CommaExpression>(_expression_));
+ else if (is<AST::DereferenceExpression>(_expression_))
+ checkErrorAndVisit(downcast<AST::DereferenceExpression>(_expression_));
+ else if (is<AST::FloatLiteral>(_expression_))
+ checkErrorAndVisit(downcast<AST::FloatLiteral>(_expression_));
+ else if (is<AST::IntegerLiteral>(_expression_))
+ checkErrorAndVisit(downcast<AST::IntegerLiteral>(_expression_));
+ else if (is<AST::LogicalExpression>(_expression_))
+ checkErrorAndVisit(downcast<AST::LogicalExpression>(_expression_));
+ else if (is<AST::LogicalNotExpression>(_expression_))
+ checkErrorAndVisit(downcast<AST::LogicalNotExpression>(_expression_));
+ else if (is<AST::MakeArrayReferenceExpression>(_expression_))
+ checkErrorAndVisit(downcast<AST::MakeArrayReferenceExpression>(_expression_));
+ else if (is<AST::MakePointerExpression>(_expression_))
+ checkErrorAndVisit(downcast<AST::MakePointerExpression>(_expression_));
+ else if (is<AST::NullLiteral>(_expression_))
+ checkErrorAndVisit(downcast<AST::NullLiteral>(_expression_));
+ else if (is<AST::DotExpression>(_expression_))
+ checkErrorAndVisit(downcast<AST::DotExpression>(_expression_));
+ else if (is<AST::IndexExpression>(_expression_))
+ checkErrorAndVisit(downcast<AST::IndexExpression>(_expression_));
+ else if (is<AST::ReadModifyWriteExpression>(_expression_))
+ checkErrorAndVisit(downcast<AST::ReadModifyWriteExpression>(_expression_));
+ else if (is<AST::TernaryExpression>(_expression_))
+ checkErrorAndVisit(downcast<AST::TernaryExpression>(_expression_));
+ else if (is<AST::UnsignedIntegerLiteral>(_expression_))
+ checkErrorAndVisit(downcast<AST::UnsignedIntegerLiteral>(_expression_));
+ else {
+ ASSERT(is<AST::VariableReference>(_expression_));
+ checkErrorAndVisit(downcast<AST::VariableReference>(_expression_));
+ }
+}
+
+void Visitor::visit(AST::DotExpression& dotExpression)
+{
+ checkErrorAndVisit(static_cast<AST::PropertyAccessExpression&>(dotExpression));
+}
+
+void Visitor::visit(AST::IndexExpression& indexExpression)
+{
+ checkErrorAndVisit(indexExpression.indexExpression());
+ checkErrorAndVisit(static_cast<AST::PropertyAccessExpression&>(indexExpression));
+}
+
+void Visitor::visit(AST::PropertyAccessExpression& _expression_)
+{
+ checkErrorAndVisit(_expression_.base());
+}
+
+void Visitor::visit(AST::EffectfulExpressionStatement& effectfulExpressionStatement)
+{
+ checkErrorAndVisit(effectfulExpressionStatement.effectfulExpression());
+}
+
+void Visitor::visit(AST::Fallthrough&)
+{
+}
+
+void Visitor::visit(AST::ForLoop& forLoop)
+{
+ WTF::visit(WTF::makeVisitor([&](AST::VariableDeclarationsStatement& variableDeclarationsStatement) {
+ checkErrorAndVisit(variableDeclarationsStatement);
+ }, [&](UniqueRef<AST::_expression_>& _expression_) {
+ checkErrorAndVisit(static_cast<AST::_expression_&>(_expression_));
+ }), forLoop.initialization());
+ if (forLoop.condition())
+ checkErrorAndVisit(*forLoop.condition());
+ if (forLoop.increment())
+ checkErrorAndVisit(*forLoop.increment());
+ checkErrorAndVisit(forLoop.body());
+}
+
+void Visitor::visit(AST::IfStatement& ifStatement)
+{
+ checkErrorAndVisit(ifStatement.conditional());
+ checkErrorAndVisit(ifStatement.body());
+ if (ifStatement.elseBody())
+ checkErrorAndVisit(static_cast<AST::Statement&>(*ifStatement.elseBody()));
+}
+
+void Visitor::visit(AST::Return& returnStatement)
+{
+ if (returnStatement.value())
+ checkErrorAndVisit(*returnStatement.value());
+}
+
+void Visitor::visit(AST::SwitchCase& switchCase)
+{
+ if (switchCase.value())
+ checkErrorAndVisit(*switchCase.value());
+ checkErrorAndVisit(switchCase.block());
+}
+
+void Visitor::visit(AST::SwitchStatement& switchStatement)
+{
+ checkErrorAndVisit(switchStatement.value());
+ for (auto& switchCase : switchStatement.switchCases())
+ checkErrorAndVisit(switchCase);
+}
+
+void Visitor::visit(AST::Trap&)
+{
+}
+
+void Visitor::visit(AST::VariableDeclarationsStatement& variableDeclarationsStatement)
+{
+ for (auto& variableDeclaration : variableDeclarationsStatement.variableDeclarations())
+ checkErrorAndVisit(variableDeclaration);
+}
+
+void Visitor::visit(AST::WhileLoop& whileLoop)
+{
+ checkErrorAndVisit(whileLoop.conditional());
+ checkErrorAndVisit(whileLoop.body());
+}
+
+void Visitor::visit(AST::VariableDeclaration& variableDeclaration)
+{
+ if (variableDeclaration.type())
+ checkErrorAndVisit(*variableDeclaration.type());
+ if (variableDeclaration.semantic())
+ checkErrorAndVisit(*variableDeclaration.semantic());
+ if (variableDeclaration.initializer())
+ checkErrorAndVisit(*variableDeclaration.initializer());
+}
+
+void Visitor::visit(AST::AssignmentExpression& assignmentExpression)
+{
+ checkErrorAndVisit(assignmentExpression.left());
+ checkErrorAndVisit(assignmentExpression.right());
+}
+
+void Visitor::visit(AST::CallExpression& callExpression)
+{
+ for (auto& argument : callExpression.arguments())
+ checkErrorAndVisit(static_cast<AST::_expression_&>(argument));
+ if (callExpression.castReturnType())
+ checkErrorAndVisit(callExpression.castReturnType()->get());
+}
+
+void Visitor::visit(AST::CommaExpression& commaExpression)
+{
+ for (auto& _expression_ : commaExpression.list())
+ checkErrorAndVisit(static_cast<AST::_expression_&>(_expression_));
+}
+
+void Visitor::visit(AST::DereferenceExpression& dereferenceExpression)
+{
+ checkErrorAndVisit(dereferenceExpression.pointer());
+}
+
+void Visitor::visit(AST::LogicalExpression& logicalExpression)
+{
+ checkErrorAndVisit(logicalExpression.left());
+ checkErrorAndVisit(logicalExpression.right());
+}
+
+void Visitor::visit(AST::LogicalNotExpression& logicalNotExpression)
+{
+ checkErrorAndVisit(logicalNotExpression.operand());
+}
+
+void Visitor::visit(AST::MakeArrayReferenceExpression& makeArrayReferenceExpression)
+{
+ checkErrorAndVisit(makeArrayReferenceExpression.lValue());
+}
+
+void Visitor::visit(AST::MakePointerExpression& makePointerExpression)
+{
+ checkErrorAndVisit(makePointerExpression.lValue());
+}
+
+void Visitor::visit(AST::ReadModifyWriteExpression& readModifyWriteExpression)
+{
+ checkErrorAndVisit(readModifyWriteExpression.lValue());
+ checkErrorAndVisit(readModifyWriteExpression.oldValue());
+ checkErrorAndVisit(readModifyWriteExpression.newValue());
+ if (readModifyWriteExpression.newValueExpression())
+ checkErrorAndVisit(*readModifyWriteExpression.newValueExpression());
+ if (readModifyWriteExpression.resultExpression())
+ checkErrorAndVisit(*readModifyWriteExpression.resultExpression());
+}
+
+void Visitor::visit(AST::TernaryExpression& ternaryExpression)
+{
+ checkErrorAndVisit(ternaryExpression.predicate());
+ checkErrorAndVisit(ternaryExpression.bodyExpression());
+ checkErrorAndVisit(ternaryExpression.elseExpression());
+}
+
+void Visitor::visit(AST::VariableReference&)
+{
+}
+
+}
+
+}
+
+#endif
Property changes on: trunk/Source/WebCore/Modules/webgpu/WHLSL/WHLSLVisitor.cpp
___________________________________________________________________
Added: svn:eol-style
+native
\ No newline at end of property
Added: trunk/Source/WebCore/Modules/webgpu/WHLSL/WHLSLVisitor.h (0 => 239893)
--- trunk/Source/WebCore/Modules/webgpu/WHLSL/WHLSLVisitor.h (rev 0)
+++ trunk/Source/WebCore/Modules/webgpu/WHLSL/WHLSLVisitor.h 2019-01-12 02:46:08 UTC (rev 239893)
@@ -0,0 +1,202 @@
+/*
+ * Copyright (C) 2019 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#pragma once
+
+#if ENABLE(WEBGPU)
+
+#include "WHLSLFunctionAttribute.h"
+#include "WHLSLSemantic.h"
+#include "WHLSLTypeArgument.h"
+
+namespace WebCore {
+
+namespace WHLSL {
+
+class Program;
+
+namespace AST {
+
+class TypeDefinition;
+class StructureDefinition;
+class EnumerationDefinition;
+class FunctionDefinition;
+class NativeFunctionDeclaration;
+class NativeTypeDeclaration;
+class TypeReference;
+class PointerType;
+class ArrayReferenceType;
+class ArrayType;
+class StructureElement;
+class EnumerationMember;
+class FunctionDeclaration;
+class ReferenceType;
+class ConstantExpression;
+class BuiltInSemantic;
+class ResourceSemantic;
+class SpecializationConstantSemantic;
+class StageInOutSemantic;
+class IntegerLiteral;
+class UnsignedIntegerLiteral;
+class FloatLiteral;
+class NullLiteral;
+class BooleanLiteral;
+class ConstantExpressionEnumerationMemberReference;
+class NumThreadsFunctionAttribute;
+class Block;
+class Statement;
+class Break;
+class Continue;
+class DoWhileLoop;
+class _expression_;
+class DotExpression;
+class IndexExpression;
+class PropertyAccessExpression;
+class EffectfulExpressionStatement;
+class Fallthrough;
+class ForLoop;
+class IfStatement;
+class Return;
+class SwitchCase;
+class SwitchStatement;
+class Trap;
+class VariableDeclarationsStatement;
+class WhileLoop;
+class VariableDeclaration;
+class AssignmentExpression;
+class CallExpression;
+class CommaExpression;
+class DereferenceExpression;
+class LogicalExpression;
+class LogicalNotExpression;
+class MakeArrayReferenceExpression;
+class MakePointerExpression;
+class ReadModifyWriteExpression;
+class TernaryExpression;
+class VariableReference;
+class UnnamedType;
+class NamedType;
+
+}
+
+class Visitor {
+public:
+ virtual ~Visitor() = default;
+
+ // FIXME: Add a way to visit a const Program
+
+ virtual void visit(Program&);
+ virtual void visit(AST::UnnamedType&);
+ virtual void visit(AST::NamedType&);
+ virtual void visit(AST::TypeDefinition&);
+ virtual void visit(AST::StructureDefinition&);
+ virtual void visit(AST::EnumerationDefinition&);
+ virtual void visit(AST::FunctionDefinition&);
+ virtual void visit(AST::NativeFunctionDeclaration&);
+ virtual void visit(AST::NativeTypeDeclaration&);
+ virtual void visit(AST::TypeReference&);
+ virtual void visit(AST::PointerType&);
+ virtual void visit(AST::ArrayReferenceType&);
+ virtual void visit(AST::ArrayType&);
+ virtual void visit(AST::StructureElement&);
+ virtual void visit(AST::EnumerationMember&);
+ virtual void visit(AST::FunctionDeclaration&);
+ virtual void visit(AST::TypeArgument&);
+ virtual void visit(AST::ReferenceType&);
+ virtual void visit(AST::Semantic&);
+ virtual void visit(AST::ConstantExpression&);
+ virtual void visit(AST::AttributeBlock&);
+ virtual void visit(AST::BuiltInSemantic&);
+ virtual void visit(AST::ResourceSemantic&);
+ virtual void visit(AST::SpecializationConstantSemantic&);
+ virtual void visit(AST::StageInOutSemantic&);
+ virtual void visit(AST::IntegerLiteral&);
+ virtual void visit(AST::UnsignedIntegerLiteral&);
+ virtual void visit(AST::FloatLiteral&);
+ virtual void visit(AST::NullLiteral&);
+ virtual void visit(AST::BooleanLiteral&);
+ virtual void visit(AST::IntegerLiteralType&);
+ virtual void visit(AST::UnsignedIntegerLiteralType&);
+ virtual void visit(AST::FloatLiteralType&);
+ virtual void visit(AST::NullLiteralType&);
+ virtual void visit(AST::ConstantExpressionEnumerationMemberReference&);
+ virtual void visit(AST::FunctionAttribute&);
+ virtual void visit(AST::NumThreadsFunctionAttribute&);
+ virtual void visit(AST::Block&);
+ virtual void visit(AST::Statement&);
+ virtual void visit(AST::Break&);
+ virtual void visit(AST::Continue&);
+ virtual void visit(AST::DoWhileLoop&);
+ virtual void visit(AST::_expression_&);
+ virtual void visit(AST::DotExpression&);
+ virtual void visit(AST::IndexExpression&);
+ virtual void visit(AST::PropertyAccessExpression&);
+ virtual void visit(AST::EffectfulExpressionStatement&);
+ virtual void visit(AST::Fallthrough&);
+ virtual void visit(AST::ForLoop&);
+ virtual void visit(AST::IfStatement&);
+ virtual void visit(AST::Return&);
+ virtual void visit(AST::SwitchCase&);
+ virtual void visit(AST::SwitchStatement&);
+ virtual void visit(AST::Trap&);
+ virtual void visit(AST::VariableDeclarationsStatement&);
+ virtual void visit(AST::WhileLoop&);
+ virtual void visit(AST::VariableDeclaration&);
+ virtual void visit(AST::AssignmentExpression&);
+ virtual void visit(AST::CallExpression&);
+ virtual void visit(AST::CommaExpression&);
+ virtual void visit(AST::DereferenceExpression&);
+ virtual void visit(AST::LogicalExpression&);
+ virtual void visit(AST::LogicalNotExpression&);
+ virtual void visit(AST::MakeArrayReferenceExpression&);
+ virtual void visit(AST::MakePointerExpression&);
+ virtual void visit(AST::ReadModifyWriteExpression&);
+ virtual void visit(AST::TernaryExpression&);
+ virtual void visit(AST::VariableReference&);
+
+ bool error() const { return m_error; }
+
+protected:
+ template<typename T> void checkErrorAndVisit(T& x)
+ {
+ if (!m_error)
+ visit(x);
+ }
+
+ void setError()
+ {
+ ASSERT(!m_error);
+ m_error = true;
+ }
+
+private:
+ bool m_error { false }; // FIXME: Migrate this to be some sort of descriptive string.
+};
+
+}
+
+}
+
+#endif
Property changes on: trunk/Source/WebCore/Modules/webgpu/WHLSL/WHLSLVisitor.h
___________________________________________________________________
Added: svn:eol-style
+native
\ No newline at end of property
Added: svn:keywords
+Author Date Id Rev URL
\ No newline at end of property
Modified: trunk/Source/WebCore/Sources.txt (239892 => 239893)
--- trunk/Source/WebCore/Sources.txt 2019-01-12 01:50:27 UTC (rev 239892)
+++ trunk/Source/WebCore/Sources.txt 2019-01-12 02:46:08 UTC (rev 239893)
@@ -308,6 +308,7 @@
Modules/webgpu/DOMWindowWebGPU.cpp
Modules/webgpu/WHLSL/WHLSLLexer.cpp
Modules/webgpu/WHLSL/WHLSLParser.cpp
+Modules/webgpu/WHLSL/WHLSLVisitor.cpp
Modules/webgpu/WHLSL/AST/WHLSLTypeArgument.cpp
Modules/webgpu/WHLSL/AST/WHLSLBuiltInSemantic.cpp
Modules/webgpu/WHLSL/AST/WHLSLResourceSemantic.cpp
Modified: trunk/Source/WebCore/WebCore.xcodeproj/project.pbxproj (239892 => 239893)
--- trunk/Source/WebCore/WebCore.xcodeproj/project.pbxproj 2019-01-12 01:50:27 UTC (rev 239892)
+++ trunk/Source/WebCore/WebCore.xcodeproj/project.pbxproj 2019-01-12 02:46:08 UTC (rev 239893)
@@ -13325,6 +13325,8 @@
C21BF74521CD969800227979 /* WHLSLStandardLibrary.txt */ = {isa = PBXFileReference; lastKnownFileType = text; path = WHLSLStandardLibrary.txt; sourceTree = "<group>"; };
C21DF2E71D9E4E9900F5B24C /* CSSFontVariationValue.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = CSSFontVariationValue.cpp; sourceTree = "<group>"; };
C21DF2E81D9E4E9900F5B24C /* CSSFontVariationValue.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CSSFontVariationValue.h; sourceTree = "<group>"; };
+ C234A98521E886A9003C984D /* WHLSLVisitor.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = WHLSLVisitor.cpp; sourceTree = "<group>"; };
+ C234A98721E886AD003C984D /* WHLSLVisitor.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WHLSLVisitor.h; sourceTree = "<group>"; };
C2458E611FE8979E00594759 /* FontCacheCoreText.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = FontCacheCoreText.h; sourceTree = "<group>"; };
C26017A11C72DC9900F74A16 /* CSSFontFaceSet.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = CSSFontFaceSet.cpp; sourceTree = "<group>"; };
C26017A21C72DC9900F74A16 /* CSSFontFaceSet.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CSSFontFaceSet.h; sourceTree = "<group>"; };
@@ -25394,6 +25396,8 @@
C21BF73821CD8A0300227979 /* WHLSLParser.h */,
C21BF73A21CD8D7000227979 /* WHLSLProgram.h */,
C21BF74521CD969800227979 /* WHLSLStandardLibrary.txt */,
+ C234A98521E886A9003C984D /* WHLSLVisitor.cpp */,
+ C234A98721E886AD003C984D /* WHLSLVisitor.h */,
);
path = WHLSL;
sourceTree = "<group>";
