Lines Matching defs:const
60 static const int32_t SKSL_MAGIC = 0x001F0000;
203 out.write((const char*) &word, sizeof(word));
206 static bool is_float(const Context& context, const Type& type) {
211 static bool is_signed(const Context& context, const Type& type) {
215 static bool is_unsigned(const Context& context, const Type& type) {
219 static bool is_bool(const Context& context, const Type& type) {
223 static bool is_out(const Modifiers& m) {
227 static bool is_in(const Modifiers& m) {
443 SpvId SPIRVCodeGenerator::nextId(const Type* type) {
457 void SPIRVCodeGenerator::writeStruct(const Type& type, const MemoryLayout& memoryLayout,
463 for (const auto& f : type.fields()) {
473 const Type::Field& field = type.fields()[i];
481 const Layout& fieldLayout = field.fModifiers.fLayout;
524 const Type& SPIRVCodeGenerator::getActualType(const Type& type) {
548 SpvId SPIRVCodeGenerator::getType(const Type& type) {
552 SpvId SPIRVCodeGenerator::getType(const Type& rawType, const MemoryLayout& layout) {
553 const Type* type;
561 const Type& component = this->getActualType(rawType.componentType());
684 SpvId SPIRVCodeGenerator::getImageType(const Type& type) {
692 SpvId SPIRVCodeGenerator::getFunctionType(const FunctionDeclaration& function) {
695 const std::vector<const Variable*>& parameters = function.parameters();
746 SpvId SPIRVCodeGenerator::getPointerType(const Type& type, SpvStorageClass_ storageClass) {
750 SpvId SPIRVCodeGenerator::getPointerType(const Type& rawType, const MemoryLayout& layout,
752 const Type& type = this->getActualType(rawType);
765 SpvId SPIRVCodeGenerator::writeExpression(const Expression& expr, OutputStream& out) {
811 SpvId SPIRVCodeGenerator::writeIntrinsicCall(const FunctionCall& c, OutputStream& out) {
812 const FunctionDeclaration& function = c.function();
819 const ExpressionArray& arguments = c.arguments();
821 const Type& type = arguments[0]->type();
907 SpvId SPIRVCodeGenerator::vectorize(const Expression& arg, int vectorSize, OutputStream& out) {
909 const Type& argType = arg.type();
929 std::vector<SpvId> SPIRVCodeGenerator::vectorize(const ExpressionArray& args, OutputStream& out) {
931 for (const auto& a : args) {
942 for (const auto& arg : args) {
948 void SPIRVCodeGenerator::writeGLSLExtendedInstruction(const Type& type, SpvId id, SpvId floatInst,
950 const std::vector<SpvId>& args,
971 SpvId SPIRVCodeGenerator::writeSpecialIntrinsic(const FunctionCall& c, SpecialIntrinsic kind,
973 const ExpressionArray& arguments = c.arguments();
974 const Type& callType = c.type();
980 for (const std::unique_ptr<Expression>& arg : arguments) {
1036 const Type& arg1Type = arguments[1]->type();
1089 const Type& operandType = arguments[0]->type();
1199 SpvId SPIRVCodeGenerator::writeFunctionCallArgument(const Expression& arg,
1200 const Modifiers& paramModifiers,
1239 void SPIRVCodeGenerator::copyBackTempVars(const std::vector<TempVar>& tempVars, OutputStream& out) {
1240 for (const TempVar& tempVar : tempVars) {
1247 SpvId SPIRVCodeGenerator::writeFunctionCall(const FunctionCall& c, OutputStream& out) {
1248 const FunctionDeclaration& function = c.function();
1252 const ExpressionArray& arguments = c.arguments();
1253 const auto& entry = fFunctionMap.find(&function);
1282 SpvId SPIRVCodeGenerator::writeConstantVector(const AnyConstructor& c) {
1283 const Type& type = c.type();
1290 const Type& scalarType = type.componentType();
1317 const Type& inputType,
1318 const Type& outputType,
1338 SpvId SPIRVCodeGenerator::writeFloatConstructor(const AnyConstructor& c, OutputStream& out) {
1341 const Expression& ctorExpr = *c.argumentSpan().front();
1346 SpvId SPIRVCodeGenerator::castScalarToFloat(SpvId inputId, const Type& inputType,
1347 const Type& outputType, OutputStream& out) {
1357 const SpvId oneID = this->writeLiteral(1.0, *fContext.fTypes.fFloat);
1358 const SpvId zeroID = this->writeLiteral(0.0, *fContext.fTypes.fFloat);
1372 SpvId SPIRVCodeGenerator::writeIntConstructor(const AnyConstructor& c, OutputStream& out) {
1375 const Expression& ctorExpr = *c.argumentSpan().front();
1380 SpvId SPIRVCodeGenerator::castScalarToSignedInt(SpvId inputId, const Type& inputType,
1381 const Type& outputType, OutputStream& out) {
1391 const SpvId oneID = this->writeLiteral(1.0, *fContext.fTypes.fInt);
1392 const SpvId zeroID = this->writeLiteral(0.0, *fContext.fTypes.fInt);
1407 SpvId SPIRVCodeGenerator::writeUIntConstructor(const AnyConstructor& c, OutputStream& out) {
1410 const Expression& ctorExpr = *c.argumentSpan().front();
1415 SpvId SPIRVCodeGenerator::castScalarToUnsignedInt(SpvId inputId, const Type& inputType,
1416 const Type& outputType, OutputStream& out) {
1426 const SpvId oneID = this->writeLiteral(1.0, *fContext.fTypes.fUInt);
1427 const SpvId zeroID = this->writeLiteral(0.0, *fContext.fTypes.fUInt);
1442 SpvId SPIRVCodeGenerator::writeBooleanConstructor(const AnyConstructor& c, OutputStream& out) {
1445 const Expression& ctorExpr = *c.argumentSpan().front();
1450 SpvId SPIRVCodeGenerator::castScalarToBoolean(SpvId inputId, const Type& inputType,
1451 const Type& outputType, OutputStream& out) {
1461 const SpvId zeroID = this->writeLiteral(0.0, *fContext.fTypes.fInt);
1466 const SpvId zeroID = this->writeLiteral(0.0, *fContext.fTypes.fUInt);
1471 const SpvId zeroID = this->writeLiteral(0.0, *fContext.fTypes.fFloat);
1481 void SPIRVCodeGenerator::writeUniformScaleMatrix(SpvId id, SpvId diagonal, const Type& type,
1508 SpvId SPIRVCodeGenerator::writeMatrixCopy(SpvId src, const Type& srcType, const Type& dstType,
1521 const SpvId zeroId = this->writeLiteral(0.0, dstType.componentType());
1522 const SpvId oneId = this->writeLiteral(1.0, dstType.componentType());
1581 void SPIRVCodeGenerator::addColumnEntry(const Type& columnType,
1597 SpvId SPIRVCodeGenerator::writeMatrixConstructor(const ConstructorCompound& c, OutputStream& out) {
1598 const Type& type = c.type();
1601 const Type& arg0Type = c.arguments()[0]->type();
1606 for (const std::unique_ptr<Expression>& arg : c.arguments()) {
1621 const Type& vecType = type.componentType().toCompound(fContext, /*columns=*/2, /*rows=*/1);
1628 const Type& columnType = type.componentType().toCompound(fContext,
1635 const Type& argType = c.arguments()[i]->type();
1657 SpvId SPIRVCodeGenerator::writeConstructorCompound(const ConstructorCompound& c,
1663 SpvId SPIRVCodeGenerator::writeVectorConstructor(const ConstructorCompound& c, OutputStream& out) {
1664 const Type& type = c.type();
1665 const Type& componentType = type.componentType();
1675 const Type& argType = c.arguments()[i]->type();
1708 SpvId SPIRVCodeGenerator::writeComposite(const std::vector<SpvId>& arguments,
1709 const Type& type,
1723 SpvId SPIRVCodeGenerator::writeConstructorSplat(const ConstructorSplat& c, OutputStream& out) {
1738 SpvId SPIRVCodeGenerator::writeCompositeConstructor(const AnyConstructor& c, OutputStream& out) {
1744 for (const std::unique_ptr<Expression>& arg : ctorArgs) {
1751 SpvId SPIRVCodeGenerator::writeConstructorScalarCast(const ConstructorScalarCast& c,
1753 const Type& type = c.type();
1758 const Expression& ctorExpr = *c.argument();
1763 SpvId SPIRVCodeGenerator::writeConstructorCompoundCast(const ConstructorCompoundCast& c,
1765 const Type& ctorType = c.type();
1766 const Type& argType = c.argument()->type();
1782 const Type& srcType = argType.componentType();
1783 const Type& dstType = ctorType.componentType();
1797 SpvId SPIRVCodeGenerator::writeConstructorDiagonalMatrix(const ConstructorDiagonalMatrix& c,
1799 const Type& type = c.type();
1812 SpvId SPIRVCodeGenerator::writeConstructorMatrixResize(const ConstructorMatrixResize& c,
1821 static SpvStorageClass_ get_storage_class(const Variable& var,
1823 const Modifiers& modifiers = var.modifiers();
1846 static SpvStorageClass_ get_storage_class(const Expression& expr) {
1849 const Variable& var = *expr.as<VariableReference>().variable();
1864 std::vector<SpvId> SPIRVCodeGenerator::getAccessChain(const Expression& expr, OutputStream& out) {
1868 const IndexExpression& indexExpr = expr.as<IndexExpression>();
1874 const FieldAccess& fieldExpr = expr.as<FieldAccess>();
1903 bool isMemoryObjectPointer() const override {
1919 const SpvId fPointer;
1920 const bool fIsMemoryObject;
1921 const SpvId fType;
1922 const SPIRVCodeGenerator::Precision fPrecision;
1927 SwizzleLValue(SPIRVCodeGenerator& gen, SpvId vecPointer, const ComponentArray& components,
1928 const Type& baseType, const Type& swizzleType)
1935 bool applySwizzle(const ComponentArray& components, const Type& newType) override {
2004 const SpvId fVecPointer;
2006 const Type* fBaseType;
2007 const Type* fSwizzleType;
2010 int SPIRVCodeGenerator::findUniformFieldIndex(const Variable& var) const {
2015 std::unique_ptr<SPIRVCodeGenerator::LValue> SPIRVCodeGenerator::getLValue(const Expression& expr,
2017 const Type& type = expr.type();
2021 const Variable& var = *expr.as<VariableReference>().variable();
2054 const Swizzle& swizzle = expr.as<Swizzle>();
2094 SpvId SPIRVCodeGenerator::writeVariableReference(const VariableReference& ref, OutputStream& out) {
2095 const Variable* variable = ref.variable();
2116 const char* DEVICE_COORDS_NAME = "__device_FragCoords";
2151 const char* DEVICE_CLOCKWISE_NAME = "__device_Clockwise";
2183 SpvId SPIRVCodeGenerator::writeIndexExpression(const IndexExpression& expr, OutputStream& out) {
2195 SpvId SPIRVCodeGenerator::writeFieldAccess(const FieldAccess& f, OutputStream& out) {
2199 SpvId SPIRVCodeGenerator::writeSwizzle(const Swizzle& swizzle, OutputStream& out) {
2219 SpvId SPIRVCodeGenerator::writeBinaryOperation(const Type& resultType,
2220 const Type& operandType, SpvId lhs,
2239 SpvId SPIRVCodeGenerator::foldToBool(SpvId id, const Type& operandType, SpvOp op,
2249 SpvId SPIRVCodeGenerator::writeMatrixComparison(const Type& operandType, SpvId lhs, SpvId rhs,
2284 SpvId SPIRVCodeGenerator::writeComponentwiseMatrixBinary(const Type& operandType, SpvId lhs,
2303 SpvId SPIRVCodeGenerator::writeReciprocal(const Type& type, SpvId value, OutputStream& out) {
2311 SpvId SPIRVCodeGenerator::writeScalarToMatrixSplat(const Type& matrixType,
2315 const Type& vectorType = matrixType.componentType().toCompound(fContext,
2326 SpvId SPIRVCodeGenerator::writeBinaryExpression(const Type& leftType, SpvId lhs, Operator op,
2327 const Type& rightType, SpvId rhs,
2328 const Type& resultType, OutputStream& out) {
2334 const Type* operandType;
2356 const Type& vecType = leftType;
2376 const Type& vecType = rightType;
2459 const Type* tmpType;
2486 const Type* tmpType;
2575 SpvId SPIRVCodeGenerator::writeArrayComparison(const Type& arrayType, SpvId lhs, Operator op,
2580 const Type& componentType = arrayType.componentType();
2581 const SpvId componentTypeId = this->getType(componentType);
2582 const int arraySize = arrayType.columns();
2586 const Type& boolType = *fContext.fTypes.fBool;
2603 SpvId SPIRVCodeGenerator::writeStructComparison(const Type& structType, SpvId lhs, Operator op,
2608 const std::vector<Type::Field>& fields = structType.fields();
2612 const Type& boolType = *fContext.fTypes.fBool;
2616 const Type& fieldType = *fields[index].fType;
2617 const SpvId fieldTypeId = this->getType(fieldType);
2639 const Type& boolType = *fContext.fTypes.fBool;
2658 static float division_by_literal_value(Operator op, const Expression& right) {
2669 SpvId SPIRVCodeGenerator::writeBinaryExpression(const BinaryExpression& b, OutputStream& out) {
2670 const Expression* left = b.left().get();
2671 const Expression* right = b.right().get();
2724 SpvId SPIRVCodeGenerator::writeLogicalAnd(const Expression& left, const Expression& right,
2744 SpvId SPIRVCodeGenerator::writeLogicalOr(const Expression& left, const Expression& right,
2764 SpvId SPIRVCodeGenerator::writeTernaryExpression(const TernaryExpression& t, OutputStream& out) {
2765 const Type& type = t.type();
2800 SpvId SPIRVCodeGenerator::writePrefixExpression(const PrefixExpression& p, OutputStream& out) {
2801 const Type& type = p.type();
2854 SpvId SPIRVCodeGenerator::writePostfixExpression(const PostfixExpression& p, OutputStream& out) {
2855 const Type& type = p.type();
2878 SpvId SPIRVCodeGenerator::writeLiteral(const Literal& l) {
2882 SpvId SPIRVCodeGenerator::writeLiteral(double value, const Type& type) {
2910 SpvId SPIRVCodeGenerator::writeFunctionStart(const FunctionDeclaration& f, OutputStream& out) {
2921 for (const Variable* parameter : f.parameters()) {
2930 SpvId SPIRVCodeGenerator::writeFunction(const FunctionDefinition& f, OutputStream& out) {
2953 void SPIRVCodeGenerator::writeLayout(const Layout& layout, SpvId target) {
2981 void SPIRVCodeGenerator::writeLayout(const Layout& layout, SpvId target, int member) {
3008 MemoryLayout SPIRVCodeGenerator::memoryLayoutForVariable(const Variable& v) const {
3013 SpvId SPIRVCodeGenerator::writeInterfaceBlock(const InterfaceBlock& intf, bool appendRTFlip) {
3016 const Variable& intfVar = intf.variable();
3017 const Type& type = intfVar.type();
3042 const Type* rtFlipStructType = fProgram.fSymbols->takeOwnershipOfSymbol(
3044 const Variable* modifiedVar = fProgram.fSymbols->takeOwnershipOfSymbol(
3066 const Modifiers& intfModifiers = intfVar.modifiers();
3083 bool SPIRVCodeGenerator::isDead(const Variable& var) const {
3099 void SPIRVCodeGenerator::writeGlobalVar(ProgramKind kind, const VarDeclaration& varDecl) {
3100 const Variable& var = varDecl.var();
3118 const Type& type = var.type();
3145 void SPIRVCodeGenerator::writeVarDeclaration(const VarDeclaration& varDecl, OutputStream& out) {
3146 const Variable& var = varDecl.var();
3158 void SPIRVCodeGenerator::writeStatement(const Statement& s, OutputStream& out) {
3202 void SPIRVCodeGenerator::writeBlock(const Block& b, OutputStream& out) {
3203 for (const std::unique_ptr<Statement>& stmt : b.children()) {
3208 void SPIRVCodeGenerator::writeIfStatement(const IfStatement& stmt, OutputStream& out) {
3239 void SPIRVCodeGenerator::writeForStatement(const ForStatement& f, OutputStream& out) {
3276 void SPIRVCodeGenerator::writeDoStatement(const DoStatement& d, OutputStream& out) {
3303 void SPIRVCodeGenerator::writeSwitchStatement(const SwitchStatement& s, OutputStream& out) {
3311 for (const std::unique_ptr<Statement>& stmt : cases) {
3312 const SwitchCase& c = stmt->as<SwitchCase>();
3327 const SwitchCase& c = cases[i]->as<SwitchCase>();
3335 const SwitchCase& c = cases[i]->as<SwitchCase>();
3346 void SPIRVCodeGenerator::writeReturnStatement(const ReturnStatement& r, OutputStream& out) {
3356 static std::shared_ptr<SymbolTable> get_top_level_symbol_table(const FunctionDeclaration& anyFunc) {
3361 const FunctionDeclaration& main) {
3369 const Symbol* skFragColorSymbol = (*symbolTable)["sk_FragColor"];
3371 const Variable& skFragColorVar = skFragColorSymbol->as<Variable>();
3414 /*parameters=*/std::vector<const Variable*>{},
3437 for (const VarDeclaration* topLevelUniform : fTopLevelUniforms) {
3438 const Variable* var = &topLevelUniform->var();
3487 const Type* intfStruct =
3499 const Modifiers* modsPtr;
3513 const Variable* intfVar = fSynthetics.takeOwnershipOfSymbol(
3535 void SPIRVCodeGenerator::writeInstructions(const Program& program, OutputStream& out) {
3539 const FunctionDeclaration* main = nullptr;
3540 for (const ProgramElement* e : program.elements()) {
3542 const FunctionDefinition& funcDef = e->as<FunctionDefinition>();
3543 const FunctionDeclaration& funcDecl = funcDef.declaration();
3557 for (const ProgramElement* e : program.elements()) {
3559 const InterfaceBlock& intf = e->as<InterfaceBlock>();
3562 const Modifiers& modifiers = intf.variable().modifiers();
3570 for (const ProgramElement* e : program.elements()) {
3592 for (const ProgramElement* e : program.elements()) {
3599 const Variable* var = entry.first;
3633 for (const ProgramElement* e : program.elements()) {