ExprEnv.h

Go to the documentation of this file.

/*
 Copyright Disney Enterprises, Inc.  All rights reserved.

 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License
 and the following modification to it: Section 6 Trademarks.
 deleted and replaced with:

 6. Trademarks. This License does not grant permission to use the
 trade names, trademarks, service marks, or product names of the
 Licensor and its affiliates, except as required for reproducing
 the content of the NOTICE file.

 You may obtain a copy of the License at
 http://www.apache.org/licenses/LICENSE-2.0
*/
#ifndef ExprEnv_h
#define ExprEnv_h

#include <vector>
#include <map>
#include <cassert>
#include <memory>

#include "ExprType.h"
#include "ExprLLVM.h"
#include <iostream>


namespace SeExpr2 {
class ExprVarRef;
class ExprLocalVar;
class ExprNode;
class ExprLocalFunctionNode;
class Interpreter;

class ExprLocalVar {
  protected:
    ExprType _type;
    ExprLocalVar* _phi;
    mutable LLVM_VALUE _varPtr;
  public:
    ExprLocalVar(const ExprType& type) : _type(type), _phi(0), _varPtr(0) {}

    virtual ~ExprLocalVar() {}

    const ExprLocalVar* getPhi() const { return _phi; }
    ExprType type() const { return _type; }
    virtual void setPhi(ExprLocalVar* phi) { _phi = phi; }

    virtual LLVM_VALUE codegen(LLVM_BUILDER,const std::string& name,LLVM_VALUE referenceType) LLVM_BODY;

    virtual LLVM_VALUE varPtr() {return _varPtr;}

    int buildInterpreter(Interpreter* interpreter) const;

};

// This is basically like single assignment form inspired. hence the phi node nomenclature.
class ExprLocalVarPhi : public ExprLocalVar {
  public:
    ExprLocalVarPhi(ExprType condLife, ExprLocalVar* thenVar, ExprLocalVar* elseVar)
        : ExprLocalVar(ExprType()), _thenVar(thenVar), _elseVar(elseVar) {
        // find the compatible common-denominator lifetime
        ExprType firstType=_thenVar->type(),secondType=_elseVar->type();
        if(ExprType::valuesCompatible(_thenVar->type(),_elseVar->type())){
            _type=((firstType.isFP(1) ? secondType : firstType).setLifetime(firstType, secondType));
        }
        // lifetime should be the minimum (error=0,varying=1,uniform=2,constant=3).
        // i.e. you can only guarantee something is constant if the condition, ifvar, and else var are the same
        _type.setLifetime(firstType,secondType,condLife);
    }

    bool valid() const{
        return !_type.isError();
    }

    void setPhi(ExprLocalVar* phi) {
        _phi = phi;
        _thenVar->setPhi(phi);
        _elseVar->setPhi(phi);
    }

    ExprNode* _condNode;
    ExprLocalVar* _thenVar, *_elseVar;
};

class ExprVarEnv {
  private:
    typedef std::map<std::string, std::unique_ptr<ExprLocalVar>> VarDictType;
    VarDictType _map;
    typedef std::map<std::string, ExprLocalFunctionNode*> FuncDictType;
    FuncDictType _functions;

    // i.e. a=3;a=[1,2,3];a=[2];a will  yield 2 entries in shadowedVariables
    std::vector<std::unique_ptr<ExprLocalVar>> shadowedVariables;

    std::vector<std::vector<std::pair<std::string,ExprLocalVarPhi*>>> _mergedVariables;

    ExprVarEnv* _parent;

  protected:
    ExprVarEnv(ExprVarEnv& other);
    ExprVarEnv& operator=(ExprVarEnv& other);

  public:
    // TODO: figure out when anotherOwns is needed
    ExprVarEnv() : _parent(0) {};

    ~ExprVarEnv();

    void resetAndSetParent(ExprVarEnv* parent);
    ExprLocalFunctionNode* findFunction(const std::string& name);
    ExprLocalVar* find(const std::string& name);
    ExprLocalVar const* lookup(const std::string& name) const;
    void addFunction(const std::string& name, ExprLocalFunctionNode* prototype);
    void add(const std::string& name, std::unique_ptr<ExprLocalVar> var);
    //    void add(ExprVarEnv & env,const ExprType & modifyingType);
    // static bool branchesMatch(const ExprVarEnv & env1, const ExprVarEnv & env2);
    size_t mergeBranches(const ExprType& type, ExprVarEnv& env1, ExprVarEnv& env2);
    // Code generate merges.
    LLVM_VALUE codegenMerges(LLVM_BUILDER builder,int mergeIndex) LLVM_BODY;
    // Query merges
    std::vector<std::pair<std::string,ExprLocalVarPhi*>>& merge(size_t index){
        return _mergedVariables[index];
    }
};

// It is inspired by IRBuilder's notion of a basic block insertion point
class ExprVarEnvBuilder{
public:
    ExprVarEnvBuilder(){
        reset();
    }
    void reset(){
        std::unique_ptr<ExprVarEnv> newEnv(new ExprVarEnv);
        _currentEnv=newEnv.get();
        all.emplace_back(std::move(newEnv));
    }
    ExprVarEnv* current(){return _currentEnv;}
    void setCurrent(ExprVarEnv* env){_currentEnv=env;}
    ExprVarEnv* createDescendant(ExprVarEnv* parent){
        std::unique_ptr<ExprVarEnv> newEnv(new ExprVarEnv);
        newEnv->resetAndSetParent(parent);
        all.emplace_back(std::move(newEnv));
        return all.back().get();
    }
private:
    std::vector<std::unique_ptr<ExprVarEnv>> all;
    ExprVarEnv* _currentEnv;
};

struct ExprEvalResult {
    ExprEvalResult() : n(0), fp(0), str(0) {}
    ExprEvalResult(int n, double* fp) : n(n), fp(fp), str(0) {}
    ExprEvalResult(const char** c) : n(1), fp(0), str(c) {}
    ExprEvalResult(int n, double* fp, const char** c) : n(n), fp(fp), str(c) {}

    int n;
    double* fp;
    const char** str;
};
}
#endif