Welcome to the NetCologne GmbH open source mirroring service!

This machine mirrors various open-source projects. 20 Gbit/s uplink.

If there are any issues or you want another project mirrored, please contact mirror-service -=AT=- netcologne DOT de !

lib/codegen/CodeGenTypes.h

Go to the documentation of this file.

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

#ifndef COMMA_CODEGEN_CODEGENTYPES_HDR_GUARD
#define COMMA_CODEGEN_CODEGENTYPES_HDR_GUARD

#include "comma/ast/AstBase.h"

#include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/ScopedHashTable.h"
#include "llvm/DerivedTypes.h"

namespace comma {

class CGContext;
class CodeGen;

class CodeGenTypes {

public:
    CodeGenTypes(CodeGen &CG, DomainInstanceDecl *context)
        : CG(CG), topScope(rewrites), context(context) {
        if (context)
            addInstanceRewrites(context);
    };

    const llvm::Type *lowerType(const Type *type);

    const llvm::Type *lowerDomainType(const DomainType *type);

    const llvm::IntegerType *lowerEnumType(const EnumerationType *type);

    const llvm::FunctionType *lowerSubroutine(const SubroutineDecl *decl);

    const llvm::IntegerType *lowerDiscreteType(const DiscreteType *type);

    const llvm::ArrayType *lowerArrayType(const ArrayType *type);

    const llvm::StructType *lowerRecordType(const RecordType *type);

    const llvm::Type *lowerIncompleteType(const IncompleteType *type);

    const llvm::PointerType *lowerThinAccessType(const AccessType *type);

    const llvm::StructType *lowerFatAccessType(const AccessType *type);

    const llvm::Type *lowerAccessType(const AccessType *type);

    const llvm::Type *lowerUniversalType(const UniversalType *type);

    const llvm::StructType *lowerArrayBounds(const ArrayType *arrTy);

    const llvm::StructType *lowerScalarBounds(const DiscreteType *type);

    const llvm::StructType *lowerRange(const Range *range);

    unsigned getComponentIndex(const ComponentDecl *component);

    unsigned getTypeAlignment(const llvm::Type *type) const;

    uint64_t getTypeSize(const llvm::Type *type) const;

    const Type *resolveType(const Type *type);

    //@
    enum CallConvention {
        CC_Simple,
        CC_Sret,
        CC_Vstack
    };

    CallConvention getConvention(const SubroutineDecl *decl);

private:
    CodeGen &CG;

    typedef llvm::ScopedHashTable<const Type*, const Type*> RewriteMap;
    typedef llvm::ScopedHashTableScope<const Type*, const Type*> RewriteScope;
    RewriteMap rewrites;
    RewriteScope topScope;

    DomainInstanceDecl *context;

    typedef llvm::DenseMap<const ComponentDecl*, unsigned> ComponentIndexMap;
    ComponentIndexMap ComponentIndices;

    typedef llvm::DenseMap<const Type*, const llvm::Type*> TypeMap;
    TypeMap loweredTypes;

    const DomainType *rewriteAbstractDecl(const AbstractDomainDecl *abstract);

    const llvm::IntegerType *getTypeForWidth(unsigned numBits);

    void addInstanceRewrites(const DomainInstanceDecl *instance);

    const llvm::Type *&getLoweredType(const Type *type) {
        return loweredTypes.FindAndConstruct(type).second;
    }
};

}; // end comma namespace

#endif

---