lib/codegen/DomainInfo.h

Go to the documentation of this file.

//===-- codegen/DomainInfo.h ---------------------------------- -*- C++ -*-===//
//
// This file is distributed under the MIT license. See LICENSE.txt for details.
//
// Copyright (C) 2009-2010, Stephen Wilson
//
//===----------------------------------------------------------------------===//

#ifndef COMMA_CODEGEN_DOMAININFO_HDR_GUARD
#define COMMA_CODEGEN_DOMAININFO_HDR_GUARD

#include "CodeGen.h"
#include "comma/ast/Decl.h"

#include "llvm/Support/IRBuilder.h"

#include <string>
#include <vector>

namespace comma {

class CommaRT;
class DependencySet;

class DomainInfo {

public:
    DomainInfo(CommaRT &CRT);

    void init();

    enum FieldId {
        Arity,       
        Name,        
        Ctor,        
        ITable,      
    };

    const std::string &getTypeName() const { return theTypeName; }

    const llvm::StructType *getType() const;

    const llvm::PointerType *getPointerTypeTo() const;

    const llvm::PointerType *getCtorPtrType() const;

    llvm::GlobalVariable *emit(const Domoid *domoid);

    static std::string getLinkName(const Domoid *model);

    template <FieldId F>
    struct FieldIdTraits {
        typedef const llvm::PointerType FieldType;
    };

    template <FieldId F>
    typename FieldIdTraits<F>::FieldType *getFieldType() const;

private:
    CommaRT &CRT;
    CodeGen &CG;
    const llvm::TargetData &TD;

    static const std::string theTypeName;

    llvm::PATypeHolder theType;

    llvm::Constant *genName(const Domoid *domoid);

    llvm::Constant *genArity(const Domoid *domoid);

    llvm::Constant *genConstructor(const Domoid *domoid);

    llvm::Constant *genITable(const Domoid *domoid);

    void genInstanceRequirement(llvm::IRBuilder<> &builder,
                                const DependencySet &DS,
                                unsigned ID,
                                llvm::Value *destVector,
                                llvm::Value *percent);

    void genDomainRequirement(llvm::IRBuilder<> &builder,
                              const DependencySet &DS,
                              unsigned ID,
                              llvm::Value *destVector);

    void genFunctorRequirement(llvm::IRBuilder<> &builder,
                               const DependencySet &DS,
                               unsigned ID,
                               llvm::Value *destVector,
                               llvm::Value *percent);

    static std::string getCtorName(const Domoid *domoid);
};

//===----------------------------------------------------------------------===//
// DomainInfo::FieldIdTraits specializations for the various fields within a
// domain_info.

template <>
struct DomainInfo::FieldIdTraits<DomainInfo::Arity> {
    typedef const llvm::IntegerType FieldType;
};

//===----------------------------------------------------------------------===//
// DomainInfo::getFieldType specializations for each field in a domain_info.

template <> inline
DomainInfo::FieldIdTraits<DomainInfo::Arity>::FieldType *
DomainInfo::getFieldType<DomainInfo::Arity>() const {
    typedef FieldIdTraits<Arity>::FieldType FTy;
    return llvm::cast<FTy>(getType()->getElementType(Arity));
}

template <> inline
DomainInfo::FieldIdTraits<DomainInfo::Name>::FieldType *
DomainInfo::getFieldType<DomainInfo::Name>() const {
    typedef FieldIdTraits<Name>::FieldType FTy;
    return llvm::cast<FTy>(getType()->getElementType(Name));
}

template <> inline
DomainInfo::FieldIdTraits<DomainInfo::Ctor>::FieldType *
DomainInfo::getFieldType<DomainInfo::Ctor>() const {
    typedef FieldIdTraits<Ctor>::FieldType FTy;
    return llvm::cast<FTy>(getType()->getElementType(Ctor));
}

template <> inline
DomainInfo::FieldIdTraits<DomainInfo::ITable>::FieldType *
DomainInfo::getFieldType<DomainInfo::ITable>() const {
    typedef FieldIdTraits<ITable>::FieldType FTy;
    return llvm::cast<FTy>(getType()->getElementType(ITable));
}

}; // end comma namespace.

#endif

---