DataType.hpp

Go to the documentation of this file.

#pragma once

#ifndef CHI_DATA_TYPE_HPP
#define CHI_DATA_TYPE_HPP

#include "chi/Fwd.hpp"

#include <string>

namespace chi {
struct DataType {
    DataType(ChiModule* chiMod = nullptr, std::string typeName = {}, llvm::Type* llvmtype = nullptr,
             llvm::DIType* debugTy = nullptr)
        : mModule(chiMod), mName{typeName}, mLLVMType{llvmtype}, mDIType{debugTy} {}

    ChiModule& module() const { return *mModule; }
    const std::string& unqualifiedName() const { return mName; }
    std::string qualifiedName() const;
    llvm::Type* llvmType() const { return mLLVMType; }
    llvm::DIType* debugType() const { return mDIType; }
    bool valid() const {
        return mModule != nullptr && mName != "" && mLLVMType != nullptr && mDIType != nullptr;
    }

private:
    ChiModule*    mModule;
    std::string   mName;
    llvm::Type*   mLLVMType;
    llvm::DIType* mDIType;
};

inline bool operator==(const DataType& lhs, const DataType& rhs) {
    return &lhs.module() == &rhs.module() && lhs.unqualifiedName() == rhs.unqualifiedName();
}

inline bool operator!=(const DataType& lhs, const DataType& rhs) { return !(lhs == rhs); }

struct NamedDataType {
    NamedDataType(std::string n = {}, DataType ty = {}) : name{std::move(n)}, type{std::move(ty)} {}

    bool valid() const { return type.valid(); }

    std::string name;

    DataType type;
};

inline bool operator==(const NamedDataType& lhs, const NamedDataType& rhs) {
    return lhs.name == rhs.name && lhs.type == rhs.type;
}

inline bool operator!=(const NamedDataType& lhs, const NamedDataType& rhs) { return !(lhs == rhs); }
}  // namespace chi

#endif  // CHI_DATA_TYPE_HPP