// -*- mode: C++; c-file-style: "cc-mode" -*-
//*************************************************************************
// DESCRIPTION: Verilator: Lifelicate variable assignment elimination
//
// Code available from: http://www.veripool.org/verilator
//
//*************************************************************************
//
// Copyright 2003-2019 by Wilson Snyder.  This program is free software; you can
// redistribute it and/or modify it under the terms of either the GNU
// Lesser General Public License Version 3 or the Perl Artistic License
// Version 2.0.
//
// Verilator is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
//*************************************************************************
// LIFE TRANSFORMATIONS:
//      Build control-flow graph with assignments and var usages
//      All modules:
//          ASSIGN(x,...), ASSIGN(x,...) => delete first one
//          We also track across if statements:
//          ASSIGN(X,...) IF( ..., ASSIGN(X,...), ASSIGN(X,...)) => deletes first
//          We don't do the opposite yet though (remove assigns in if followed by outside if)
//
//*************************************************************************

#include "config_build.h"
#include "verilatedos.h"

#include "V3Global.h"
#include "V3Life.h"
#include "V3Stats.h"
#include "V3Ast.h"
#include "V3Const.h"

#include <cstdarg>
#include <map>
#include <vector>

//######################################################################
// Structure for global state

class LifeState {
    // NODE STATE
    //   See below
    AstUser1InUse       m_inuser1;

    // STATE
public:
    V3Double0   m_statAssnDel;  // Statistic tracking
    V3Double0   m_statAssnCon;  // Statistic tracking
    std::vector<AstNode*> m_unlinkps;

public:
    // CONSTRUCTORS
    LifeState() {}
    ~LifeState() {
        V3Stats::addStatSum("Optimizations, Lifetime assign deletions", m_statAssnDel);
        V3Stats::addStatSum("Optimizations, Lifetime constant prop", m_statAssnCon);
        for (std::vector<AstNode*>::iterator it = m_unlinkps.begin();
             it != m_unlinkps.end(); ++it) {
            (*it)->unlinkFrBack();
            (*it)->deleteTree();
        }
    }
    // METHODS
    void pushUnlinkDeletep(AstNode* nodep) { m_unlinkps.push_back(nodep); }
};

//######################################################################
// Structure for each variable encountered

class LifeVarEntry {
    AstNodeAssign*      m_assignp;      // Last assignment to this varscope, NULL if no longer relevant
    AstConst*           m_constp;       // Known constant value
    bool                m_setBeforeUse; // First access was a set (and thus block above may have a set that can be deleted
    bool                m_everSet;      // Was ever assigned (and thus above block may not preserve constant propagation)

    inline void init(bool setBeforeUse) {
        m_assignp = NULL;
        m_constp = NULL;
        m_setBeforeUse = setBeforeUse;
        m_everSet = false;
    }
public:
    class SIMPLEASSIGN {};
    class COMPLEXASSIGN {};
    class CONSUMED {};

    LifeVarEntry(SIMPLEASSIGN, AstNodeAssign* assp) {
        init(true); simpleAssign(assp);
    }
    explicit LifeVarEntry(COMPLEXASSIGN) {
        init(false); complexAssign();
    }
    explicit LifeVarEntry(CONSUMED) {
        init(false); consumed();
    }
    ~LifeVarEntry() {}
    inline void simpleAssign(AstNodeAssign* assp) {  // New simple A=.... assignment
        m_assignp = assp;
        m_constp = NULL;
        m_everSet = true;
        if (VN_IS(assp->rhsp(), Const)) m_constp = VN_CAST(assp->rhsp(), Const);
    }
    inline void complexAssign() {  // A[x]=... or some complicated assignment
        m_assignp = NULL;
        m_constp = NULL;
        m_everSet = true;
    }
    inline void consumed() {  // Rvalue read of A
        m_assignp = NULL;
    }
    AstNodeAssign* assignp() const { return m_assignp; }
    AstConst* constNodep() const { return m_constp; }
    bool setBeforeUse() const { return m_setBeforeUse; }
    bool everSet() const { return m_everSet; }
};

//######################################################################
// Structure for all variables under a given meta-basic block

class LifeBlock {
    // NODE STATE
    // Cleared each AstIf:
    //   AstVarScope::user1()   -> int.       Used in combining to detect duplicates

    // LIFE MAP
    //  For each basic block, we'll make a new map of what variables that if/else is changing
    typedef std::map<AstVarScope*, LifeVarEntry> LifeMap;
    LifeMap     m_map;          // Current active lifetime map for current scope
    LifeBlock*  m_aboveLifep;   // Upper life, or NULL
    LifeState*  m_statep;       // Current global state

    VL_DEBUG_FUNC;  // Declare debug()

public:
    LifeBlock(LifeBlock* aboveLifep, LifeState* statep) {
        m_aboveLifep = aboveLifep;  // Null if top
        m_statep = statep;
    }
    ~LifeBlock() {}
    // METHODS
    void checkRemoveAssign(const LifeMap::iterator& it) {
        AstVar* varp = it->first->varp();
        LifeVarEntry* entp = &(it->second);
        if (!varp->isSigPublic()) {
            // Rather than track what sigs AstUCFunc/AstUCStmt may change,
            // we just don't optimize any public sigs
            // Check the var entry, and remove if appropriate
            if (AstNode* oldassp = entp->assignp()) {
                UINFO(7,"       PREV: "<<oldassp<<endl);
                // Redundant assignment, in same level block
                // Don't delete it now as it will confuse iteration since it maybe WAY
                // above our current iteration point.
                if (debug()>4) oldassp->dumpTree(cout, "       REMOVE/SAMEBLK ");
                entp->complexAssign();
                m_statep->pushUnlinkDeletep(oldassp); VL_DANGLING(oldassp);
                ++m_statep->m_statAssnDel;
            }
        }
    }
    void simpleAssign(AstVarScope* nodep, AstNodeAssign* assp) {
        // Do we have a old assignment we can nuke?
        UINFO(4,"     ASSIGNof: "<<nodep<<endl);
        UINFO(7,"       new: "<<assp<<endl);
        LifeMap::iterator it = m_map.find(nodep);
        if (it != m_map.end()) {
            checkRemoveAssign(it);
            it->second.simpleAssign(assp);
        } else {
            m_map.insert(make_pair(nodep, LifeVarEntry(LifeVarEntry::SIMPLEASSIGN(), assp)));
        }
        //lifeDump();
    }
    void complexAssign(AstVarScope* nodep) {
        UINFO(4,"     clearof: "<<nodep<<endl);
        LifeMap::iterator it = m_map.find(nodep);
        if (it != m_map.end()) {
            it->second.complexAssign();
        } else {
            m_map.insert(make_pair(nodep, LifeVarEntry(LifeVarEntry::COMPLEXASSIGN())));
        }
    }
    void varUsageReplace(AstVarScope* nodep, AstVarRef* varrefp) {
        // Variable rvalue.  If it references a constant, we can simply replace it
        LifeMap::iterator it = m_map.find(nodep);
        if (it != m_map.end()) {
            if (AstConst* constp = it->second.constNodep()) {
                if (!varrefp->varp()->isSigPublic()) {
                    // Aha, variable is constant; substitute in.
                    // We'll later constant propagate
                    UINFO(4,"     replaceconst: "<<varrefp<<endl);
                    varrefp->replaceWith(constp->cloneTree(false));
                    varrefp->deleteTree(); VL_DANGLING(varrefp);
                    ++m_statep->m_statAssnCon;
                    return;  // **DONE, no longer a var reference**
                }
            }
            UINFO(4,"     usage: "<<nodep<<endl);
            it->second.consumed();
        } else {
            m_map.insert(make_pair(nodep, LifeVarEntry(LifeVarEntry::CONSUMED())));
        }
    }
    void complexAssignFind(AstVarScope* nodep) {
        LifeMap::iterator it = m_map.find(nodep);
        if (it != m_map.end()) {
            UINFO(4,"     casfind: "<<it->first<<endl);
            it->second.complexAssign();
        } else {
            m_map.insert(make_pair(nodep, LifeVarEntry(LifeVarEntry::COMPLEXASSIGN())));
        }
    }
    void consumedFind(AstVarScope* nodep) {
        LifeMap::iterator it = m_map.find(nodep);
        if (it != m_map.end()) {
            it->second.consumed();
        } else {
            m_map.insert(make_pair(nodep, LifeVarEntry(LifeVarEntry::CONSUMED())));
        }
    }
    void lifeToAbove() {
        // Any varrefs under a if/else branch affect statements outside and after the if/else
        if (!m_aboveLifep) v3fatalSrc("Pushing life when already at the top level");
        for (LifeMap::iterator it = m_map.begin(); it!=m_map.end(); ++it) {
            AstVarScope* nodep = it->first;
            m_aboveLifep->complexAssignFind(nodep);
            if (it->second.everSet()) {
                // Record there may be an assignment, so we don't constant propagate across the if.
                complexAssignFind(nodep);
            } else {
                // Record consumption, so we don't eliminate earlier assignments
                consumedFind(nodep);
            }
        }
    }
    void dualBranch(LifeBlock* life1p, LifeBlock* life2p) {
        // Find any common sets on both branches of IF and propagate upwards
        //life1p->lifeDump();
        //life2p->lifeDump();
        AstNode::user1ClearTree();  // user1p() used on entire tree
        for (LifeMap::iterator it = life1p->m_map.begin(); it!=life1p->m_map.end(); ++it) {
            // When the if branch sets a var before it's used, mark that variable
            if (it->second.setBeforeUse()) it->first->user1(1);
        }
        for (LifeMap::iterator it = life2p->m_map.begin(); it!=life2p->m_map.end(); ++it) {
            // When the else branch sets a var before it's used
            AstVarScope* nodep = it->first;
            if (it->second.setBeforeUse() && nodep->user1()) {
                // Both branches set the var, we can remove the assignment before the IF.
                UINFO(4,"DUALBRANCH "<<nodep<<endl);
                LifeMap::iterator itab = m_map.find(nodep);
                if (itab != m_map.end()) {
                    checkRemoveAssign(itab);
                }
            }
        }
        //this->lifeDump();
    }
    // DEBUG
    void lifeDump() {
        UINFO(5, "  LifeMap:"<<endl);
        for (LifeMap::iterator it = m_map.begin(); it!=m_map.end(); ++it) {
            UINFO(5, "     Ent:  "
                  <<(it->second.setBeforeUse()?"[F]  ":"     ")
                  <<it->first<<endl);
            if (it->second.assignp()) {
                UINFO(5, "       Ass: "<<it->second.assignp()<<endl);
            }
        }
    }
};

//######################################################################
// Life state, as a visitor of each AstNode

class LifeVisitor : public AstNVisitor {
private:
    // STATE
    LifeState*  m_statep;       // Current state
    bool        m_sideEffect;   // Side effects discovered in assign RHS
    bool        m_noopt;        // Disable optimization of variables in this block
    bool        m_tracingCall;  // Iterating into a CCall to a CFunc

    // LIFE MAP
    //  For each basic block, we'll make a new map of what variables that if/else is changing
    typedef std::map<AstVarScope*, LifeVarEntry> LifeMap;
    // cppcheck-suppress memleak  // cppcheck bug - it is deleted
    LifeBlock*  m_lifep;        // Current active lifetime map for current scope

    // METHODS
    VL_DEBUG_FUNC;  // Declare debug()

    // VISITORS
    virtual void visit(AstVarRef* nodep) {
        // Consumption/generation of a variable,
        // it's used so can't elim assignment before this use.
        if (!nodep->varScopep()) nodep->v3fatalSrc("NULL");
        //
        AstVarScope* vscp = nodep->varScopep();
        if (!vscp) nodep->v3fatalSrc("Scope not assigned");
        if (nodep->lvalue()) {
            m_lifep->complexAssign(vscp);
        } else {
            m_lifep->varUsageReplace(vscp, nodep); VL_DANGLING(nodep);
        }
    }
    virtual void visit(AstNodeAssign* nodep) {
        // Collect any used variables first, as lhs may also be on rhs
        // Similar code in V3Dead
        vluint64_t lastEdit = AstNode::editCountGbl();  // When it was last edited
        m_sideEffect = false;
        iterateAndNextNull(nodep->rhsp());
        if (lastEdit != AstNode::editCountGbl()) {
            // We changed something, try to constant propagate, but don't delete the
            // assignment as we still need nodep to remain.
            V3Const::constifyEdit(nodep->rhsp());  // rhsp may change
        }
        // Has to be direct assignment without any EXTRACTing.
        if (VN_IS(nodep->lhsp(), VarRef) && !m_sideEffect && !m_noopt) {
            AstVarScope* vscp = VN_CAST(nodep->lhsp(), VarRef)->varScopep();
            if (!vscp) nodep->v3fatalSrc("Scope lost on variable");
            m_lifep->simpleAssign(vscp, nodep);
        } else {
            iterateAndNextNull(nodep->lhsp());
        }
    }
    virtual void visit(AstAssignDly* nodep) {
        // Don't treat as normal assign; V3Life doesn't understand time sense
        iterateChildren(nodep);
    }

    //---- Track control flow changes
    virtual void visit(AstNodeIf* nodep) {
        UINFO(4,"   IF "<<nodep<<endl);
        // Condition is part of PREVIOUS block
        iterateAndNextNull(nodep->condp());
        LifeBlock* prevLifep = m_lifep;
        LifeBlock* ifLifep   = new LifeBlock(prevLifep, m_statep);
        LifeBlock* elseLifep = new LifeBlock(prevLifep, m_statep);
        {
            m_lifep = ifLifep;
            iterateAndNextNull(nodep->ifsp());
            m_lifep = prevLifep;
        }
        {
            m_lifep = elseLifep;
            iterateAndNextNull(nodep->elsesp());
            m_lifep = prevLifep;
        }
        UINFO(4,"   join "<<endl);
        // Find sets on both flows
        m_lifep->dualBranch(ifLifep, elseLifep);
        // For the next assignments, clear any variables that were read or written in the block
        ifLifep->lifeToAbove();
        elseLifep->lifeToAbove();
        delete ifLifep;
        delete elseLifep;
    }

    virtual void visit(AstWhile* nodep) {
        // While's are a problem, as we don't allow loops in the graph.  We
        // may go around the cond/body multiple times.  Thus a
        // lifelication just in the body is ok, but we can't delete an
        // assignment in the body that's used in the cond.  (And otherwise
        // would because it only appears used after-the-fact.  So, we model
        // it as a IF statement, and just don't allow elimination of
        // variables across the body.
        LifeBlock* prevLifep = m_lifep;
        LifeBlock* condLifep = new LifeBlock(prevLifep, m_statep);
        LifeBlock* bodyLifep = new LifeBlock(prevLifep, m_statep);
        {
            m_lifep = condLifep;
            iterateAndNextNull(nodep->precondsp());
            iterateAndNextNull(nodep->condp());
            m_lifep = prevLifep;
        }
        {
            m_lifep = bodyLifep;
            iterateAndNextNull(nodep->bodysp());
            iterateAndNextNull(nodep->incsp());
            m_lifep = prevLifep;
        }
        UINFO(4,"   joinfor"<<endl);
        // For the next assignments, clear any variables that were read or written in the block
        condLifep->lifeToAbove();
        bodyLifep->lifeToAbove();
        delete condLifep;
        delete bodyLifep;
    }
    virtual void visit(AstJumpLabel* nodep) {
        // As with While's we can't predict if a JumpGo will kill us or not
        // It's worse though as an IF(..., JUMPGO) may change the control flow.
        // Just don't optimize blocks with labels; they're rare - so far.
        LifeBlock* prevLifep = m_lifep;
        LifeBlock* bodyLifep = new LifeBlock(prevLifep, m_statep);
        bool prev_noopt = m_noopt;
        {
            m_lifep = bodyLifep;
            m_noopt = true;
            iterateAndNextNull(nodep->stmtsp());
            m_lifep = prevLifep;
            m_noopt = prev_noopt;
        }
        UINFO(4,"   joinjump"<<endl);
        // For the next assignments, clear any variables that were read or written in the block
        bodyLifep->lifeToAbove();
        delete bodyLifep;
    }
    virtual void visit(AstCCall* nodep) {
        //UINFO(4,"  CCALL "<<nodep<<endl);
        iterateChildren(nodep);
        // Enter the function and trace it
        if (!nodep->funcp()->entryPoint()) {  // else is non-inline or public function we optimize separately
            m_tracingCall = true;
            iterate(nodep->funcp());
        }
    }
    virtual void visit(AstCFunc* nodep) {
        //UINFO(4,"  CCALL "<<nodep<<endl);
        if (!m_tracingCall && !nodep->entryPoint()) return;
        m_tracingCall = false;
        if (nodep->dpiImport() && !nodep->pure()) {
            m_sideEffect = true;  // If appears on assign RHS, don't ever delete the assignment
        }
        iterateChildren(nodep);
    }
    virtual void visit(AstUCFunc* nodep) {
        m_sideEffect = true;  // If appears on assign RHS, don't ever delete the assignment
        iterateChildren(nodep);
    }
    virtual void visit(AstCMath* nodep) {
        m_sideEffect = true;  // If appears on assign RHS, don't ever delete the assignment
        iterateChildren(nodep);
    }

    virtual void visit(AstVar*) {}  // Don't want varrefs under it
    virtual void visit(AstNode* nodep) {
        iterateChildren(nodep);
    }

public:
    // CONSTRUCTORS
    LifeVisitor(AstNode* nodep, LifeState* statep) {
        UINFO(4,"  LifeVisitor on "<<nodep<<endl);
        m_statep = statep;
        m_sideEffect = false;
        m_noopt = false;
        m_tracingCall = false;
        {
            m_lifep = new LifeBlock(NULL, m_statep);
            iterate(nodep);
            if (m_lifep) { delete m_lifep; m_lifep = NULL; }
        }
    }
    virtual ~LifeVisitor() {
        if (m_lifep) { delete m_lifep; m_lifep = NULL; }
    }
};

//######################################################################

class LifeTopVisitor : public AstNVisitor {
    // Visit all top nodes searching for functions that are entry points we want to start
    // finding code within.
private:
    // STATE
    LifeState* m_statep;        // Current state

    // VISITORS
    virtual void visit(AstCFunc* nodep) {
        if (nodep->entryPoint()) {
            // Usage model 1: Simulate all C code, doing lifetime analysis
            LifeVisitor visitor (nodep, m_statep);
        }
    }
    virtual void visit(AstAlways* nodep) {
        // Usage model 2: Cleanup basic blocks
        LifeVisitor visitor (nodep, m_statep);
    }
    virtual void visit(AstInitial* nodep) {
        // Usage model 2: Cleanup basic blocks
        LifeVisitor visitor (nodep, m_statep);
    }
    virtual void visit(AstFinal* nodep) {
        // Usage model 2: Cleanup basic blocks
        LifeVisitor visitor (nodep, m_statep);
    }
    virtual void visit(AstVar*) {}  // Accelerate
    virtual void visit(AstNodeStmt*) {}  // Accelerate
    virtual void visit(AstNodeMath*) {}  // Accelerate
    virtual void visit(AstNode* nodep) {
        iterateChildren(nodep);
    }
public:
    // CONSTRUCTORS
    LifeTopVisitor(AstNetlist* nodep, LifeState* statep) {
        m_statep = statep;
        iterate(nodep);
    }
    virtual ~LifeTopVisitor() {}
};

//######################################################################
// Life class functions

void V3Life::lifeAll(AstNetlist* nodep) {
    UINFO(2,__FUNCTION__<<": "<<endl);
    {
        LifeState state;
        LifeTopVisitor visitor (nodep, &state);
    }  // Destruct before checking
    V3Global::dumpCheckGlobalTree("life", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3);
}
