/*
 *  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 Nikolay A. Sidelnikov
 */
#include <cstring>
#include "Ia32IRManager.h"

namespace Jitrino
{
namespace Ia32{

    template<class T> struct AttrDesc {
        T value;
        const char * name;
    };

    struct BBStats {
        int64 * bbExecCount;
        U_32 *    counters;

        BBStats() : bbExecCount(NULL), counters(NULL) {}
    };

    struct MethodStats {
        std::string methodName;
        StlMap<int, BBStats> bbStats; //bbID, bbExecCount, array of counters
        MethodStats(std::string s, MemoryManager& mm) : methodName(s), bbStats(mm) {}
    };

typedef StlVector<MethodStats *> Statistics;

template<class T> class FilterAttr {
    public:
        T       value;
        bool    isInitialized;
        bool    isNegative;

        FilterAttr(T v, bool i = false, bool n = false) : value(v), isInitialized(i), isNegative(n) {};
        
        FilterAttr& operator=(const FilterAttr& c) {
            FilterAttr& f = *this;
            f.value = c.value;
            f.isInitialized = c.isInitialized;
            f.isNegative = c.isNegative;
            return f;
        }
};

struct OpndFilter {
        bool                            isInitialized;
        int                             opNum;
        FilterAttr<Inst::OpndRole>      opndRole;
        FilterAttr<OpndKind>            opndKind;
        FilterAttr<RegName>             regName;
        FilterAttr<MemOpndKind>         memOpndKind;

        OpndFilter() : isInitialized(false), opNum(-1), opndRole(Inst::OpndRole_Null), opndKind(OpndKind_Null), regName(RegName_Null), memOpndKind(MemOpndKind_Null) {}
        
        OpndFilter& operator=(const OpndFilter& c) {
            OpndFilter& f = *this;
            f.isInitialized = c.isInitialized;      
            f.opNum = c.opNum;
            f.opndRole          =c.opndRole;    
            f.opndKind          =c.opndKind;    
            f.regName           =c.regName;     
            f.memOpndKind       =c.memOpndKind; 
            return f;
        }

};

struct Filter {
        bool    isInitialized;
        bool    isNegative;
        bool    isOR;

        FilterAttr<Mnemonic>                                mnemonic;
        FilterAttr<I_32>                                   operandNumber;
        FilterAttr<Opnd::RuntimeInfo::Kind>                 rtKind;
        FilterAttr<VM_RT_SUPPORT>                           rtHelperID;
        FilterAttr<std::string>                             rtIntHelperName;
        FilterAttr<bool>                                    isNative;
        FilterAttr<bool>                                    isStatic;
        FilterAttr<bool>                                    isSynchronized;
        FilterAttr<bool>                                    isNoInlining;
        FilterAttr<bool>                                    isInstance;
        FilterAttr<bool>                                    isFinal;
        FilterAttr<bool>                                    isVirtual;
        FilterAttr<bool>                                    isAbstract;
        FilterAttr<bool>                                    isClassInitializer;
        FilterAttr<bool>                                    isInstanceInitializer;
        FilterAttr<bool>                                    isStrict;
        FilterAttr<bool>                                    isInitLocals;

        StlMap<int, OpndFilter> operandFilters;

        Filter() : isInitialized(false), isNegative(false), isOR(false), mnemonic(Mnemonic_NULL), operandNumber(-1), rtKind(Opnd::RuntimeInfo::Kind_Null), rtHelperID(VM_RT_UNKNOWN), rtIntHelperName("none"), isNative(false), isStatic(false), isSynchronized(false), isNoInlining(false), isInstance(false), isFinal(false), isVirtual(false), isAbstract(false), isClassInitializer(false), isInstanceInitializer(false), isStrict(false), isInitLocals(false), operandFilters(Jitrino::getGlobalMM()) {}

        Filter& operator=(const Filter& c) {
            Filter& f = *this;
            f.isNegative = c.isNegative;
            f.isInitialized = c.isInitialized;
            f.isOR = c.isOR;
            f.mnemonic=c.mnemonic;
            f.operandNumber=c.operandNumber;
            f.rtKind=c.rtKind;
            f.rtHelperID=c.rtHelperID;
            f.rtIntHelperName=c.rtIntHelperName;
            f.isNative=c.isNative;
            f.isStatic=c.isStatic;
            f.isSynchronized=c.isSynchronized;
            f.isNoInlining            =  c.isNoInlining;              
            f.isInstance             =  c.isInstance;                
            f.isFinal               =  c.isFinal;                   
            f.isVirtual              =  c.isVirtual;                 
            f.isAbstract              =  c.isAbstract;                
            f.isClassInitializer      =  c.isClassInitializer;        
            f.isInstanceInitializer   =  c.isInstanceInitializer;     
            f.isStrict                =  c.isStrict;                  
            f.isInitLocals            =  c.isInitLocals;              

            for(StlMap<int, OpndFilter>::const_iterator it = c.operandFilters.begin(); it !=c.operandFilters.end(); it++) {
                f.operandFilters[it->first] = it->second;
            }
            return f;
        }
};

struct Counter {
        std::string     name;
        std::string     title;
        bool            isSorting;
        Filter          filter;

        Counter() : isSorting(false) {}
};

class Config {
public:
    StlVector<Counter> counters;

    bool printBBStats;
    Config(MemoryManager& mm) : counters(mm), printBBStats(false) {};
};


//========================================================================================
// class InternalProfiler
//========================================================================================
/**
    class InternalProfiler collects information about methods 
    
*/

class InternalProfilerAct : public Action {
public:
    void init();
    void deinit() { dumpIt(); config = NULL; }

protected:
    void readConfig(Config * config);
    void dumpIt();

    Config * config;
    Statistics * statistics;

friend class InternalProfiler;
};


class InternalProfiler : public SessionAction {
public: 
    void runImpl();

protected:
    void addCounters(MethodDesc& methodDesc);

    bool passFilter(Inst * inst, Filter& filter);
    bool passOpndFilter(Inst * inst, Opnd * opnd, Filter& filter, OpndFilter& opndFltr);    
};

const AttrDesc<Inst::OpndRole> opndRoles[] = {
    {Inst::OpndRole_Null,"Null"},
    {Inst::OpndRole_Use,"Use"},
    {Inst::OpndRole_Def, "Def"},
    {Inst::OpndRole_UseDef,"UseDef"},
    {Inst::OpndRole_FromEncoder, "FromEncoder"},
    {Inst::OpndRole_Explicit, "Explicit"},
    {Inst::OpndRole_Auxilary, "Auxilary"},
    {Inst::OpndRole_Changeable, "Changeable"},
    {Inst::OpndRole_Implicit, "Implicit"},
    {Inst::OpndRole_InstLevel, "InstLevel"},
    {Inst::OpndRole_MemOpndSubOpnd, "MemOpndSubOpnd"},
    {Inst::OpndRole_OpndLevel, "OpndLevel"},
    {Inst::OpndRole_ForIterator, "ForIterator"},
    {Inst::OpndRole_All, "All"},
    {Inst::OpndRole_AllDefs, "AllDefs"},
    {Inst::OpndRole_AllUses, "AllUses"},
};

const AttrDesc<MemOpndKind> memOpndKinds[] = {
    {MemOpndKind_Null, "Null"},
    {MemOpndKind_StackAutoLayout, "StackAutoLayout"},
    {MemOpndKind_StackManualLayout, "StackManualLayout"}, 
    {MemOpndKind_Stack, "Stack"}, 
    {MemOpndKind_Heap, "Heap"}, 
    {MemOpndKind_ConstantArea, "ConstantArea"}, 
    {MemOpndKind_Any, "Any"},
};

const AttrDesc<Opnd::RuntimeInfo::Kind> rtKinds[] = {
    {Opnd::RuntimeInfo::Kind_Null, "Null"},
    {Opnd::RuntimeInfo::Kind_AllocationHandle,  "AllocationHandle"},
    {Opnd::RuntimeInfo::Kind_TypeRuntimeId, "TypeRuntimeId" },
    {Opnd::RuntimeInfo::Kind_MethodRuntimeId,"MethodRuntimeId"  },  
    {Opnd::RuntimeInfo::Kind_StringDescription, "StringDescription" },
    {Opnd::RuntimeInfo::Kind_Size,  "Size"  },
    {Opnd::RuntimeInfo::Kind_HelperAddress, "HelperAddress"},
    {Opnd::RuntimeInfo::Kind_InternalHelperAddress, "InternalHelperAddress"},
    {Opnd::RuntimeInfo::Kind_StaticFieldAddress,"StaticFieldAddress"},
    {Opnd::RuntimeInfo::Kind_FieldOffset,"FieldOffset"},
    {Opnd::RuntimeInfo::Kind_VTableAddrOffset,"VTableAddrOffset"},
    {Opnd::RuntimeInfo::Kind_VTableConstantAddr,"VTableConstantAddr"},
    {Opnd::RuntimeInfo::Kind_MethodVtableSlotOffset,"MethodVtableSlotOffset"},
    {Opnd::RuntimeInfo::Kind_MethodIndirectAddr,"MethodIndirectAddr"},
    {Opnd::RuntimeInfo::Kind_MethodDirectAddr,"MethodDirectAddr"},
    {Opnd::RuntimeInfo::Kind_ConstantAreaItem,"ConstantAreaItem"},
};

static ActionFactory<InternalProfiler, InternalProfilerAct> _iprof("iprof");

void InternalProfilerAct::init() {
    MemoryManager& mm = Jitrino::getGlobalMM();
    config = new(mm) Config(mm);
    statistics = new(mm) Statistics(mm);
    readConfig(config);
}

void InternalProfilerAct::readConfig(Config * config) {
    std::string configString;
    std::ifstream configFile;
    const char* fname;
    if ((fname = getArg("config")) == 0)
        fname = "iprof.cfg";
    configFile.open(fname, std::ios::in);

    bool rc = false;
    if (configFile.is_open()) {
        std::string line;
        U_32 ln = 0;
        bool opened = false;
        int num = -1;
        while (std::getline(configFile, line)) {
            ln++;
            if(!line.empty() && (line.find("#")!= 0)) {
                const char * c_line = line.c_str();
                if(std::strstr(c_line, "Config") == c_line) {
                    if(((int)line.find("PrintBBStats") != -1) && ((int)line.find("true")!=-1))
                        config->printBBStats = true;
                } else if (line.find("Counter.") == 0) {
                    if(!opened) {
                        opened = true;
                        num = (int)config->counters.size();
                        config->counters.push_back(Counter());
                        int pos1 = (int)line.find(".");
                        int pos2 = (int)line.find_first_of(".=" , pos1+1);

                        config->counters[num].name =    line.substr(pos1+1, pos2-pos1-1);
                    }
                    if((int)line.find(".Title=")!=-1) {
                        char * val = (char *)std::strstr(line.c_str(),"=")+1;
                        config->counters[num].title=std::string(val);
                    } else if (((int)line.find(".IsOR=")!=-1) && ((int)line.find("true")!=-1)) {
                        config->counters[num].filter.isOR=true;
                    } else if ((int)line.find(std::string(config->counters[num].name)+"=")!=-1) {
                        char * val = (char *)std::strstr(line.c_str(),"=")+1;
                        for(U_32 i = 0; i < config->counters.size(); i++) {
                            if(std::string(config->counters[i].name) == val) {
                                config->counters[num].filter = config->counters[i].filter;
                                break;
                            }
                        }
                    } else if((int)line.find(".Mnemonic")!=-1) {
                        char * mnem = (char *)std::strstr(line.c_str(),"=")+1;
                        if ((std::string(mnem) == "true") && (std::strstr(line.c_str(), "IsNegative"))) {
                            config->counters[num].filter.mnemonic.isNegative=true;
                        } else {
                            config->counters[num].filter.isInitialized=true;
                            config->counters[num].filter.mnemonic.value=EncoderBase::str2mnemonic(mnem);
                            config->counters[num].filter.mnemonic.isInitialized=true;
                        }
                    } else if (std::strstr(line.c_str(), ".OpndNumber")) {
                        char * val = (char *)std::strstr(line.c_str(),"=")+1;
                        if ((std::string(val) == "true") && (std::strstr(line.c_str(), "IsNegative"))) {
                            config->counters[num].filter.operandNumber.isNegative=true;
                        } else {
                            config->counters[num].filter.isInitialized=true;
                            config->counters[num].filter.operandNumber.value=atoi(val);
                            config->counters[num].filter.operandNumber.isInitialized=true;
                        }
                    } else if ((int)line.find(".Operand.") != -1) {
                        char * val = (char *)std::strstr(line.c_str(),"=")+1;
                        int pos = int(line.find(".Operand.")+9);
                        std::string v = line.substr(pos, line.find_first_of(".", pos)-pos);
                        int opNum;
                        if(v == "*")
                            opNum = -1;
                        else 
                            opNum = atoi(v.c_str());
                        config->counters[num].filter.operandFilters[opNum].opNum = opNum;
                        config->counters[num].filter.operandFilters[opNum].isInitialized = true;
                        if ((int)line.find(".OpndRole") != -1) {
                            if ((std::string(val) == "true") && (std::strstr(line.c_str(), "IsNegative"))) {
                                config->counters[num].filter.operandFilters[opNum].opndRole.isNegative=true;
                            } else {
                                config->counters[num].filter.isInitialized=true;
                                config->counters[num].filter.operandFilters[opNum].opndRole.isInitialized=true;
                                for (U_32 i = 0; i<lengthof(opndRoles); i++) {
                                    if(std::string(opndRoles[i].name) == val)
                                        config->counters[num].filter.operandFilters[opNum].opndRole.value=opndRoles[i].value;
                                }
                            }
                        } else if ((int)line.find(".OpndKind") != -1) {
                            if ((std::string(val) == "true") && (std::strstr(line.c_str(), "IsNegative"))) {
                                config->counters[num].filter.operandFilters[opNum].opndKind.isNegative=true;
                            } else {
                                config->counters[num].filter.isInitialized=true;
                                config->counters[num].filter.operandFilters[opNum].opndKind.isInitialized=true;
                                config->counters[num].filter.operandFilters[opNum].opndKind.value=getOpndKind(val);
                            }
                        } else if ((int)line.find(".RegName") != -1) {
                            if ((std::string(val) == "true") && (std::strstr(line.c_str(), "IsNegative"))) {
                                config->counters[num].filter.operandFilters[opNum].opndRole.isNegative=true;
                            } else {
                                config->counters[num].filter.isInitialized=true;
                                config->counters[num].filter.operandFilters[opNum].regName.isInitialized=true;
                                config->counters[num].filter.operandFilters[opNum].regName.value = getRegName(val);
                            }
                        } else if ((int)line.find(".MemOpndKind") != -1) {
                            if ((std::string(val) == "true") && (std::strstr(line.c_str(), "IsNegative"))) {
                                config->counters[num].filter.operandFilters[opNum].memOpndKind.isNegative=true;
                            } else {
                                config->counters[num].filter.isInitialized=true;
                                config->counters[num].filter.operandFilters[opNum].memOpndKind.isInitialized=true;
                                for (U_32 i = 0; i<lengthof(memOpndKinds); i++) {
                                    if(std::string(memOpndKinds[i].name) == val)
                                        config->counters[num].filter.operandFilters[opNum].memOpndKind.value=memOpndKinds[i].value;
                                }
                            }
                        }
                    } else if ((int)line.find(".RuntimeInfo.Kind") != -1) {
                        char * val = (char *)std::strstr(line.c_str(),"=")+1;
                        if ((std::string(val) == "true") && (std::strstr(line.c_str(), "IsNegative"))) {
                            config->counters[num].filter.rtKind.isNegative=true;
                        } else {
                            config->counters[num].filter.isInitialized=true;
                            for (U_32 i = 0; i<lengthof(rtKinds); i++) {
                                if(std::string(rtKinds[i].name) == val)
                                    config->counters[num].filter.rtKind.value=rtKinds[i].value;
                            }
                                //CompilationInterface::str2rid(val);
                            config->counters[num].filter.rtKind.isInitialized=true;
                        }
                    } else if ((int)line.find(".RuntimeInfo.HelperID") != -1) {
                        char * val = (char *)std::strstr(line.c_str(),"=")+1;
                        if ((std::string(val) == "true") && (std::strstr(line.c_str(), "IsNegative"))) {
                            config->counters[num].filter.rtHelperID.isNegative=true;
                        } else {
                            config->counters[num].filter.isInitialized=true;
                            config->counters[num].filter.rtHelperID.value=CompilationInterface::str2rid(val);
                            config->counters[num].filter.rtHelperID.isInitialized=true;
                        }
                    } else if ((int)line.find(".RuntimeInfo.IntHelperName") != -1) {
                        char * val = (char *)std::strstr(line.c_str(),"=")+1;
                        if ((std::string(val) == "true") && (std::strstr(line.c_str(), "IsNegative"))) {
                            config->counters[num].filter.rtIntHelperName.isNegative=true;
                        } else {
                            config->counters[num].filter.isInitialized=true;
                            config->counters[num].filter.rtIntHelperName.value=std::string(val);
                            config->counters[num].filter.rtIntHelperName.isInitialized=true;
                        }
                    } else if ((int)line.find(".isNative") != -1) {
                        char * val = (char *)std::strstr(line.c_str(),"=")+1;
                        if ((std::string(val) == "true") && (std::strstr(line.c_str(), "IsNegative"))) {
                            config->counters[num].filter.isNative.isNegative=true;
                        } else {
                            config->counters[num].filter.isInitialized=true;
                            config->counters[num].filter.isNative.value=(std::string(val) == "true")? true : false;
                            config->counters[num].filter.isNative.isInitialized=true;
                        }
                    } else if ((int)line.find(".isStatic") != -1) {
                        char * val = (char *)std::strstr(line.c_str(),"=")+1;
                        if ((std::string(val) == "true") && (std::strstr(line.c_str(), "IsNegative"))) {
                            config->counters[num].filter.isStatic.isNegative=true;
                        } else {
                            config->counters[num].filter.isInitialized=true;
                            config->counters[num].filter.isStatic.value=(std::string(val) == "true")? true : false;
                            config->counters[num].filter.isStatic.isInitialized=true;
                        }
                    } else if ((int)line.find(".isSynchronized") != -1) {
                        char * val = (char *)std::strstr(line.c_str(),"=")+1;
                        if ((std::string(val) == "true") && (std::strstr(line.c_str(), "IsNegative"))) {
                            config->counters[num].filter.isSynchronized.isNegative=true;
                        } else {
                            config->counters[num].filter.isInitialized=true;
                            config->counters[num].filter.isSynchronized.value=(std::string(val) == "true")? true : false;
                            config->counters[num].filter.isSynchronized.isInitialized=true;
                        }
                    } else if ((int)line.find(".isNoInlining") != -1) {
                        char * val = (char *)std::strstr(line.c_str(),"=")+1;
                        if ((std::string(val) == "true") && (std::strstr(line.c_str(), "IsNegative"))) {
                            config->counters[num].filter.isNoInlining.isNegative=true;
                        } else {
                            config->counters[num].filter.isInitialized=true;
                            config->counters[num].filter.isNoInlining.value=(std::string(val) == "true")? true : false;
                            config->counters[num].filter.isNoInlining.isInitialized=true;
                        }
                    } else if ((int)line.find(".isInstance") != -1) {
                        char * val = (char *)std::strstr(line.c_str(),"=")+1;
                        if ((std::string(val) == "true") && (std::strstr(line.c_str(), "IsNegative"))) {
                            config->counters[num].filter.isInstance.isNegative=true;
                        } else {
                            config->counters[num].filter.isInitialized=true;
                            config->counters[num].filter.isInstance.value=(std::string(val) == "true")? true : false;
                            config->counters[num].filter.isInstance.isInitialized=true;
                        }
                    } else if ((int)line.find(".isFinal") != -1) {
                        char * val = (char *)std::strstr(line.c_str(),"=")+1;
                        if ((std::string(val) == "true") && (std::strstr(line.c_str(), "IsNegative"))) {
                            config->counters[num].filter.isFinal.isNegative=true;
                        } else {
                            config->counters[num].filter.isInitialized=true;
                            config->counters[num].filter.isFinal.value=(std::string(val) == "true")? true : false;
                            config->counters[num].filter.isFinal.isInitialized=true;
                        }
                    } else if ((int)line.find(".isVirtual") != -1) {
                        char * val = (char *)std::strstr(line.c_str(),"=")+1;
                        if ((std::string(val) == "true") && (std::strstr(line.c_str(), "IsNegative"))) {
                            config->counters[num].filter.isVirtual.isNegative=true;
                        } else {
                            config->counters[num].filter.isInitialized=true;
                            config->counters[num].filter.isVirtual.value=(std::string(val) == "true")? true : false;
                            config->counters[num].filter.isVirtual.isInitialized=true;
                        }
                    } else if ((int)line.find(".isAbstract") != -1) {
                        char * val = (char *)std::strstr(line.c_str(),"=")+1;
                        if ((std::string(val) == "true") && (std::strstr(line.c_str(), "IsNegative"))) {
                            config->counters[num].filter.isAbstract.isNegative=true;
                        } else {
                            config->counters[num].filter.isInitialized=true;
                            config->counters[num].filter.isAbstract.value=(std::string(val) == "true")? true : false;
                            config->counters[num].filter.isAbstract.isInitialized=true;
                        }
                    } else if ((int)line.find(".isClassInitializer") != -1) {
                        char * val = (char *)std::strstr(line.c_str(),"=")+1;
                        if ((std::string(val) == "true") && (std::strstr(line.c_str(), "IsNegative"))) {
                            config->counters[num].filter.isClassInitializer.isNegative=true;
                        } else {
                            config->counters[num].filter.isInitialized=true;
                            config->counters[num].filter.isClassInitializer.value=(std::string(val) == "true")? true : false;
                            config->counters[num].filter.isClassInitializer.isInitialized=true;
                        }
                    } else if ((int)line.find(".isInstanceInitializer") != -1) {
                        char * val = (char *)std::strstr(line.c_str(),"=")+1;
                        if ((std::string(val) == "true") && (std::strstr(line.c_str(), "IsNegative"))) {
                            config->counters[num].filter.isInstanceInitializer.isNegative=true;
                        } else {
                            config->counters[num].filter.isInitialized=true;
                            config->counters[num].filter.isInstanceInitializer.value=(std::string(val) == "true")? true : false;
                            config->counters[num].filter.isInstanceInitializer.isInitialized=true;
                        }
                    } else if ((int)line.find(".isStrict") != -1) {
                        char * val = (char *)std::strstr(line.c_str(),"=")+1;
                        if ((std::string(val) == "true") && (std::strstr(line.c_str(), "IsNegative"))) {
                            config->counters[num].filter.isStrict.isNegative=true;
                        } else {
                            config->counters[num].filter.isInitialized=true;
                            config->counters[num].filter.isStrict.value=(std::string(val) == "true")? true : false;
                            config->counters[num].filter.isStrict.isInitialized=true;
                        }
                    } else if ((int)line.find(".isInitLocals") != -1) {
                        char * val = (char *)std::strstr(line.c_str(),"=")+1;
                        if ((std::string(val) == "true") && (std::strstr(line.c_str(), "IsNegative"))) {
                            config->counters[num].filter.isInitLocals.isNegative=true;
                        } else {
                            config->counters[num].filter.isInitialized=true;
                            config->counters[num].filter.isInitLocals.value=(std::string(val) == "true")? true : false;
                            config->counters[num].filter.isInitLocals.isInitialized=true;
                        }
                    }
                } else if (std::strstr(c_line, "[begin]") == c_line) {
                } else if (std::strstr(c_line, "[end]") == c_line) {
                    opened = false;
                } else if (std::strstr(c_line, "#") == c_line) {
                } else {
                    ::std::cerr<<"iprof: BAD LINE("<<ln<<") in configuration file"<<::std::endl;
                    exit(1);
                }
                configString+=line+"\n";
            }
        }
        rc = !configString.empty();
    } 
    if (!rc) {
        ::std::cerr<<"iprof: Can't read configuration"<<::std::endl;
    }
}

void InternalProfilerAct::dumpIt() {
    if(!config || !config->counters.size())
        return;
    const char* fname;
    if ((fname = getArg("out")) == 0)
        fname = "iprof.stat";
    std::ofstream outFile(fname, std::ios::ate);
    outFile << "Method name\t";
    for(U_32 i = 0; i < config->counters.size(); i++) {
        std::string fName = config->counters[i].title != "" ? config->counters[i].title : config->counters[i].name;
        outFile << fName << "\t";
    }
    outFile << "\n";
    
    for(Statistics::const_iterator it = statistics->begin(); it != statistics->end(); it++) {
        MethodStats * stats = *it;
        outFile << stats->methodName.c_str()  << "\t";
        BBStats bbs = stats->bbStats[-1];
        for(U_32 i = 0; i < config->counters.size(); i++) {
            int64 count;
            std::string name = config->counters[i].name;
            if((name == "ByteCodeSize") || (name == "ExcHandlersNum")) {
                count = bbs.counters[i];
            } else if (name == "MaxBBExec") {
                count = 0;
                for(StlMap<int, BBStats>::iterator iter = stats->bbStats.begin(); iter != stats->bbStats.end(); iter++) {
                    if(iter->second.counters[i]*(*(iter->second.bbExecCount)) > count) {
                        count = iter->second.counters[i] * (*(iter->second.bbExecCount)) ;
                    }
                }
            } else if (name == "HottestBBNum") {
                int64 c = 0;
                count = 0;
                for(StlMap<int, BBStats>::iterator iter = stats->bbStats.begin(); iter != stats->bbStats.end(); iter++) {
                    if(iter->first != -1) {
                        int64 j = iter->second.counters[i]*(*(iter->second.bbExecCount)) ;
                        if(j > c) {
                            c = iter->second.counters[i] * (*(iter->second.bbExecCount)) ;
                            count = iter->first;
                        }
                    }
                }
            } else if (name == "MethodExec") {
                count = *(stats->bbStats[0].bbExecCount);
            } else {
                count = 0;
                for(StlMap<int, BBStats>::iterator iter = stats->bbStats.begin(); iter != stats->bbStats.end(); iter++) {
                    if(iter->first != -1)
                        count += iter->second.counters[i] * (*(iter->second.bbExecCount)) ;
                }
            }
            outFile << count << "\t";
        }
        outFile << std::endl;
        if(config->printBBStats) {
            for(StlMap<int, BBStats>::iterator iter = stats->bbStats.begin(); iter != stats->bbStats.end(); iter++) {
                if(iter->first == -1)
                    continue;
                outFile << "BB_" << iter->first << "_" << stats->methodName.c_str() << "\t";
                for(U_32 i = 0; i < config->counters.size(); i++) {
                    int64 outValue = iter->second.counters[i] * (*(iter->second.bbExecCount));
                    outFile <<  outValue << "\t";
                }
                outFile << std::endl;
            }
        }
    }
}

void InternalProfiler::runImpl() {
    addCounters(irManager->getMethodDesc());
}

void InternalProfiler::addCounters(MethodDesc& methodDesc) {
    MemoryManager& mm = Jitrino::getGlobalMM();
    MethodStats* ms = new(mm) MethodStats(std::string(methodDesc.getParentType()->getName())+"::"+methodDesc.getName()+methodDesc.getSignatureString(), mm);

    InternalProfilerAct& storage = *static_cast<InternalProfilerAct*>(getAction());
    storage.statistics->push_back(ms);
    //method external properties, no need to count
    U_32 cSize = (U_32)storage.config->counters.size();
    if (!cSize)
        return;
    ms->bbStats[-1].counters= new(mm) U_32[cSize];
    for(U_32 i = 0; i < cSize ; i++) {
        ms->bbStats[-1].counters[i] = 0;
    }
    ms->bbStats[-1].bbExecCount= new(mm) int64[1];
    *(ms->bbStats[-1].bbExecCount)  = 0;
    for(U_32 i  = 0; i < cSize ; i++) {
        Counter c  = storage.config->counters[i];
        if(c.name == std::string("ByteCodeSize")) {
            ms->bbStats[-1].bbExecCount= new(mm) int64[1];
            *(ms->bbStats[-1].bbExecCount)  = 0;
            
            ms->bbStats[-1].counters[i] = methodDesc.getByteCodeSize();
        } else if (c.name == std::string("ExcHandlersNum")) {
            int n = methodDesc.getNumHandlers();
            ms->bbStats[-1].counters[i] = n;
        }
    }
    //cycle by all insts
    IRManager & irm=getIRManager();
    const Nodes& nodes = irm.getFlowGraph()->getNodes();
    for (Nodes::const_iterator it = nodes.begin(),end = nodes.end();it!=end; ++it) {
        Node* node = *it;
        if (node->isBlockNode()){
            ms->bbStats[node->getId()].counters= new(mm) U_32[cSize];
            for(U_32 i = 0; i < cSize ; i++) {
                ms->bbStats[node->getId()].counters[i] = 0;
            }
            for (Inst * inst=(Inst*)node->getFirstInst(); inst!=NULL; inst=inst->getNextInst()){
                if(!inst->hasKind(Inst::Kind_PseudoInst) || inst->hasKind(Inst::Kind_EntryPointPseudoInst)) {
                    for(U_32 i  = 0; i < cSize ; i++) {
                        Counter c  = storage.config->counters[i];
                        if(std::string(c.name) == "MaxBBExec" || std::string(c.name) == "HottestBBNum" || std::string(c.name) == "BBExec" ) {
                                ms->bbStats[node->getId()].counters[i] =1;
                        } else {
                            bool matched = passFilter(inst, c.filter);
                            if (matched) {
                                ms->bbStats[node->getId()].counters[i]++;
                                ms->bbStats[-1].counters[i]++;
                            }
                        }
                    }
                }
            }
            ms->bbStats[node->getId()].bbExecCount= new(mm) int64[1];
            *(ms->bbStats[node->getId()].bbExecCount)   = 0;
            node->prependInst(irManager->newInst(Mnemonic_POPFD));
#ifndef _EM64T_
            node->prependInst(irManager->newInst(Mnemonic_ADC, irManager->newMemOpnd(irManager->getTypeFromTag(Type::Int32), MemOpndKind_Heap, NULL, int((U_8*)(ms->bbStats[node->getId()].bbExecCount) + 4)), irManager->newImmOpnd(irManager->getTypeFromTag(Type::Int32),0)));

            node->prependInst(irManager->newInst(Mnemonic_ADD, irManager->newMemOpnd(irManager->getTypeFromTag(Type::Int32), MemOpndKind_Heap, NULL, int(ms->bbStats[node->getId()].bbExecCount)), irManager->newImmOpnd(irManager->getTypeFromTag(Type::Int32),1)));
#endif
            node->prependInst(irManager->newInst(Mnemonic_PUSHFD));
        }
    }
#ifndef _EM64T_
    ((BasicBlock *)irManager->getFlowGraph()->getEntryNode())->prependInst(irManager->newInst(Mnemonic_ADD, irManager->newMemOpnd(irManager->getTypeFromTag(Type::Int32), MemOpndKind_Heap, NULL, int(ms->bbStats[-1].bbExecCount)), irManager->newImmOpnd(irManager->getTypeFromTag(Type::Int32),1)));
#endif

}
bool InternalProfiler::passOpndFilter(Inst * inst, Opnd * opnd, Filter& filter, OpndFilter& opndFltr) {
    bool res = false;
    if(opndFltr.opndKind.isInitialized) {
        res = opnd->isPlacedIn(opndFltr.opndKind.value);
        if(opndFltr.opndKind.isNegative)
            res = !res;

        if(filter.isOR && res)
            return true;
        if(!(filter.isOR || res))
            return false;
    }
    if(opndFltr.opndRole.isInitialized) {
        res = inst->getOpndRoles(opndFltr.opNum) & opndFltr.opndRole.value;
        if(opndFltr.opndRole.isNegative)
            res = !res;

        if(filter.isOR && res)
            return true;
        if(!(filter.isOR || res))
            return false;
    }
    if(opndFltr.regName.isInitialized) {
        res = opndFltr.regName.value == opnd->getRegName();
        if(opndFltr.regName.isNegative)
            res = !res;

        if(filter.isOR && res)
            return true;
        if(!(filter.isOR || res))
            return false;
    }
    if(opndFltr.memOpndKind.isInitialized) {
        res = opndFltr.memOpndKind.value == opnd->getMemOpndKind();
        if(opndFltr.memOpndKind.isNegative)
            res = !res;

        if(filter.isOR && res)
            return true;
        if(!(filter.isOR || res))
            return false;
    }
    return filter.isOR ? false : true;
}

bool InternalProfiler::passFilter(Inst * inst, Filter& filter) {
    if(!filter.isInitialized)
        return false;
    bool res = false;
    if(filter.mnemonic.isInitialized) {
        res = (filter.mnemonic.value == inst->getMnemonic()) || (filter.mnemonic.value == Mnemonic_Null);
        if(filter.mnemonic.isNegative)
            res = !res;

        if(filter.isOR && res)
            return true;
        if(!(filter.isOR || res))
            return false;
    }
    if(filter.operandNumber.isInitialized) {
        res = filter.operandNumber.value == (int)inst->getOpndCount();
        if(filter.operandNumber.isNegative)
            res = !res;

        if(filter.isOR && res)
            return true;
        if(!(filter.isOR || res))
            return false;
    }

    if(filter.operandFilters.size()) {
        for(StlMap<int, OpndFilter>::const_iterator it = filter.operandFilters.begin(); it !=filter.operandFilters.end(); it++) {
            OpndFilter opndFltr = it->second;
            if(!opndFltr.isInitialized)
                continue;
            if(opndFltr.opNum == -1) {
                for(U_32 i = 0; i < inst->getOpndCount(Inst::OpndRole_All) ; i++) {
                    Opnd * opnd = inst->getOpnd(i);
                    res = passOpndFilter(inst, opnd, filter, opndFltr);

                    if(filter.isOR && res)
                        return true;
                    if(!(filter.isOR || res))
                        return false;
                }
            } else if (opndFltr.opNum >= 0) {
                Opnd * opnd = opndFltr.opNum<(int)inst->getOpndCount(Inst::OpndRole_All) ? inst->getOpnd(opndFltr.opNum) : NULL;
                if(!opnd)
                    return false;
                res = passOpndFilter(inst, opnd, filter, opndFltr);

                if(filter.isOR && res)
                    return true;
                if(!(filter.isOR || res))
                    return false;
            } else {
                return false;
            }
        }
    }
    Opnd::RuntimeInfo * rt = NULL;
    if (inst->getMnemonic() == Mnemonic_CALL) {
        rt = inst->getOpnd(((ControlTransferInst*)inst)->getTargetOpndIndex())->getRuntimeInfo();
    }

    if(filter.rtKind.isInitialized) {
        if(!rt)
            return false;
        res = filter.rtKind.value == rt->getKind();
        if(filter.rtKind.isNegative)
            res = !res;

        if(filter.isOR && res)
            return true;
        if(!(filter.isOR || res))
            return false;
    }
    if(filter.rtHelperID.isInitialized) {
        if(!rt)
            return false;
        res = filter.rtHelperID.value == (VM_RT_SUPPORT)(POINTER_SIZE_INT)rt->getValue(0);
        if(filter.rtHelperID.isNegative)
            res = !res;

        if(filter.isOR && res)
            return true;
        if(!(filter.isOR || res))
            return false;
    }
    if(filter.rtIntHelperName.isInitialized) {
        if(!rt)
            return false;
        res = filter.rtIntHelperName.value == (char*)irManager->getInternalHelperInfo((const char*)rt->getValue(0))->pfn;
        if(filter.rtIntHelperName.isNegative)
            res = !res;

        if(filter.isOR && res)
            return true;
        if(!(filter.isOR || res))
            return false;
    }
    if(filter.isNative.isInitialized) {
        if(!rt || ((rt->getKind() != Opnd::RuntimeInfo::Kind_MethodDirectAddr) && (rt->getKind() != Opnd::RuntimeInfo::Kind_MethodDirectAddr)))
            return false;
        res = filter.isNative.value == ((MethodDesc *)rt->getValue(0))->isNative();
        if(filter.isNative.isNegative)
            res = !res;

        if(filter.isOR && res)
            return true;
        if(!(filter.isOR || res))
            return false;
    }
    if(filter.isStatic.isInitialized) {
        if(!rt || ((rt->getKind() != Opnd::RuntimeInfo::Kind_MethodDirectAddr) && (rt->getKind() != Opnd::RuntimeInfo::Kind_MethodDirectAddr)))
            return false;
        res = filter.isStatic.value == ((MethodDesc *)rt->getValue(0))->isStatic();
        if(filter.isStatic.isNegative)
            res = !res;

        if(filter.isOR && res)
            return true;
        if(!(filter.isOR || res))
            return false;
    }
    if(filter.isSynchronized.isInitialized) {
        if(!rt || ((rt->getKind() != Opnd::RuntimeInfo::Kind_MethodDirectAddr) && (rt->getKind() != Opnd::RuntimeInfo::Kind_MethodDirectAddr)))
            return false;
        res = filter.isSynchronized.value == ((MethodDesc *)rt->getValue(0))->isSynchronized();
        if(filter.isSynchronized.isNegative)
            res = !res;

        if(filter.isOR && res)
            return true;
        if(!(filter.isOR || res))
            return false;
    }
    if(filter.isNoInlining.isInitialized) {
        if(!rt || ((rt->getKind() != Opnd::RuntimeInfo::Kind_MethodDirectAddr) && (rt->getKind() != Opnd::RuntimeInfo::Kind_MethodDirectAddr)))
            return false;
        res = filter.isNoInlining.value == ((MethodDesc *)rt->getValue(0))->isNoInlining();
        if(filter.isNoInlining.isNegative)
            res = !res;

        if(filter.isOR && res)
            return true;
        if(!(filter.isOR || res))
            return false;
    }
    if(filter.isInstance.isInitialized) {
        if(!rt || ((rt->getKind() != Opnd::RuntimeInfo::Kind_MethodDirectAddr) && (rt->getKind() != Opnd::RuntimeInfo::Kind_MethodDirectAddr)))
            return false;
        res = filter.isInstance.value == ((MethodDesc *)rt->getValue(0))->isInstance();
        if(filter.isInstance.isNegative)
            res = !res;

        if(filter.isOR && res)
            return true;
        if(!(filter.isOR || res))
            return false;
    }
    if(filter.isFinal.isInitialized) {
        if(!rt || ((rt->getKind() != Opnd::RuntimeInfo::Kind_MethodDirectAddr) && (rt->getKind() != Opnd::RuntimeInfo::Kind_MethodDirectAddr)))
            return false;
        res = filter.isFinal.value == ((MethodDesc *)rt->getValue(0))->isFinal();
        if(filter.isFinal.isNegative)
            res = !res;

        if(filter.isOR && res)
            return true;
        if(!(filter.isOR || res))
            return false;
    }
    if(filter.isVirtual.isInitialized) {
        if(!rt || ((rt->getKind() != Opnd::RuntimeInfo::Kind_MethodDirectAddr) && (rt->getKind() != Opnd::RuntimeInfo::Kind_MethodDirectAddr)))
            return false;
        res = filter.isVirtual.value == ((MethodDesc *)rt->getValue(0))->isVirtual();
        if(filter.isVirtual.isNegative)
            res = !res;

        if(filter.isOR && res)
            return true;
        if(!(filter.isOR || res))
            return false;
    }
    if(filter.isAbstract.isInitialized) {
        if(!rt || ((rt->getKind() != Opnd::RuntimeInfo::Kind_MethodDirectAddr) && (rt->getKind() != Opnd::RuntimeInfo::Kind_MethodDirectAddr)))
            return false;
        res = filter.isAbstract.value == ((MethodDesc *)rt->getValue(0))->isAbstract();
        if(filter.isAbstract.isNegative)
            res = !res;

        if(filter.isOR && res)
            return true;
        if(!(filter.isOR || res))
            return false;
    }
    if(filter.isClassInitializer.isInitialized) {
        if(!rt || ((rt->getKind() != Opnd::RuntimeInfo::Kind_MethodDirectAddr) && (rt->getKind() != Opnd::RuntimeInfo::Kind_MethodDirectAddr)))
            return false;
        res = filter.isClassInitializer.value == ((MethodDesc *)rt->getValue(0))->isClassInitializer();
        if(filter.isClassInitializer.isNegative)
            res = !res;

        if(filter.isOR && res)
            return true;
        if(!(filter.isOR || res))
            return false;
    }
    if(filter.isInstanceInitializer.isInitialized) {
        if(!rt || ((rt->getKind() != Opnd::RuntimeInfo::Kind_MethodDirectAddr) && (rt->getKind() != Opnd::RuntimeInfo::Kind_MethodDirectAddr)))
            return false;
        res = filter.isInstanceInitializer.value == ((MethodDesc *)rt->getValue(0))->isInstanceInitializer();
        if(filter.isInstanceInitializer.isNegative)
            res = !res;

        if(filter.isOR && res)
            return true;
        if(!(filter.isOR || res))
            return false;
    }
    if(filter.isStrict.isInitialized) {
        if(!rt || ((rt->getKind() != Opnd::RuntimeInfo::Kind_MethodDirectAddr) && (rt->getKind() != Opnd::RuntimeInfo::Kind_MethodDirectAddr)))
            return false;
        res = filter.isStrict.value == ((MethodDesc *)rt->getValue(0))->isStrict();
        if(filter.isStrict.isNegative)
            res = !res;

        if(filter.isOR && res)
            return true;
        if(!(filter.isOR || res))
            return false;
    }
    if(filter.isInitLocals.isInitialized) {
        if(!rt || ((rt->getKind() != Opnd::RuntimeInfo::Kind_MethodDirectAddr) && (rt->getKind() != Opnd::RuntimeInfo::Kind_MethodDirectAddr)))
            return false;
        res = filter.isInitLocals.value == false;
        if(filter.isInitLocals.isNegative)
            res = !res;

        if(filter.isOR && res)
            return true;
        if(!(filter.isOR || res))
            return false;
    }

    return filter.isOR ? false : true;
}

}}; // namespace Ia32