Type.h

Go to the documentation of this file.

// Copyright (c) 2018 the Talvos developers. All rights reserved.
//
// This file is distributed under a three-clause BSD license. For full license
// terms please see the LICENSE file distributed with this source code.


#ifndef TALVOS_TYPE_H
#define TALVOS_TYPE_H

#include <cstdint>
#include <cstring>
#include <iosfwd>
#include <map>
#include <memory>
#include <vector>

namespace talvos
{

class Type;

typedef std::vector<std::pair<const Type *, std::map<uint32_t, uint32_t>>>
    StructElementTypeList;

class Type
{
public:
  enum TypeId
  {
    VOID,
    BOOL,
    INT,
    FLOAT,
    VECTOR,
    MATRIX,
    IMAGE,
    SAMPLER,
    SAMPLED_IMAGE,
    ARRAY,
    RUNTIME_ARRAY,
    STRUCT,
    POINTER,
    FUNCTION,
  };

  uint32_t getBitWidth() const;

  uint32_t getDimensionality() const { return Dimensionality; }

  uint32_t getElementCount() const { return ElementCount; }

  size_t getElementOffset(uint64_t Index) const;

  const Type *getElementType(uint64_t Index = 0) const;

  const Type *getScalarType() const;

  size_t getSize() const { return ByteSize; };

  uint32_t getStorageClass() const;

  const std::map<uint32_t, uint32_t> &
  getStructMemberDecorations(uint32_t Index) const;

  TypeId getTypeId() const { return Id; }

  bool isArray() const { return Id == ARRAY; }

  bool isArrayedImage() const { return Arrayed; }

  bool isBool() const { return Id == BOOL; }

  bool isComposite() const;

  bool isFloat() const { return Id == FLOAT; }

  bool isInt() const { return Id == INT; }

  bool isMatrix() const { return Id == MATRIX; }

  bool isPointer() const { return Id == POINTER; }

  bool isScalar() const;

  bool isStruct() const { return Id == STRUCT; }

  bool isVector() const { return Id == VECTOR; }

  friend std::ostream &operator<<(std::ostream &Stream, const Type *Ty);

  static std::unique_ptr<Type>
  getArray(const Type *ElemType, uint32_t ElementCount, uint32_t ArrayStride);

  static std::unique_ptr<Type> getBool();

  static std::unique_ptr<Type> getFloat(uint32_t Width);

  static std::unique_ptr<Type> getInt(uint32_t Width);

  static std::unique_ptr<Type>
  getFunction(const Type *ReturnType,
              const std::vector<const Type *> &ArgTypes);

  static std::unique_ptr<Type> getImage(const Type *SampledType, uint32_t Dim,
                                        uint32_t Depth, bool Arrayed, bool MS,
                                        uint32_t Sampled, uint32_t Format);

  static std::unique_ptr<Type> getMatrix(const Type *ColumnType,
                                         uint32_t NumColumns);

  static std::unique_ptr<Type>
  getPointer(uint32_t StorageClass, const Type *ElemType, uint32_t ArrayStride);

  static std::unique_ptr<Type> getRuntimeArray(const Type *ElemType,
                                               uint32_t ArrayStride);

  static std::unique_ptr<Type> getSampledImage(const Type *ImageType);

  static std::unique_ptr<Type> getSampler();

  static std::unique_ptr<Type>
  getStruct(const StructElementTypeList &ElemTypes);

  static std::unique_ptr<Type> getVector(const Type *ElemType,
                                         uint32_t ElemCount);

  static std::unique_ptr<Type> getVoid();

private:
  Type(TypeId Id, size_t ByteSize)
  {
    this->Id = Id;
    this->ByteSize = ByteSize;
    ElementCount = 1;
    ElementType = nullptr;
  };

  TypeId Id; 

  size_t ByteSize; 

  uint32_t BitWidth; 

  uint32_t StorageClass; 

  const Type *ElementType; 
  uint32_t ElementCount;   
  uint32_t ArrayStride;    

  StructElementTypeList ElementTypes; 
  std::vector<size_t> ElementOffsets; 

  const Type *ReturnType;                  
  std::vector<const Type *> ArgumentTypes; 

  uint32_t Dimensionality; 
  uint32_t Depth;          
  bool Arrayed;            
  bool Multisampled;       
  uint32_t Sampled;        
  uint32_t Format;         
};

} // namespace talvos

#endif