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/Frame.h

Go to the documentation of this file.

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

#ifndef COMMA_CODEGEN_FRAME_HDR_GUARD
#define COMMA_CODEGEN_FRAME_HDR_GUARD

#include "SRInfo.h"

#include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/ilist.h"
#include "llvm/ADT/ilist_node.h"
#include "llvm/Support/IRBuilder.h"

namespace comma {

class CodeGenRoutine;

namespace activation {

enum Tag {
    Slot,
    Bounds,
    Length,
};

class Property : public llvm::ilist_node<Property> {
public:
    Property() : kind(Slot), value(0) { }

    Property(Tag kind, llvm::Value *value)
        : kind(kind), value(value) { }

    Tag getKind() const { return kind; }

    llvm::Value *getValue() { return value; }

    static bool classof(const Property *prop) { return true; }

private:
    Tag kind;
    llvm::Value *value;
};

}; // end activation namespace.

class SRFrame {

public:
    SRFrame(SRInfo *routineInfo,
            CodeGenRoutine &CGR, llvm::IRBuilder<> &Builder);

    ~SRFrame();

    SRInfo *getSRInfo() { return SRI; }

    SubroutineDecl *getDeclaration() { return SRI->getDeclaration(); }

    llvm::Function *getLLVMFunction() { return SRI->getLLVMFunction(); }

    llvm::IRBuilder<> &getIRBuilder() { return Builder; }

    llvm::BasicBlock *makeBasicBlock(const std::string &name = "",
                                     llvm::BasicBlock *insertBefore = 0);



    void pushFrame(llvm::BasicBlock *associatedBB);

    void popFrame();

    void stacksave();

    void addLandingPad();

    bool hasLandingPad();

    llvm::BasicBlock *getLandingPad();

    void removeLandingPad();


    llvm::Value *createTemp(const llvm::Type *type);

    void associate(const ValueDecl *decl, activation::Tag tag,
                   llvm::Value *slot);

    llvm::Value *lookup(const ValueDecl *decl, activation::Tag tag);

    llvm::Value *createEntry(const ValueDecl *decl, activation::Tag tag,
                             const llvm::Type *type) {
        llvm::Value *slot = createTemp(type);
        associate(decl, tag, slot);
        return slot;
    }


    void associate(const PrimaryType *type, activation::Tag tag,
                   llvm::Value *value);

    llvm::Value *lookup(const PrimaryType *type, activation::Tag tag);

    void emitReturn();

    llvm::Value *getReturnValue() { return returnValue; }

    llvm::Value *getImplicitContext() { return implicitContext; }

    void emitPrologue(llvm::BasicBlock *bodyBB);
    void emitEpilogue();

private:
    class ActivationEntry {

    public:
        ActivationEntry() : plist() { }

        activation::Property *find(activation::Tag tag);

        void add(activation::Property *prop) { plist.push_front(prop); }

    private:
        ActivationEntry(const ActivationEntry &); // Do not implement.
        void operator=(const ActivationEntry &);  // Likewise.

        llvm::iplist<activation::Property> plist;
    };

    class Subframe {

    public:
        Subframe(SRFrame *context, Subframe *parent,
                 llvm::BasicBlock *entryBB);
        ~Subframe();

        bool hasParent() const { return parent != 0; }

        Subframe *getParent() { return parent; }

        void emitStacksave();

        void emitStackrestore();

        void addLandingPad();

        void removeLandingPad() { landingPad = 0; }

        llvm::BasicBlock *getLandingPad() { return landingPad; }

        llvm::BasicBlock *getEntryBB() { return entryBB; }

    private:
        SRFrame *SRF;

        Subframe *parent;

        llvm::Value *restorePtr;

        llvm::BasicBlock *landingPad;

        llvm::BasicBlock *entryBB;
    };

    SRInfo *SRI;

    llvm::IRBuilder<> &Builder;

    llvm::BasicBlock *allocaBB;

    llvm::BasicBlock *returnBB;

    Subframe *currentSubframe;

    llvm::Value *returnValue;

    llvm::Value *implicitContext;

    // Map from Comma Decl's and Type's to AllocaEntry's.
    typedef llvm::DenseMap<const Ast*, ActivationEntry*> EntryMap;
    EntryMap entryTable;

    void injectSubroutineArgs(CodeGenRoutine &CGR);
};

} // end comma namespace.

#endif

---