drlvm/modules/vm/src/main/native/jitrino/shared/optimizer/escapeanalyzer.h

/*
 *  Licensed to the Apache Software Foundation (ASF) under one or more
 *  contributor license agreements.  See the NOTICE file distributed with
 *  this work for additional information regarding copyright ownership.
 *  The ASF licenses this file to You under the Apache License, Version 2.0
 *  (the "License"); you may not use this file except in compliance with
 *  the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */

/**
 * @author Intel, Pavel A. Ozhdikhin
 *
 */

#ifndef _ESCAPEANALYSIS_H_
#define _ESCAPEANALYSIS_H_

#include "open/types.h"
#include "Stl.h"
#include "optpass.h"

namespace Jitrino {

class IRManager;
class ControlFlowGraph;
class Inst;


//DEFINE_OPTPASS(EscapeAnalysisPass)

//
// Simple escape analyzer
//
class EscapeAnalyzer {
public:
    EscapeAnalyzer(IRManager& irm) : irManager(irm) {};
    //
    // Performs escape analysis and returns the number of instructions
    // that do not escape.
    //
    U_32 doAnalysis();
    U_32 doAggressiveAnalysis();
private:
    IRManager& irManager;
};

//
// Def-use chains
//
class DefUseLink;

class DefUseLink {
public:
    Inst*       getUseInst()    {return useInst;}
    U_32      getSrcIndex()   {return srcIndex;}
    DefUseLink* getNext()       {return next;}
private:
    DefUseLink(Inst* use,U_32 index,DefUseLink* n) 
        : useInst(use), srcIndex(index), next(n) 
    {
    }
    Inst*       useInst;
    U_32      srcIndex;
    DefUseLink* next;
    friend class DefUseBuilder;
};

class DefUseBuilder {
public:
    DefUseBuilder(MemoryManager& mm) : memoryManager(mm), defUseTable(mm) {}

    void initialize(ControlFlowGraph& fg);

    DefUseLink* getDefUseLinks(Inst* defInst) {
        return defUseTable[defInst];
    }

    void    addUses(Inst* useInst);
    void    addDefUse(Inst* defInst,Inst* srcInst,U_32 srcIndex);

    DefUseLink* getDefUse(Inst* defInst,Inst* srcInst,U_32 srcIndex);

    void    removeDef(Inst* defInst);
    void    removeDefUse(Inst* defInst,Inst* srcInst,U_32 srcIndex);
private:
    MemoryManager&                              memoryManager;
    StlHashMap<Inst*,DefUseLink*>    defUseTable;
};

} //namespace Jitrino 

#endif // _ESCAPEANALYSIS_H_