Changeset 247110 in webkit


Ignore:
Timestamp:
Jul 3, 2019 3:11:36 PM (5 years ago)
Author:
rmorisset@apple.com
Message:

[WHLSL] "Semantic" should be held by a unique_ptr, not an Optional
​https://bugs.webkit.org/show_bug.cgi?id=199462

Reviewed by Myles C. Maxfield.

Most StructureElement, FunctionDeclaration and (especially) VariableDeclaration don't have a 'Semantic' field.
Using an Optional<Semantic> to represent this is a major memory waste, as Semantic is 56 bytes, so Optional<Semantic> is 64 bytes!
Putting one level of indirection through a unique_ptr thus saves 56 bytes for each VariableDeclaration (and FunctionDeclaration and StructureElement) that does not have a Semantic,
at the low cost of one pointer dereference when accessing the field for those that have one.

This patch also reorders the fields of FunctionDefinition to save another 8 bytes.

No new tests as there is no intended functional change.

  • Modules/webgpu/WHLSL/AST/WHLSLFunctionDeclaration.h:

(WebCore::WHLSL::AST::FunctionDeclaration::FunctionDeclaration):
(WebCore::WHLSL::AST::FunctionDeclaration::semantic):

  • Modules/webgpu/WHLSL/AST/WHLSLReadModifyWriteExpression.h:

(WebCore::WHLSL::AST::ReadModifyWriteExpression::ReadModifyWriteExpression):

  • Modules/webgpu/WHLSL/AST/WHLSLStructureElement.h:

(WebCore::WHLSL::AST::StructureElement::StructureElement):
(WebCore::WHLSL::AST::StructureElement::semantic):

  • Modules/webgpu/WHLSL/AST/WHLSLVariableDeclaration.h:

(WebCore::WHLSL::AST::VariableDeclaration::VariableDeclaration):
(WebCore::WHLSL::AST::VariableDeclaration::semantic):

  • Modules/webgpu/WHLSL/WHLSLChecker.cpp:

(WebCore::WHLSL::resolveWithOperatorAnderIndexer):
(WebCore::WHLSL::resolveWithOperatorLength):
(WebCore::WHLSL::resolveWithReferenceComparator):

  • Modules/webgpu/WHLSL/WHLSLGatherEntryPointItems.cpp:

(WebCore::WHLSL::Gatherer::visit):
(WebCore::WHLSL::gatherEntryPointItems):

  • Modules/webgpu/WHLSL/WHLSLParser.cpp:

(WebCore::WHLSL::Parser::parseSemantic):

  • Modules/webgpu/WHLSL/WHLSLParser.h:
  • Modules/webgpu/WHLSL/WHLSLPreserveVariableLifetimes.cpp:

(WebCore::WHLSL::preserveVariableLifetimes):

  • Modules/webgpu/WHLSL/WHLSLPropertyResolver.cpp:

(WebCore::WHLSL::wrapAnderCallArgument):
(WebCore::WHLSL::modify):
(WebCore::WHLSL::PropertyResolver::visit):

  • Modules/webgpu/WHLSL/WHLSLSynthesizeArrayOperatorLength.cpp:

(WebCore::WHLSL::synthesizeArrayOperatorLength):

  • Modules/webgpu/WHLSL/WHLSLSynthesizeConstructors.cpp:

(WebCore::WHLSL::synthesizeConstructors):

  • Modules/webgpu/WHLSL/WHLSLSynthesizeEnumerationFunctions.cpp:

(WebCore::WHLSL::synthesizeEnumerationFunctions):

  • Modules/webgpu/WHLSL/WHLSLSynthesizeStructureAccessors.cpp:

(WebCore::WHLSL::synthesizeStructureAccessors):

Location:
trunk/Source/WebCore
Files:
15 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r247105 r247110  
     12019-07-03  Robin Morisset  <rmorisset@apple.com>
     2
     3        [WHLSL] "Semantic" should be held by a unique_ptr, not an Optional
     4        https://bugs.webkit.org/show_bug.cgi?id=199462
     5
     6        Reviewed by Myles C. Maxfield.
     7
     8        Most StructureElement, FunctionDeclaration and (especially) VariableDeclaration don't have a 'Semantic' field.
     9        Using an Optional<Semantic> to represent this is a major memory waste, as Semantic is 56 bytes, so Optional<Semantic> is 64 bytes!
     10        Putting one level of indirection through a unique_ptr thus saves 56 bytes for each VariableDeclaration (and FunctionDeclaration and StructureElement) that does not have a Semantic,
     11        at the low cost of one pointer dereference when accessing the field for those that have one.
     12
     13        This patch also reorders the fields of FunctionDefinition to save another 8 bytes.
     14
     15        No new tests as there is no intended functional change.
     16
     17        * Modules/webgpu/WHLSL/AST/WHLSLFunctionDeclaration.h:
     18        (WebCore::WHLSL::AST::FunctionDeclaration::FunctionDeclaration):
     19        (WebCore::WHLSL::AST::FunctionDeclaration::semantic):
     20        * Modules/webgpu/WHLSL/AST/WHLSLReadModifyWriteExpression.h:
     21        (WebCore::WHLSL::AST::ReadModifyWriteExpression::ReadModifyWriteExpression):
     22        * Modules/webgpu/WHLSL/AST/WHLSLStructureElement.h:
     23        (WebCore::WHLSL::AST::StructureElement::StructureElement):
     24        (WebCore::WHLSL::AST::StructureElement::semantic):
     25        * Modules/webgpu/WHLSL/AST/WHLSLVariableDeclaration.h:
     26        (WebCore::WHLSL::AST::VariableDeclaration::VariableDeclaration):
     27        (WebCore::WHLSL::AST::VariableDeclaration::semantic):
     28        * Modules/webgpu/WHLSL/WHLSLChecker.cpp:
     29        (WebCore::WHLSL::resolveWithOperatorAnderIndexer):
     30        (WebCore::WHLSL::resolveWithOperatorLength):
     31        (WebCore::WHLSL::resolveWithReferenceComparator):
     32        * Modules/webgpu/WHLSL/WHLSLGatherEntryPointItems.cpp:
     33        (WebCore::WHLSL::Gatherer::visit):
     34        (WebCore::WHLSL::gatherEntryPointItems):
     35        * Modules/webgpu/WHLSL/WHLSLParser.cpp:
     36        (WebCore::WHLSL::Parser::parseSemantic):
     37        * Modules/webgpu/WHLSL/WHLSLParser.h:
     38        * Modules/webgpu/WHLSL/WHLSLPreserveVariableLifetimes.cpp:
     39        (WebCore::WHLSL::preserveVariableLifetimes):
     40        * Modules/webgpu/WHLSL/WHLSLPropertyResolver.cpp:
     41        (WebCore::WHLSL::wrapAnderCallArgument):
     42        (WebCore::WHLSL::modify):
     43        (WebCore::WHLSL::PropertyResolver::visit):
     44        * Modules/webgpu/WHLSL/WHLSLSynthesizeArrayOperatorLength.cpp:
     45        (WebCore::WHLSL::synthesizeArrayOperatorLength):
     46        * Modules/webgpu/WHLSL/WHLSLSynthesizeConstructors.cpp:
     47        (WebCore::WHLSL::synthesizeConstructors):
     48        * Modules/webgpu/WHLSL/WHLSLSynthesizeEnumerationFunctions.cpp:
     49        (WebCore::WHLSL::synthesizeEnumerationFunctions):
     50        * Modules/webgpu/WHLSL/WHLSLSynthesizeStructureAccessors.cpp:
     51        (WebCore::WHLSL::synthesizeStructureAccessors):
     52
    1532019-07-03  Robin Morisset  <rmorisset@apple.com>
    254

  • trunk/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLFunctionDeclaration.h

    r247105 r247110  
    4545class FunctionDeclaration {
    4646public:
    47     FunctionDeclaration(Lexer::Token&& origin, AttributeBlock&& attributeBlock, Optional<EntryPointType> entryPointType, UniqueRef<UnnamedType>&& type, String&& name, VariableDeclarations&& parameters, Optional<Semantic>&& semantic, bool isOperator)
     47    FunctionDeclaration(Lexer::Token&& origin, AttributeBlock&& attributeBlock, Optional<EntryPointType> entryPointType, UniqueRef<UnnamedType>&& type, String&& name, VariableDeclarations&& parameters, std::unique_ptr<Semantic>&& semantic, bool isOperator)
    4848        : m_origin(WTFMove(origin))
    4949        , m_attributeBlock(WTFMove(attributeBlock))
    5050        , m_entryPointType(entryPointType)
     51        , m_isOperator(WTFMove(isOperator))
    5152        , m_type(WTFMove(type))
    5253        , m_name(WTFMove(name))
    5354        , m_parameters(WTFMove(parameters))
    5455        , m_semantic(WTFMove(semantic))
    55         , m_isOperator(WTFMove(isOperator))
    5656    {
    5757    }
    … …  
    7474    const VariableDeclarations& parameters() const { return m_parameters; }
    7575    VariableDeclarations& parameters() { return m_parameters; }
    76     Optional<Semantic>& semantic() { return m_semantic; }
     76    Semantic* semantic() { return m_semantic.get(); }
    7777    bool isOperator() const { return m_isOperator; }
    7878    Lexer::Token origin() { return m_origin; }
    … …  
    8282    AttributeBlock m_attributeBlock;
    8383    Optional<EntryPointType> m_entryPointType;
     84    bool m_isOperator;
    8485    UniqueRef<UnnamedType> m_type;
    8586    String m_name;
    8687    VariableDeclarations m_parameters;
    87     Optional<Semantic> m_semantic;
    88     bool m_isOperator;
     88    std::unique_ptr<Semantic> m_semantic;
    8989};
    9090

  • trunk/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLReadModifyWriteExpression.h

    r247062 r247110  
    119119        : Expression(Lexer::Token(origin))
    120120        , m_leftValue(WTFMove(leftValue))
    121         , m_oldValue(makeUniqueRef<VariableDeclaration>(Lexer::Token(origin), Qualifiers(), WTF::nullopt, String(), WTF::nullopt, nullptr))
    122         , m_newValue(makeUniqueRef<VariableDeclaration>(WTFMove(origin), Qualifiers(), WTF::nullopt, String(), WTF::nullopt, nullptr))
     121        , m_oldValue(makeUniqueRef<VariableDeclaration>(Lexer::Token(origin), Qualifiers(), WTF::nullopt, String(), nullptr, nullptr))
     122        , m_newValue(makeUniqueRef<VariableDeclaration>(WTFMove(origin), Qualifiers(), WTF::nullopt, String(), nullptr, nullptr))
    123123    {
    124124    }

  • trunk/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLStructureElement.h

    r247105 r247110  
    4242class StructureElement {
    4343public:
    44     StructureElement(Lexer::Token&& origin, Qualifiers&& qualifiers, UniqueRef<UnnamedType>&& type, String&& name, Optional<Semantic> semantic)
     44    StructureElement(Lexer::Token&& origin, Qualifiers&& qualifiers, UniqueRef<UnnamedType>&& type, String&& name, std::unique_ptr<Semantic>&& semantic)
    4545        : m_origin(WTFMove(origin))
    4646        , m_qualifiers(WTFMove(qualifiers))
    … …  
    5959    UnnamedType& type() { return m_type; }
    6060    const String& name() { return m_name; }
    61     Optional<Semantic>& semantic() { return m_semantic; }
     61    Semantic* semantic() { return m_semantic.get(); }
    6262
    6363private:
    … …  
    6666    UniqueRef<UnnamedType> m_type;
    6767    String m_name;
    68     Optional<Semantic> m_semantic;
     68    std::unique_ptr<Semantic> m_semantic;
    6969};
    7070

  • trunk/Source/WebCore/Modules/webgpu/WHLSL/AST/WHLSLVariableDeclaration.h

    r247062 r247110  
    4848    using Base = Value;
    4949public:
    50     VariableDeclaration(Lexer::Token&& origin, Qualifiers&& qualifiers, Optional<UniqueRef<UnnamedType>>&& type, String&& name, Optional<Semantic>&& semantic, std::unique_ptr<Expression>&& initializer)
     50    VariableDeclaration(Lexer::Token&& origin, Qualifiers&& qualifiers, Optional<UniqueRef<UnnamedType>>&& type, String&& name, std::unique_ptr<Semantic>&& semantic, std::unique_ptr<Expression>&& initializer)
    5151        : Base(WTFMove(origin))
    5252        , m_qualifiers(WTFMove(qualifiers))
    … …  
    7575    const Optional<UniqueRef<UnnamedType>>& type() const { return m_type; }
    7676    UnnamedType* type() { return m_type ? &*m_type : nullptr; }
    77     Optional<Semantic>& semantic() { return m_semantic; }
     77    Semantic* semantic() { return m_semantic.get(); }
    7878    Expression* initializer() { return m_initializer.get(); }
    7979    bool isAnonymous() const { return m_name.isNull(); }
    … …  
    9090    Optional<UniqueRef<UnnamedType>> m_type;
    9191    String m_name;
    92     Optional<Semantic> m_semantic;
     92    std::unique_ptr<Semantic> m_semantic;
    9393    std::unique_ptr<Expression> m_initializer;
    9494};

  • trunk/Source/WebCore/Modules/webgpu/WHLSL/WHLSLChecker.cpp

    r247062 r247110  
    123123    auto returnType = makeUniqueRef<AST::PointerType>(Lexer::Token(origin), firstArgument.addressSpace(), firstArgument.elementType().clone());
    124124    AST::VariableDeclarations parameters;
    125     parameters.append(makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(origin), AST::Qualifiers(), firstArgument.clone(), String(), WTF::nullopt, nullptr));
    126     parameters.append(makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(origin), AST::Qualifiers(), UniqueRef<AST::UnnamedType>(AST::TypeReference::wrap(Lexer::Token(origin), intrinsics.uintType())), String(), WTF::nullopt, nullptr));
    127     return AST::NativeFunctionDeclaration(AST::FunctionDeclaration(Lexer::Token(origin), AST::AttributeBlock(), WTF::nullopt, WTFMove(returnType), String("operator&[]", String::ConstructFromLiteral), WTFMove(parameters), WTF::nullopt, isOperator));
     125    parameters.append(makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(origin), AST::Qualifiers(), firstArgument.clone(), String(), nullptr, nullptr));
     126    parameters.append(makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(origin), AST::Qualifiers(), UniqueRef<AST::UnnamedType>(AST::TypeReference::wrap(Lexer::Token(origin), intrinsics.uintType())), String(), nullptr, nullptr));
     127    return AST::NativeFunctionDeclaration(AST::FunctionDeclaration(Lexer::Token(origin), AST::AttributeBlock(), WTF::nullopt, WTFMove(returnType), String("operator&[]", String::ConstructFromLiteral), WTFMove(parameters), nullptr, isOperator));
    128128}
    129129
    … …  
    133133    auto returnType = AST::TypeReference::wrap(Lexer::Token(origin), intrinsics.uintType());
    134134    AST::VariableDeclarations parameters;
    135     parameters.append(makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(origin), AST::Qualifiers(), firstArgument.clone(), String(), WTF::nullopt, nullptr));
    136     return AST::NativeFunctionDeclaration(AST::FunctionDeclaration(Lexer::Token(origin), AST::AttributeBlock(), WTF::nullopt, WTFMove(returnType), String("operator.length", String::ConstructFromLiteral), WTFMove(parameters), WTF::nullopt, isOperator));
     135    parameters.append(makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(origin), AST::Qualifiers(), firstArgument.clone(), String(), nullptr, nullptr));
     136    return AST::NativeFunctionDeclaration(AST::FunctionDeclaration(Lexer::Token(origin), AST::AttributeBlock(), WTF::nullopt, WTFMove(returnType), String("operator.length", String::ConstructFromLiteral), WTFMove(parameters), nullptr, isOperator));
    137137}
    138138
    … …  
    154154    }));
    155155    AST::VariableDeclarations parameters;
    156     parameters.append(makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(origin), AST::Qualifiers(), argumentType->clone(), String(), WTF::nullopt, nullptr));
    157     parameters.append(makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(origin), AST::Qualifiers(), UniqueRef<AST::UnnamedType>(WTFMove(argumentType)), String(), WTF::nullopt, nullptr));
    158     return AST::NativeFunctionDeclaration(AST::FunctionDeclaration(Lexer::Token(origin), AST::AttributeBlock(), WTF::nullopt, WTFMove(returnType), String("operator==", String::ConstructFromLiteral), WTFMove(parameters), WTF::nullopt, isOperator));
     156    parameters.append(makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(origin), AST::Qualifiers(), argumentType->clone(), String(), nullptr, nullptr));
     157    parameters.append(makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(origin), AST::Qualifiers(), UniqueRef<AST::UnnamedType>(WTFMove(argumentType)), String(), nullptr, nullptr));
     158    return AST::NativeFunctionDeclaration(AST::FunctionDeclaration(Lexer::Token(origin), AST::AttributeBlock(), WTF::nullopt, WTFMove(returnType), String("operator==", String::ConstructFromLiteral), WTFMove(parameters), nullptr, isOperator));
    159159}
    160160

  • trunk/Source/WebCore/Modules/webgpu/WHLSL/WHLSLGatherEntryPointItems.cpp

    r246427 r247110  
    9898        for (auto& structureElement : structureDefinition.structureElements()) {
    9999            if (structureElement.semantic())
    100                 m_currentSemantic = &*structureElement.semantic();
     100                m_currentSemantic = structureElement.semantic();
    101101            m_path.append(structureElement.name());
    102102            checkErrorAndVisit(structureElement);
    … …  
    150150        ASSERT(!m_currentSemantic);
    151151        if (variableDeclaration.semantic())
    152             m_currentSemantic = &*variableDeclaration.semantic();
     152            m_currentSemantic = variableDeclaration.semantic();
    153153        ASSERT(variableDeclaration.type());
    154154        m_path.append(variableDeclaration.name());
    … …  
    175175            return WTF::nullopt;
    176176    }
    177     Gatherer outputGatherer(intrinsics, functionDefinition.semantic() ? &*functionDefinition.semantic() : nullptr);
     177    Gatherer outputGatherer(intrinsics, functionDefinition.semantic());
    178178    if (*functionDefinition.entryPointType() != AST::EntryPointType::Compute)
    179179        outputGatherer.checkErrorAndVisit(functionDefinition.type());

  • trunk/Source/WebCore/Modules/webgpu/WHLSL/WHLSLParser.cpp

    r247062 r247110  
    689689}
    690690
    691 auto Parser::parseSemantic() -> Expected<Optional<AST::Semantic>, Error>
     691auto Parser::parseSemantic() -> Expected<std::unique_ptr<AST::Semantic>, Error>
    692692{
    693693    if (!tryType(Lexer::Token::Type::Colon))
    694         return { WTF::nullopt };
     694        return { nullptr };
    695695
    696696    PEEK(token);
    … …  
    698698    case Lexer::Token::Type::Attribute: {
    699699        PARSE(result, StageInOutSemantic);
    700         return { AST::Semantic(WTFMove(*result)) };
     700        return { std::make_unique<AST::Semantic>(WTFMove(*result)) };
    701701    }
    702702    case Lexer::Token::Type::Specialized:  {
    703703        PARSE(result, SpecializationConstantSemantic);
    704         return { AST::Semantic(WTFMove(*result)) };
     704        return { std::make_unique<AST::Semantic>(WTFMove(*result)) };
    705705    }
    706706    case Lexer::Token::Type::Register:  {
    707707        PARSE(result, ResourceSemantic);
    708         return { AST::Semantic(WTFMove(*result)) };
     708        return { std::make_unique<AST::Semantic>(WTFMove(*result)) };
    709709    }
    710710    default:  {
    711711        PARSE(result, BuiltInSemantic);
    712         return { AST::Semantic(WTFMove(*result)) };
     712        return { std::make_unique<AST::Semantic>(WTFMove(*result)) };
    713713    }
    714714    }

  • trunk/Source/WebCore/Modules/webgpu/WHLSL/WHLSLParser.h

    r247105 r247110  
    175175    Expected<AST::SpecializationConstantSemantic, Error> parseSpecializationConstantSemantic();
    176176    Expected<AST::StageInOutSemantic, Error> parseStageInOutSemantic();
    177     Expected<Optional<AST::Semantic>, Error> parseSemantic();
     177    Expected<std::unique_ptr<AST::Semantic>, Error> parseSemantic();
    178178    AST::Qualifiers parseQualifiers();
    179179    Expected<AST::StructureElement, Error> parseStructureElement();

  • trunk/Source/WebCore/Modules/webgpu/WHLSL/WHLSLPreserveVariableLifetimes.cpp

    r247105 r247110  
    136136        if (isEntryPoint) {
    137137            auto structVariableDeclaration = makeUniqueRef<AST::VariableDeclaration>(functionDefinition.origin(), AST::Qualifiers(),
    138                 m_structType->clone(), String(), WTF::nullopt, nullptr);
     138                m_structType->clone(), String(), nullptr, nullptr);
    139139
    140140            auto structVariableReference = makeUniqueRef<AST::VariableReference>(AST::VariableReference::wrap(structVariableDeclaration));
    … …  
    151151
    152152            auto pointerDeclaration = makeUniqueRef<AST::VariableDeclaration>(functionDefinition.origin(), AST::Qualifiers(),
    153                 m_pointerToStructType->clone(), "wrapper"_s, WTF::nullopt, WTFMove(makePointerExpression));
     153                m_pointerToStructType->clone(), "wrapper"_s, nullptr, WTFMove(makePointerExpression));
    154154            m_structVariable = &pointerDeclaration;
    155155
    … …  
    162162        } else {
    163163            auto pointerDeclaration = makeUniqueRef<AST::VariableDeclaration>(functionDefinition.origin(), AST::Qualifiers(),
    164                 m_pointerToStructType->clone(), "wrapper"_s, WTF::nullopt, nullptr);
     164                m_pointerToStructType->clone(), "wrapper"_s, nullptr, nullptr);
    165165            m_structVariable = &pointerDeclaration;
    166166            functionDefinition.parameters().append(WTFMove(pointerDeclaration));
    … …  
    257257        auto* variable = pair.key;
    258258        String name = pair.value;
    259         elements.append(AST::StructureElement { Lexer::Token(variable->origin()), { }, variable->type()->clone(), WTFMove(name), WTF::nullopt });
     259        elements.append(AST::StructureElement { Lexer::Token(variable->origin()), { }, variable->type()->clone(), WTFMove(name), nullptr });
    260260    }
    261261

  • trunk/Source/WebCore/Modules/webgpu/WHLSL/WHLSLPropertyResolver.cpp

    r247105 r247110  
    110110    if (threadAnderFunction) {
    111111        auto origin = expression->origin();
    112         auto variableDeclaration = makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(origin), AST::Qualifiers(), baseType->clone(), String(), WTF::nullopt, nullptr);
     112        auto variableDeclaration = makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(origin), AST::Qualifiers(), baseType->clone(), String(), nullptr, nullptr);
    113113
    114114        auto variableReference1 = makeUniqueRef<AST::VariableReference>(AST::VariableReference::wrap(variableDeclaration));
    … …  
    314314
    315315    // Create "p" variable.
    316     auto pointerVariable = makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(leftExpression->origin()), AST::Qualifiers(), UniqueRef<AST::UnnamedType>(makeUniqueRef<AST::PointerType>(Lexer::Token(leftExpression->origin()), *leftExpression->typeAnnotation().leftAddressSpace(), leftExpression->resolvedType().clone())), String(), WTF::nullopt, nullptr);
     316    auto pointerVariable = makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(leftExpression->origin()), AST::Qualifiers(), UniqueRef<AST::UnnamedType>(makeUniqueRef<AST::PointerType>(Lexer::Token(leftExpression->origin()), *leftExpression->typeAnnotation().leftAddressSpace(), leftExpression->resolvedType().clone())), String(), nullptr, nullptr);
    317317
    318318    // Create "q" and "r" variables.
    … …  
    321321    for (size_t i = 1; i < chain.size(); ++i) {
    322322        auto& propertyAccessExpression = static_cast<AST::PropertyAccessExpression&>(chain[i]);
    323         intermediateVariables.uncheckedAppend(makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(propertyAccessExpression.origin()), AST::Qualifiers(), propertyAccessExpression.resolvedType().clone(), String(), WTF::nullopt, nullptr));
     323        intermediateVariables.uncheckedAppend(makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(propertyAccessExpression.origin()), AST::Qualifiers(), propertyAccessExpression.resolvedType().clone(), String(), nullptr, nullptr));
    324324    }
    325325
    … …  
    352352        }
    353353        auto& indexExpression = downcast<AST::IndexExpression>(propertyAccessExpression);
    354         indexVariables.uncheckedAppend(makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(propertyAccessExpression.origin()), AST::Qualifiers(), indexExpression.indexExpression().resolvedType().clone(), String(), WTF::nullopt, nullptr));
     354        indexVariables.uncheckedAppend(makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(propertyAccessExpression.origin()), AST::Qualifiers(), indexExpression.indexExpression().resolvedType().clone(), String(), nullptr, nullptr));
    355355    }
    356356
    … …  
    564564        auto pointerType = makeUniqueRef<AST::PointerType>(Lexer::Token(readModifyWriteExpression.leftValue().origin()), *readModifyWriteExpression.leftValue().typeAnnotation().leftAddressSpace(), baseType->clone());
    565565
    566         auto pointerVariable = makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(readModifyWriteExpression.leftValue().origin()), AST::Qualifiers(), UniqueRef<AST::UnnamedType>(pointerType->clone()), String(), WTF::nullopt, nullptr);
     566        auto pointerVariable = makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(readModifyWriteExpression.leftValue().origin()), AST::Qualifiers(), UniqueRef<AST::UnnamedType>(pointerType->clone()), String(), nullptr, nullptr);
    567567
    568568        Vector<UniqueRef<AST::Expression>> expressions;

  • trunk/Source/WebCore/Modules/webgpu/WHLSL/WHLSLSynthesizeArrayOperatorLength.cpp

    r247062 r247110  
    6666
    6767    for (auto& arrayType : arrayTypes) {
    68         auto variableDeclaration = makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(arrayType.get().origin()), AST::Qualifiers(), arrayType.get().clone(), String(), WTF::nullopt, nullptr);
     68        auto variableDeclaration = makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(arrayType.get().origin()), AST::Qualifiers(), arrayType.get().clone(), String(), nullptr, nullptr);
    6969        AST::VariableDeclarations parameters;
    7070        parameters.append(WTFMove(variableDeclaration));
    71         AST::NativeFunctionDeclaration nativeFunctionDeclaration(AST::FunctionDeclaration(Lexer::Token(arrayType.get().origin()), AST::AttributeBlock(), WTF::nullopt, AST::TypeReference::wrap(Lexer::Token(arrayType.get().origin()), program.intrinsics().uintType()), "operator.length"_str, WTFMove(parameters), WTF::nullopt, isOperator));
     71        AST::NativeFunctionDeclaration nativeFunctionDeclaration(AST::FunctionDeclaration(Lexer::Token(arrayType.get().origin()), AST::AttributeBlock(), WTF::nullopt, AST::TypeReference::wrap(Lexer::Token(arrayType.get().origin()), program.intrinsics().uintType()), "operator.length"_str, WTFMove(parameters), nullptr, isOperator));
    7272        if (!program.append(WTFMove(nativeFunctionDeclaration)))
    7373            return false;

  • trunk/Source/WebCore/Modules/webgpu/WHLSL/WHLSLSynthesizeConstructors.cpp

    r247062 r247110  
    158158        auto& unnamedType = unnamedTypeKey.unnamedType();
    159159
    160         auto variableDeclaration = makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(unnamedType.origin()), AST::Qualifiers(), unnamedType.clone(), String(), WTF::nullopt, nullptr);
     160        auto variableDeclaration = makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(unnamedType.origin()), AST::Qualifiers(), unnamedType.clone(), String(), nullptr, nullptr);
    161161        AST::VariableDeclarations parameters;
    162162        parameters.append(WTFMove(variableDeclaration));
    163         AST::NativeFunctionDeclaration copyConstructor(AST::FunctionDeclaration(Lexer::Token(unnamedType.origin()), AST::AttributeBlock(), WTF::nullopt, unnamedType.clone(), "operator cast"_str, WTFMove(parameters), WTF::nullopt, isOperator));
     163        AST::NativeFunctionDeclaration copyConstructor(AST::FunctionDeclaration(Lexer::Token(unnamedType.origin()), AST::AttributeBlock(), WTF::nullopt, unnamedType.clone(), "operator cast"_str, WTFMove(parameters), nullptr, isOperator));
    164164        program.append(WTFMove(copyConstructor));
    165165
    166         AST::NativeFunctionDeclaration defaultConstructor(AST::FunctionDeclaration(Lexer::Token(unnamedType.origin()), AST::AttributeBlock(), WTF::nullopt, unnamedType.clone(), "operator cast"_str, AST::VariableDeclarations(), WTF::nullopt, isOperator));
     166        AST::NativeFunctionDeclaration defaultConstructor(AST::FunctionDeclaration(Lexer::Token(unnamedType.origin()), AST::AttributeBlock(), WTF::nullopt, unnamedType.clone(), "operator cast"_str, AST::VariableDeclarations(), nullptr, isOperator));
    167167        if (!program.append(WTFMove(defaultConstructor)))
    168168            return false;
    … …  
    175175            continue;
    176176
    177         auto variableDeclaration = makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(namedType.get().origin()), AST::Qualifiers(), UniqueRef<AST::UnnamedType>(AST::TypeReference::wrap(Lexer::Token(namedType.get().origin()), namedType.get())), String(), WTF::nullopt, nullptr);
     177        auto variableDeclaration = makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(namedType.get().origin()), AST::Qualifiers(), UniqueRef<AST::UnnamedType>(AST::TypeReference::wrap(Lexer::Token(namedType.get().origin()), namedType.get())), String(), nullptr, nullptr);
    178178        AST::VariableDeclarations parameters;
    179179        parameters.append(WTFMove(variableDeclaration));
    180         AST::NativeFunctionDeclaration copyConstructor(AST::FunctionDeclaration(Lexer::Token(namedType.get().origin()), AST::AttributeBlock(), WTF::nullopt, AST::TypeReference::wrap(Lexer::Token(namedType.get().origin()), namedType.get()), "operator cast"_str, WTFMove(parameters), WTF::nullopt, isOperator));
     180        AST::NativeFunctionDeclaration copyConstructor(AST::FunctionDeclaration(Lexer::Token(namedType.get().origin()), AST::AttributeBlock(), WTF::nullopt, AST::TypeReference::wrap(Lexer::Token(namedType.get().origin()), namedType.get()), "operator cast"_str, WTFMove(parameters), nullptr, isOperator));
    181181        program.append(WTFMove(copyConstructor));
    182182
    … …  
    186186                continue;
    187187        }
    188         AST::NativeFunctionDeclaration defaultConstructor(AST::FunctionDeclaration(Lexer::Token(namedType.get().origin()), AST::AttributeBlock(), WTF::nullopt, AST::TypeReference::wrap(Lexer::Token(namedType.get().origin()), namedType.get()), "operator cast"_str, AST::VariableDeclarations(), WTF::nullopt, isOperator));
     188        AST::NativeFunctionDeclaration defaultConstructor(AST::FunctionDeclaration(Lexer::Token(namedType.get().origin()), AST::AttributeBlock(), WTF::nullopt, AST::TypeReference::wrap(Lexer::Token(namedType.get().origin()), namedType.get()), "operator cast"_str, AST::VariableDeclarations(), nullptr, isOperator));
    189189        if (!program.append(WTFMove(defaultConstructor)))
    190190            return false;

  • trunk/Source/WebCore/Modules/webgpu/WHLSL/WHLSLSynthesizeEnumerationFunctions.cpp

    r247062 r247110  
    4242    for (auto& enumerationDefinition : program.enumerationDefinitions()) {
    4343        {
    44             auto variableDeclaration1 = makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(enumerationDefinition->origin()), AST::Qualifiers(), UniqueRef<AST::UnnamedType>(AST::TypeReference::wrap(Lexer::Token(enumerationDefinition->origin()), enumerationDefinition)), String(), WTF::nullopt, nullptr);
    45             auto variableDeclaration2 = makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(enumerationDefinition->origin()), AST::Qualifiers(), UniqueRef<AST::UnnamedType>(AST::TypeReference::wrap(Lexer::Token(enumerationDefinition->origin()), enumerationDefinition)), String(), WTF::nullopt, nullptr);
     44            auto variableDeclaration1 = makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(enumerationDefinition->origin()), AST::Qualifiers(), UniqueRef<AST::UnnamedType>(AST::TypeReference::wrap(Lexer::Token(enumerationDefinition->origin()), enumerationDefinition)), String(), nullptr, nullptr);
     45            auto variableDeclaration2 = makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(enumerationDefinition->origin()), AST::Qualifiers(), UniqueRef<AST::UnnamedType>(AST::TypeReference::wrap(Lexer::Token(enumerationDefinition->origin()), enumerationDefinition)), String(), nullptr, nullptr);
    4646            AST::VariableDeclarations parameters;
    4747            parameters.append(WTFMove(variableDeclaration1));
    4848            parameters.append(WTFMove(variableDeclaration2));
    49             AST::NativeFunctionDeclaration nativeFunctionDeclaration(AST::FunctionDeclaration(Lexer::Token(enumerationDefinition->origin()), AST::AttributeBlock(), WTF::nullopt, AST::TypeReference::wrap(Lexer::Token(enumerationDefinition->origin()), program.intrinsics().boolType()), "operator=="_str, WTFMove(parameters), WTF::nullopt, isOperator));
     49            AST::NativeFunctionDeclaration nativeFunctionDeclaration(AST::FunctionDeclaration(Lexer::Token(enumerationDefinition->origin()), AST::AttributeBlock(), WTF::nullopt, AST::TypeReference::wrap(Lexer::Token(enumerationDefinition->origin()), program.intrinsics().boolType()), "operator=="_str, WTFMove(parameters), nullptr, isOperator));
    5050            if (!program.append(WTFMove(nativeFunctionDeclaration)))
    5151                return false;
    … …  
    5353
    5454        {
    55             auto variableDeclaration = makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(enumerationDefinition->origin()), AST::Qualifiers(), UniqueRef<AST::UnnamedType>(AST::TypeReference::wrap(Lexer::Token(enumerationDefinition->origin()), enumerationDefinition)), String(), WTF::nullopt, nullptr);
     55            auto variableDeclaration = makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(enumerationDefinition->origin()), AST::Qualifiers(), UniqueRef<AST::UnnamedType>(AST::TypeReference::wrap(Lexer::Token(enumerationDefinition->origin()), enumerationDefinition)), String(), nullptr, nullptr);
    5656            AST::VariableDeclarations parameters;
    5757            parameters.append(WTFMove(variableDeclaration));
    58             AST::NativeFunctionDeclaration nativeFunctionDeclaration(AST::FunctionDeclaration(Lexer::Token(enumerationDefinition->origin()), AST::AttributeBlock(), WTF::nullopt, enumerationDefinition->type().clone(), "operator.value"_str, WTFMove(parameters), WTF::nullopt, isOperator));
     58            AST::NativeFunctionDeclaration nativeFunctionDeclaration(AST::FunctionDeclaration(Lexer::Token(enumerationDefinition->origin()), AST::AttributeBlock(), WTF::nullopt, enumerationDefinition->type().clone(), "operator.value"_str, WTFMove(parameters), nullptr, isOperator));
    5959            if (!program.append(WTFMove(nativeFunctionDeclaration)))
    6060                return false;
    … …  
    6262
    6363        {
    64             auto variableDeclaration = makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(enumerationDefinition->origin()), AST::Qualifiers(), UniqueRef<AST::UnnamedType>(AST::TypeReference::wrap(Lexer::Token(enumerationDefinition->origin()), enumerationDefinition)), String(), WTF::nullopt, nullptr);
     64            auto variableDeclaration = makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(enumerationDefinition->origin()), AST::Qualifiers(), UniqueRef<AST::UnnamedType>(AST::TypeReference::wrap(Lexer::Token(enumerationDefinition->origin()), enumerationDefinition)), String(), nullptr, nullptr);
    6565            AST::VariableDeclarations parameters;
    6666            parameters.append(WTFMove(variableDeclaration));
    67             AST::NativeFunctionDeclaration nativeFunctionDeclaration(AST::FunctionDeclaration(Lexer::Token(enumerationDefinition->origin()), AST::AttributeBlock(), WTF::nullopt, enumerationDefinition->type().clone(), "operator cast"_str, WTFMove(parameters), WTF::nullopt, isOperator));
     67            AST::NativeFunctionDeclaration nativeFunctionDeclaration(AST::FunctionDeclaration(Lexer::Token(enumerationDefinition->origin()), AST::AttributeBlock(), WTF::nullopt, enumerationDefinition->type().clone(), "operator cast"_str, WTFMove(parameters), nullptr, isOperator));
    6868            if (!program.append(WTFMove(nativeFunctionDeclaration)))
    6969                return false;
    … …  
    7171
    7272        {
    73             auto variableDeclaration = makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(enumerationDefinition->origin()), AST::Qualifiers(), enumerationDefinition->type().clone(), String(), WTF::nullopt, nullptr);
     73            auto variableDeclaration = makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(enumerationDefinition->origin()), AST::Qualifiers(), enumerationDefinition->type().clone(), String(), nullptr, nullptr);
    7474            AST::VariableDeclarations parameters;
    7575            parameters.append(WTFMove(variableDeclaration));
    76             AST::NativeFunctionDeclaration nativeFunctionDeclaration(AST::FunctionDeclaration(Lexer::Token(enumerationDefinition->origin()), AST::AttributeBlock(), WTF::nullopt, UniqueRef<AST::UnnamedType>(AST::TypeReference::wrap(Lexer::Token(enumerationDefinition->origin()), enumerationDefinition)), "operator cast"_str, WTFMove(parameters), WTF::nullopt, isOperator));
     76            AST::NativeFunctionDeclaration nativeFunctionDeclaration(AST::FunctionDeclaration(Lexer::Token(enumerationDefinition->origin()), AST::AttributeBlock(), WTF::nullopt, UniqueRef<AST::UnnamedType>(AST::TypeReference::wrap(Lexer::Token(enumerationDefinition->origin()), enumerationDefinition)), "operator cast"_str, WTFMove(parameters), nullptr, isOperator));
    7777            if (!program.append(WTFMove(nativeFunctionDeclaration)))
    7878                return false;

  • trunk/Source/WebCore/Modules/webgpu/WHLSL/WHLSLSynthesizeStructureAccessors.cpp

    r247062 r247110  
    4848            auto createAnder = [&](AST::AddressSpace addressSpace) -> AST::NativeFunctionDeclaration {
    4949                auto argumentType = makeUniqueRef<AST::PointerType>(Lexer::Token(structureElement.origin()), addressSpace, AST::TypeReference::wrap(Lexer::Token(structureElement.origin()), structureDefinition));
    50                 auto variableDeclaration = makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(structureElement.origin()), AST::Qualifiers(), UniqueRef<AST::UnnamedType>(WTFMove(argumentType)), String(), WTF::nullopt, nullptr);
     50                auto variableDeclaration = makeUniqueRef<AST::VariableDeclaration>(Lexer::Token(structureElement.origin()), AST::Qualifiers(), UniqueRef<AST::UnnamedType>(WTFMove(argumentType)), String(), nullptr, nullptr);
    5151                AST::VariableDeclarations parameters;
    5252                parameters.append(WTFMove(variableDeclaration));
    5353                auto returnType = makeUniqueRef<AST::PointerType>(Lexer::Token(structureElement.origin()), addressSpace, structureElement.type().clone());
    54                 AST::NativeFunctionDeclaration nativeFunctionDeclaration(AST::FunctionDeclaration(Lexer::Token(structureElement.origin()), AST::AttributeBlock(), WTF::nullopt, WTFMove(returnType), makeString("operator&.", structureElement.name()), WTFMove(parameters), WTF::nullopt, isOperator));
     54                AST::NativeFunctionDeclaration nativeFunctionDeclaration(AST::FunctionDeclaration(Lexer::Token(structureElement.origin()), AST::AttributeBlock(), WTF::nullopt, WTFMove(returnType), makeString("operator&.", structureElement.name()), WTFMove(parameters), nullptr, isOperator));
    5555                return nativeFunctionDeclaration;
    5656            };
Note: See TracChangeset for help on using the changeset viewer.