Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(21)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: src/sksl/ir/SkSLType.h

Issue 1984363002: initial checkin of SkSL compiler (Closed) Base URL: https://skia.googlesource.com/skia@master
Patch Set: IR cleanups Created 4 years, 6 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« src/sksl/ir/SkSLSwizzle.h ('K') | « src/sksl/ir/SkSLTernaryExpression.h ('k') | src/sksl/ir/SkSLType.cpp » ('j') | src/sksl/sksl.flex » ('J')
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: src/sksl/ir/SkSLType.h
diff --git a/src/sksl/ir/SkSLType.h b/src/sksl/ir/SkSLType.h
new file mode 100644
index 0000000000000000000000000000000000000000..527f28fa16240d2f5d386acf243a02d224355912
--- /dev/null
+++ b/src/sksl/ir/SkSLType.h
@@ -0,0 +1,508 @@
+/*
+ * Copyright 2016 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SKIASL_TYPE
+#define SKIASL_TYPE
+
+#include "SkSLModifiers.h"
+#include "SkSLSymbol.h"
+#include "../SkSLPosition.h"
+#include "../SkSLUtil.h"
+#include "../spirv.h"
+#include <vector>
+#include <memory>
+
+namespace SkSL {
+
+/**
+ * Represents a type, such as int or vec4.
+ */
+class Type : public Symbol {
+public:
+ struct Field {
+ Field(Modifiers modifiers, std::string name, std::shared_ptr<Type> type)
+ : fModifiers(modifiers)
+ , fName(std::move(name))
+ , fType(std::move(type)) {}
+
+ const std::string description() {
+ return fType->description() + " " + fName + ";";
+ }
+
+ const Modifiers fModifiers;
+ const std::string fName;
+ const std::shared_ptr<Type> fType;
+ };
+
+ enum Kind {
+ kScalar_Kind,
+ kVector_Kind,
+ kMatrix_Kind,
+ kArray_Kind,
+ kStruct_Kind,
+ kGeneric_Kind,
+ kSampler_Kind,
+ kOther_Kind
+ };
+
+ // Create an "other" (special) type with the given name. These types cannot be directly
+ // referenced from user code.
+ Type(std::string name)
+ : INHERITED(Position(), kType_Kind, std::move(name))
+ , fTypeKind(kOther_Kind)
+ , fIsNumber(false)
+ , fColumns(-1)
+ , fRows(-1)
+ , fDimensions(SpvDim1D)
+ , fIsDepth(false)
+ , fIsArrayed(false)
+ , fIsMultisampled(false)
+ , fIsSampled(false) {}
+
+ // Create a generic type which maps to the listed types.
+ Type(std::string name, std::vector<std::shared_ptr<Type>> types)
+ : INHERITED(Position(), kType_Kind, std::move(name))
+ , fTypeKind(kGeneric_Kind)
+ , fIsNumber(false)
+ , fCoercibleTypes(std::move(types))
+ , fColumns(-1)
+ , fRows(-1)
+ , fDimensions(SpvDim1D)
+ , fIsDepth(false)
+ , fIsArrayed(false)
+ , fIsMultisampled(false)
+ , fIsSampled(false) {
+ ASSERT(types.size() == 4);
+ }
+
+ // Create a struct type with the given fields.
+ Type(std::string name, std::vector<Field> fields)
+ : INHERITED(Position(), kType_Kind, std::move(name))
+ , fTypeKind(kStruct_Kind)
+ , fIsNumber(false)
+ , fColumns(-1)
+ , fRows(-1)
+ , fFields(std::move(fields))
+ , fDimensions(SpvDim1D)
+ , fIsDepth(false)
+ , fIsArrayed(false)
+ , fIsMultisampled(false)
+ , fIsSampled(false) {}
+
+ // Create a scalar type.
+ Type(std::string name, bool isNumber)
+ : INHERITED(Position(), kType_Kind, std::move(name))
+ , fTypeKind(kScalar_Kind)
+ , fIsNumber(isNumber)
+ , fColumns(1)
+ , fRows(1)
+ , fDimensions(SpvDim1D)
+ , fIsDepth(false)
+ , fIsArrayed(false)
+ , fIsMultisampled(false)
+ , fIsSampled(false) {}
+
+ // Create a scalar type which can be coerced to the listed types.
+ Type(std::string name, bool isNumber, std::vector<std::shared_ptr<Type>> coercibleTypes)
+ : INHERITED(Position(), kType_Kind, std::move(name))
+ , fTypeKind(kScalar_Kind)
+ , fIsNumber(isNumber)
+ , fCoercibleTypes(std::move(coercibleTypes))
+ , fColumns(1)
+ , fRows(1)
+ , fDimensions(SpvDim1D)
+ , fIsDepth(false)
+ , fIsArrayed(false)
+ , fIsMultisampled(false)
+ , fIsSampled(false) {}
+
+ // Create a vector type.
+ Type(std::string name, std::shared_ptr<Type> componentType, int columns)
+ : INHERITED(Position(), kType_Kind, std::move(name))
+ , fTypeKind(kVector_Kind)
+ , fIsNumber(false)
+ , fComponentType(std::move(componentType))
dogben 2016/06/24 17:05:29 nit: Maybe assert that componentType is a scalar?
+ , fColumns(columns)
+ , fRows(1)
+ , fDimensions(SpvDim1D)
+ , fIsDepth(false)
+ , fIsArrayed(false)
+ , fIsMultisampled(false)
+ , fIsSampled(false) {}
+
+ // Create a vector or array type.
+ Type(std::string name, Kind kind, std::shared_ptr<Type> componentType, int columns)
+ : INHERITED(Position(), kType_Kind, std::move(name))
+ , fTypeKind(kind)
+ , fIsNumber(false)
+ , fComponentType(std::move(componentType))
+ , fColumns(columns)
+ , fRows(1)
+ , fDimensions(SpvDim1D)
+ , fIsDepth(false)
+ , fIsArrayed(false)
+ , fIsMultisampled(false)
+ , fIsSampled(false) {}
+
+ // Create a matrix type.
+ Type(std::string name, std::shared_ptr<Type> componentType, int columns, int rows)
+ : INHERITED(Position(), kType_Kind, std::move(name))
+ , fTypeKind(kMatrix_Kind)
+ , fIsNumber(false)
+ , fComponentType(std::move(componentType))
dogben 2016/06/24 17:05:29 nit: Maybe assert that componentType is a scalar?
+ , fColumns(columns)
+ , fRows(rows)
+ , fDimensions(SpvDim1D)
+ , fIsDepth(false)
+ , fIsArrayed(false)
+ , fIsMultisampled(false)
+ , fIsSampled(false) {}
+
+ // Create a sampler type.
+ Type(std::string name, SpvDim_ dimensions, bool isDepth, bool isArrayed, bool isMultisampled,
+ bool isSampled)
+ : INHERITED(Position(), kType_Kind, std::move(name))
+ , fTypeKind(kSampler_Kind)
+ , fIsNumber(false)
+ , fColumns(-1)
+ , fRows(-1)
+ , fDimensions(dimensions)
+ , fIsDepth(isDepth)
+ , fIsArrayed(isArrayed)
+ , fIsMultisampled(isMultisampled)
+ , fIsSampled(isSampled) {}
+
+ std::string name() const {
+ return fName;
+ }
+
+ std::string description() const override {
+ return fName;
+ }
+
+ bool operator==(const Type& other) const {
+ return fName == other.fName;
+ }
+
+ bool operator!=(const Type& other) const {
+ return fName != other.fName;
+ }
+
+ /**
+ * Returns the category (scalar, vector, matrix, etc.) of this type.
+ */
+ Kind kind() const {
+ return fTypeKind;
+ }
+
+ /**
+ * Returns true if this is a numeric scalar type.
+ */
+ bool isNumber() const {
+ return fIsNumber;
+ }
+
+ /**
+ * Returns true if an instance of this type can be freely coerced (implicitly converted) to
+ * another type.
+ */
+ bool canCoerceTo(std::shared_ptr<Type> other) const {
+ int cost;
+ return determineCoercionCost(other, &cost);
+ }
+
+ /**
+ * Determines the "cost" of coercing (implicitly converting) this type to another type. The cost
+ * is a number with no particular meaning other than that lower costs are preferable to higher
+ * costs. Returns true if a conversion is possible, false otherwise. The value of the out
+ * parameter is undefined if false is returned.
+ */
+ bool determineCoercionCost(std::shared_ptr<Type> other, int* outCost) const;
+
+ /**
+ * For matrices and vectors, returns the type of individual cells (e.g. mat2 has a component
+ * type of kFloat_Type). For all other types, causes an assertion failure.
+ */
+ std::shared_ptr<Type> componentType() const {
+ ASSERT(fComponentType);
+ return fComponentType;
+ }
+
+ /**
+ * For matrices and vectors, returns the number of columns (e.g. both mat3 and vec3 return 3).
+ * For scalars, returns 1. For arrays, returns either the size of the array (if known) or -1.
+ * For all other types, causes an assertion failure.
+ */
+ int columns() const {
+ ASSERT(fTypeKind == kScalar_Kind || fTypeKind == kVector_Kind ||
+ fTypeKind == kMatrix_Kind || fTypeKind == kArray_Kind);
+ return fColumns;
+ }
+
+ /**
+ * For matrices, returns the number of rows (e.g. mat2x4 returns 4). For vectors and scalars,
+ * returns 1. For all other types, causes an assertion failure.
+ */
+ int rows() const {
+ ASSERT(fRows > 0);
+ return fRows;
+ }
+
+ std::vector<Field> fields() const {
+ ASSERT(fTypeKind == kStruct_Kind);
+ return fFields;
+ }
+
+ /**
+ * For generic types, returns the types that this generic type can substitute for. For other
+ * types, returns a list of other types that this type can be coerced into.
+ */
+ std::vector<std::shared_ptr<Type>> coercibleTypes() const {
+ ASSERT(fCoercibleTypes.size() > 0);
+ return fCoercibleTypes;
+ }
+
+ int dimensions() {
+ ASSERT(fTypeKind == kSampler_Kind);
+ return fDimensions;
+ }
+
+ bool isDepth() {
+ ASSERT(fTypeKind == kSampler_Kind);
+ return fIsDepth;
+ }
+
+ bool isArrayed() {
+ ASSERT(fTypeKind == kSampler_Kind);
+ return fIsArrayed;
+ }
+
+ bool isMultisampled() {
+ ASSERT(fTypeKind == kSampler_Kind);
+ return fIsMultisampled;
+ }
+
+ bool isSampled() {
+ ASSERT(fTypeKind == kSampler_Kind);
+ return fIsSampled;
+ }
+
+ /**
+ * Returns the type's required alignment (when putting this type into a struct, the offset must
+ * be a multiple of the alignment).
+ */
+ size_t alignment() {
+ // See OpenGL Spec 7.6.2.2 Standard Uniform Block Layout
+ switch (fTypeKind) {
+ case kScalar_Kind:
+ return this->size();
+ case kVector_Kind:
+ return (fColumns + fColumns % 2) * fComponentType->size();
+ case kMatrix_Kind:
+ return (fRows + fRows % 2) * fComponentType->size();
+ case kArray_Kind:
+ switch (fComponentType->kind()) {
+ case kScalar_Kind:
+ return fComponentType->alignment() * 4;
+ case kVector_Kind:
+ return fComponentType->componentType()->size() * 4;
+ case kStruct_Kind:
+ return fComponentType->alignment();
+ default:
+ ABORT("unsupported array type");
+ }
+ case kStruct_Kind: {
+ size_t result = 16;
+ for (size_t i = 0; i < fFields.size(); i++) {
+ size_t alignment = fFields[i].fType->alignment();
+ if (alignment > result) {
+ result = alignment;
+ }
+ }
+ }
+ default:
+ ABORT(("cannot determine size of type " + fName).c_str());
+ }
+ }
+
+ /**
+ * For matrices and arrays, returns the number of bytes from the start of one entry (row, in
+ * the case of matrices) to the start of the next.
+ */
+ size_t stride() {
+ // the OpenGL spec specifies a minimum of vec4 stride for these types, which is consistent
+ // with what glslang produces. Since the Skia Vulkan engine sets up its structures to fit
+ // with what glslang expects, we have no choice but to be consistent with that, which leads
+ // to wasting 75% of the space in a float[]. However, it's possible that (for arrays, at
+ // least) there is no actual reason to require a stride of 16, provided that both the shader
+ // and Skia agree on the stride.
+ // FIXME: see whether we can remove the restriction on array stride
+ switch (fTypeKind) {
+ case kMatrix_Kind:
+ // for the time being, we only handle 32 bit numbers
+ return 16;
+ case kArray_Kind:
+ return 16;
+ default:
+ ABORT("type does not have a stride");
+ }
+ }
+
+ /**
+ * Returns the size of this type in bytes.
+ */
+ size_t size() {
+ switch (fTypeKind) {
+ case kScalar_Kind:
+ // FIXME need to take precision into account, once we figure out how we want to
+ // handle it...
+ return 4;
+ case kVector_Kind:
+ return fColumns * fComponentType->size();
+ case kMatrix_Kind:
+ return (fRows + fRows % 2) * fColumns * fComponentType->size();
+ case kArray_Kind:
+ return fColumns * this->alignment();
+ case kStruct_Kind: {
+ size_t total = 0;
+ for (size_t i = 0; i < fFields.size(); i++) {
+ size_t alignment = fFields[i].fType->alignment();
+ if (total % alignment != 0) {
+ total += alignment - total % alignment;
+ }
+ ASSERT(false);
+ ASSERT(total % alignment == 0);
+ total += fFields[i].fType->size();
+ }
+ return total;
+ }
+ default:
+ ABORT(("cannot determine size of type " + fName).c_str());
+ }
+ }
+
+ /**
+ * Returns the corresponding vector or matrix type with the specified number of columns and
+ * rows.
+ */
+ std::shared_ptr<Type> toCompound(int columns, int rows);
+
+private:
+ typedef Symbol INHERITED;
+
+ const Kind fTypeKind;
+ const bool fIsNumber;
+ const std::shared_ptr<Type> fComponentType;
+ const std::vector<std::shared_ptr<Type>> fCoercibleTypes;
+ const int fColumns;
+ const int fRows;
+ const std::vector<Field> fFields;
+ const SpvDim_ fDimensions;
dogben 2016/06/24 17:05:29 Is this a TODO? It seems that everything in the IR
+ const bool fIsDepth;
+ const bool fIsArrayed;
+ const bool fIsMultisampled;
+ const bool fIsSampled;
+};
+
+extern const std::shared_ptr<Type> kVoid_Type;
+
+extern const std::shared_ptr<Type> kFloat_Type;
+extern const std::shared_ptr<Type> kVec2_Type;
+extern const std::shared_ptr<Type> kVec3_Type;
+extern const std::shared_ptr<Type> kVec4_Type;
+extern const std::shared_ptr<Type> kDouble_Type;
+extern const std::shared_ptr<Type> kDVec2_Type;
+extern const std::shared_ptr<Type> kDVec3_Type;
+extern const std::shared_ptr<Type> kDVec4_Type;
+extern const std::shared_ptr<Type> kInt_Type;
+extern const std::shared_ptr<Type> kIVec2_Type;
+extern const std::shared_ptr<Type> kIVec3_Type;
+extern const std::shared_ptr<Type> kIVec4_Type;
+extern const std::shared_ptr<Type> kUInt_Type;
+extern const std::shared_ptr<Type> kUVec2_Type;
+extern const std::shared_ptr<Type> kUVec3_Type;
+extern const std::shared_ptr<Type> kUVec4_Type;
+extern const std::shared_ptr<Type> kBool_Type;
+extern const std::shared_ptr<Type> kBVec2_Type;
+extern const std::shared_ptr<Type> kBVec3_Type;
+extern const std::shared_ptr<Type> kBVec4_Type;
+
+extern const std::shared_ptr<Type> kMat2x2_Type;
+extern const std::shared_ptr<Type> kMat2x3_Type;
+extern const std::shared_ptr<Type> kMat2x4_Type;
+extern const std::shared_ptr<Type> kMat3x2_Type;
+extern const std::shared_ptr<Type> kMat3x3_Type;
+extern const std::shared_ptr<Type> kMat3x4_Type;
+extern const std::shared_ptr<Type> kMat4x2_Type;
+extern const std::shared_ptr<Type> kMat4x3_Type;
+extern const std::shared_ptr<Type> kMat4x4_Type;
+
+extern const std::shared_ptr<Type> kDMat2x2_Type;
+extern const std::shared_ptr<Type> kDMat2x3_Type;
+extern const std::shared_ptr<Type> kDMat2x4_Type;
+extern const std::shared_ptr<Type> kDMat3x2_Type;
+extern const std::shared_ptr<Type> kDMat3x3_Type;
+extern const std::shared_ptr<Type> kDMat3x4_Type;
+extern const std::shared_ptr<Type> kDMat4x2_Type;
+extern const std::shared_ptr<Type> kDMat4x3_Type;
+extern const std::shared_ptr<Type> kDMat4x4_Type;
+
+extern const std::shared_ptr<Type> kSampler1D_Type;
+extern const std::shared_ptr<Type> kSampler2D_Type;
+extern const std::shared_ptr<Type> kSampler3D_Type;
+extern const std::shared_ptr<Type> kSamplerCube_Type;
+extern const std::shared_ptr<Type> kSampler2DRect_Type;
+extern const std::shared_ptr<Type> kSampler1DArray_Type;
+extern const std::shared_ptr<Type> kSampler2DArray_Type;
+extern const std::shared_ptr<Type> kSamplerCubeArray_Type;
+extern const std::shared_ptr<Type> kSamplerBuffer_Type;
+extern const std::shared_ptr<Type> kSampler2DMS_Type;
+extern const std::shared_ptr<Type> kSampler2DMSArray_Type;
+
+extern const std::shared_ptr<Type> kGSampler1D_Type;
+extern const std::shared_ptr<Type> kGSampler2D_Type;
+extern const std::shared_ptr<Type> kGSampler3D_Type;
+extern const std::shared_ptr<Type> kGSamplerCube_Type;
+extern const std::shared_ptr<Type> kGSampler2DRect_Type;
+extern const std::shared_ptr<Type> kGSampler1DArray_Type;
+extern const std::shared_ptr<Type> kGSampler2DArray_Type;
+extern const std::shared_ptr<Type> kGSamplerCubeArray_Type;
+extern const std::shared_ptr<Type> kGSamplerBuffer_Type;
+extern const std::shared_ptr<Type> kGSampler2DMS_Type;
+extern const std::shared_ptr<Type> kGSampler2DMSArray_Type;
+
+extern const std::shared_ptr<Type> kSampler1DShadow_Type;
+extern const std::shared_ptr<Type> kSampler2DShadow_Type;
+extern const std::shared_ptr<Type> kSamplerCubeShadow_Type;
+extern const std::shared_ptr<Type> kSampler2DRectShadow_Type;
+extern const std::shared_ptr<Type> kSampler1DArrayShadow_Type;
+extern const std::shared_ptr<Type> kSampler2DArrayShadow_Type;
+extern const std::shared_ptr<Type> kSamplerCubeArrayShadow_Type;
+extern const std::shared_ptr<Type> kGSampler2DArrayShadow_Type;
+extern const std::shared_ptr<Type> kGSamplerCubeArrayShadow_Type;
+
+extern const std::shared_ptr<Type> kGenType_Type;
+extern const std::shared_ptr<Type> kGenDType_Type;
+extern const std::shared_ptr<Type> kGenIType_Type;
+extern const std::shared_ptr<Type> kGenUType_Type;
+extern const std::shared_ptr<Type> kGenBType_Type;
+extern const std::shared_ptr<Type> kMat_Type;
+extern const std::shared_ptr<Type> kVec_Type;
+extern const std::shared_ptr<Type> kGVec_Type;
+extern const std::shared_ptr<Type> kGVec2_Type;
+extern const std::shared_ptr<Type> kGVec3_Type;
+extern const std::shared_ptr<Type> kGVec4_Type;
+extern const std::shared_ptr<Type> kDVec_Type;
+extern const std::shared_ptr<Type> kIVec_Type;
+extern const std::shared_ptr<Type> kUVec_Type;
+extern const std::shared_ptr<Type> kBVec_Type;
+
+extern const std::shared_ptr<Type> kInvalid_Type;
+
+} // namespace
+
+#endif
« src/sksl/ir/SkSLSwizzle.h ('K') | « src/sksl/ir/SkSLTernaryExpression.h ('k') | src/sksl/ir/SkSLType.cpp » ('j') | src/sksl/sksl.flex » ('J')

Powered by Google App Engine
This is Rietveld 408576698