initial checkin of SkSL compiler

src/sksl/ir/SkSLType.h

+/*
+ * 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)

[dogben, 2016/06/28 02:14:55]

nit: Given that there are so many constructors and so many fields, I think it
would be more readable to put default initializers on the fields and only
include the fields in the constructor that are non-default.

[ethannicholas, 2016/06/30 15:19:28]

Last time I did that the reviewer told me not to use default initializers in
Skia... but since you're ok with it, here we go!

[dogben, 2016/06/30 18:19:44]

It hasn't been fully supported until recently. I'm a firm believer in default
initializers.

+    , 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(fCoercibleTypes.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))

[dogben, 2016/06/28 02:14:55]

nit: maybe delegate to next constructor?

+    , fTypeKind(kVector_Kind)
+    , fIsNumber(false)
+    , fComponentType(std::move(componentType))
+    , 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))
+    , 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() const {
+        ASSERT(fTypeKind == kSampler_Kind);
+        return fDimensions;
+    }
+
+    bool isDepth() const {
+        ASSERT(fTypeKind == kSampler_Kind);
+        return fIsDepth;
+    }
+
+    bool isArrayed() const {
+        ASSERT(fTypeKind == kSampler_Kind);
+        return fIsArrayed;
+    }
+
+    bool isMultisampled() const {
+        ASSERT(fTypeKind == kSampler_Kind);
+        return fIsMultisampled;
+    }
+
+    bool isSampled() const {
+        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() const {
+        // 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();

[egdaniel, 2016/06/28 15:53:32]

This seems wrong. A column matrix should be though of as an array of size
fColumns of vec<fRows>. Thus this should have a base alignment equal to an array
of vec<fRow>

+            case kArray_Kind:
+                switch (fComponentType->kind()) {
+                    case kScalar_Kind:
+                        return fComponentType->alignment() * 4;

[egdaniel, 2016/06/28 15:53:32]

This should be the base alignment of the scalar rounded up to 16. If the size of
the scalar is < 4 then this is incorrect. If you want to assume the alignment is
>=4 then I think we need some assert here or in scalar->size().

[ethannicholas, 2016/06/30 15:19:28]

I based mine on the OpenGL spec, which says "rounded up to the base alignment of
a vec4", with various other rule differences. The Vulkan spec says "rounded up
to a multiple of 16". Naturally, since everything is 32 bit, these actually
agree for the time being. The Vulkan spec seems a lot more sensible, though, so
I will follow that.

+                    case kVector_Kind:
+                        return fComponentType->componentType()->size() * 4;

[egdaniel, 2016/06/28 15:53:31]

same need for asserts as above

+                    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() const {
+        // 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

[egdaniel, 2016/06/28 15:53:32]

This is actually all required by the Vulkan spec even if SPIR-V supports other
layouts

+        // 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

[egdaniel, 2016/06/28 15:53:32]

is this asserted somewhere?

+                return 16;
+            case kArray_Kind:
+                return std::max(this->componentType()->size(), (size_t) 16);

[egdaniel, 2016/06/28 15:53:32]

If we are trying to match the vulkan spec here, the stride of an array and
matrix must be an integer multiple of the base alignment.

Just set this to alignment

+            default:
+                ABORT("type does not have a stride");
+        }
+    }
+
+    /**
+     * Returns the size of this type in bytes.
+     */
+    size_t size() const {
+        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();

[egdaniel, 2016/06/28 15:53:31]

does a vec3 not have a size of a vec4?

[ethannicholas, 2016/06/30 15:19:28]

No. It has the *alignment* of a vec4, but not the size. This matters for things
like:

struct foo {
     vec3 bar;
     float baz;
}

baz is offset 12 bytes into the structure, not 16.

+            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;
+    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