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, Stephen Wilson
//
//===----------------------------------------------------------------------===//

#ifndef COMMA_CODEGEN_DOMAININFO_HDR_GUARD
#define COMMA_CODEGEN_DOMAININFO_HDR_GUARD

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

#include "llvm/Support/IRBuilder.h"

#include <string>
#include <vector>

namespace comma {

class CommaRT;

class DomainInfo {

public:
    DomainInfo(CommaRT &CRT);

    void init();

    enum FieldId {
        Arity,       
        NumSigs,     
        Name,        
        Ctor,        
        ITable,      
        SigOffsets,  
        Exvec        
    };

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

    const llvm::StructType *getType() const;

    const llvm::PointerType *getPointerTypeTo() const;

    const llvm::PointerType *getCtorPtrType() const;

    llvm::GlobalVariable *generateInstance(CodeGenCapsule &CGC);

    std::string getLinkName(const CodeGenCapsule &CGC) const;

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

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

    llvm::Value *indexSigOffset(llvm::IRBuilder<> &builder,
                                llvm::Value *DInfo,
                                llvm::Value *index) const;

    llvm::Value *loadExportVec(llvm::IRBuilder<> &builder,
                               llvm::Value *DInfo) const;

    llvm::Value *loadExportFn(llvm::IRBuilder<> &builder,
                              llvm::Value *DInfo,
                              llvm::Value *exportIdx) const;

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

    static const std::string theTypeName;

    llvm::PATypeHolder theType;

    llvm::Constant *genName(CodeGenCapsule &CGC);

    llvm::Constant *genArity(CodeGenCapsule &CGC);

    llvm::Constant *genSignatureCount(CodeGenCapsule &CGC);

    llvm::Constant *genConstructor(CodeGenCapsule &CGC);

    llvm::Constant *genITable(CodeGenCapsule &CGC);

    llvm::Constant *genSignatureOffsets(CodeGenCapsule &CGC);

    llvm::Constant *genExportArray(CodeGenCapsule &CGC);

    unsigned
    getOffsetsForSignature(SignatureType *sig,
                           unsigned index,
                           std::vector<llvm::Constant *> &offsets);

    void genInstanceRequirement(llvm::IRBuilder<> &builder,
                                CodeGenCapsule &CGC,
                                unsigned ID,
                                llvm::Value *destVector,
                                llvm::Value *percent);

    void genDomainRequirement(llvm::IRBuilder<> &builder,
                              CodeGenCapsule &CGC,
                              unsigned ID,
                              llvm::Value *destVector);

    void genFunctorRequirement(llvm::IRBuilder<> &builder,
                               CodeGenCapsule &CGC,
                               unsigned ID,
                               llvm::Value *destVector,
                               llvm::Value *percent);
};

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

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

template <>
struct DomainInfo::FieldIdTraits<DomainInfo::NumSigs> {
    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::NumSigs>::FieldType *
DomainInfo::getFieldType<DomainInfo::NumSigs>() const {
    typedef FieldIdTraits<NumSigs>::FieldType FTy;
    return llvm::cast<FTy>(getType()->getElementType(NumSigs));
}

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));
}

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

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

}; // end comma namespace.

#endif

---