/*
 *  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, Konstantin M. Anisimov, Igor V. Chebykin
 *
 */

#include "CodeGenIntfc.h"
#include "IpfEmitter.h"
#include "IpfOpndManager.h"
#include "IpfIrPrinter.h"
#include "IpfVerifier.h"
#include <iomanip>

namespace Jitrino {
namespace IPF {

//============================================================================//
const BundleDescription Bundle::BundleDesc[TEMPLATES_COUNT] = {
    { IT_SLOT0(IT_M) | IT_SLOT1(IT_I) | IT_SLOT2(IT_I), 0x0, 0x00 },
    { IT_SLOT0(IT_M) | IT_SLOT1(IT_I) | IT_SLOT2(IT_I), 0x4, 0x01 },
    { IT_SLOT0(IT_M) | IT_SLOT1(IT_I) | IT_SLOT2(IT_I), 0x2, 0x02 },
    { IT_SLOT0(IT_M) | IT_SLOT1(IT_I) | IT_SLOT2(IT_I), 0x6, 0x03 },
    { IT_SLOT0(IT_M) | IT_SLOT1(IT_L) | IT_SLOT2(IT_X), 0x0, 0x04 },
    { IT_SLOT0(IT_M) | IT_SLOT1(IT_L) | IT_SLOT2(IT_X), 0x4, 0x05 },
    { IT_SLOT0(IT_M) | IT_SLOT1(IT_M) | IT_SLOT2(IT_I), 0x0, 0x08 },
    { IT_SLOT0(IT_M) | IT_SLOT1(IT_M) | IT_SLOT2(IT_I), 0x4, 0x09 },
    { IT_SLOT0(IT_M) | IT_SLOT1(IT_M) | IT_SLOT2(IT_I), 0x1, 0x0a },
    { IT_SLOT0(IT_M) | IT_SLOT1(IT_M) | IT_SLOT2(IT_I), 0x5, 0x0b },
    { IT_SLOT0(IT_M) | IT_SLOT1(IT_F) | IT_SLOT2(IT_I), 0x0, 0x0c },
    { IT_SLOT0(IT_M) | IT_SLOT1(IT_F) | IT_SLOT2(IT_I), 0x4, 0x0d },
    { IT_SLOT0(IT_M) | IT_SLOT1(IT_M) | IT_SLOT2(IT_F), 0x0, 0x0e },
    { IT_SLOT0(IT_M) | IT_SLOT1(IT_M) | IT_SLOT2(IT_F), 0x4, 0x0f },
    { IT_SLOT0(IT_M) | IT_SLOT1(IT_I) | IT_SLOT2(IT_B), 0x0, 0x10 },
    { IT_SLOT0(IT_M) | IT_SLOT1(IT_I) | IT_SLOT2(IT_B), 0x4, 0x11 },
    { IT_SLOT0(IT_M) | IT_SLOT1(IT_B) | IT_SLOT2(IT_B), 0x0, 0x12 },
    { IT_SLOT0(IT_M) | IT_SLOT1(IT_B) | IT_SLOT2(IT_B), 0x4, 0x13 },
    { IT_SLOT0(IT_B) | IT_SLOT1(IT_B) | IT_SLOT2(IT_B), 0x0, 0x16 },
    { IT_SLOT0(IT_B) | IT_SLOT1(IT_B) | IT_SLOT2(IT_B), 0x4, 0x17 },
    { IT_SLOT0(IT_M) | IT_SLOT1(IT_M) | IT_SLOT2(IT_B), 0x0, 0x18 },
    { IT_SLOT0(IT_M) | IT_SLOT1(IT_M) | IT_SLOT2(IT_B), 0x4, 0x19 },
    { IT_SLOT0(IT_M) | IT_SLOT1(IT_F) | IT_SLOT2(IT_B), 0x0, 0x1c },
    { IT_SLOT0(IT_M) | IT_SLOT1(IT_F) | IT_SLOT2(IT_B), 0x4, 0x1d }
};

//============================================================================//

const char Emitter::Itanium2_DualIssueBundles[30][30] = {
    {1, 1, 1, 1, 0, 0, -1, -1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, 1, 1, 1, 1, -1, -1, 1, 1}, // MII, 0x00
    {1, 1, 1, 1, 0, 0, -1, -1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, 1, 1, 1, 1, -1, -1, 1, 1}, // MII, 0x01
    {1, 1, 1, 1, 0, 0, -1, -1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, 1, 1, 1, 1, -1, -1, 1, 1}, // MII, 0x02
    {1, 1, 1, 1, 0, 0, -1, -1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, 1, 1, 1, 1, -1, -1, 1, 1}, // MII, 0x03
    {1, 1, 1, 1, 1, 1, -1, -1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, 1, 1, 1, 1, -1, -1, 1, 1}, // MLX, 0x04
    {1, 1, 1, 1, 1, 1, -1, -1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, 1, 1, 1, 1, -1, -1, 1, 1}, // MLX, 0x05
    {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
    {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
    {1, 1, 1, 1, 1, 1, -1, -1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, 1, 1, 1, 1, -1, -1, 1, 1}, // MMI, 0x08
    {1, 1, 1, 1, 1, 1, -1, -1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, 1, 1, 1, 1, -1, -1, 1, 1}, // MMI, 0x09
    {1, 1, 1, 1, 1, 1, -1, -1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, 1, 1, 1, 1, -1, -1, 1, 1}, // MMI, 0x0a
    {1, 1, 1, 1, 1, 1, -1, -1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, 1, 1, 1, 1, -1, -1, 1, 1}, // MMI, 0x0b
    {1, 1, 1, 1, 1, 1, -1, -1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, 1, 1, 1, 1, -1, -1, 1, 1}, // MFI, 0x0c
    {1, 1, 1, 1, 1, 1, -1, -1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, 1, 1, 1, 1, -1, -1, 1, 1}, // MFI, 0x0d
    {1, 1, 1, 1, 1, 1, -1, -1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, 1, 1, 1, 1, -1, -1, 1, 1}, // MMF, 0x0e
    {1, 1, 1, 1, 1, 1, -1, -1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, 1, 1, 1, 1, -1, -1, 1, 1}, // MMF, 0x0f
    {1, 1, 1, 1, 1, 1, -1, -1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, 0, 0, 1, 1, -1, -1, 1, 1}, // MIB, 0x10
    {1, 1, 1, 1, 1, 1, -1, -1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, 0, 0, 1, 1, -1, -1, 1, 1}, // MIB, 0x11
    {0, 0, 0, 0, 0, 0, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1, -1, 0, 0, 0, 0, -1, -1, 0, 0}, // MBB, 0x12
    {0, 0, 0, 0, 0, 0, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1, -1, 0, 0, 0, 0, -1, -1, 0, 0}, // MBB, 0x13
    {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
    {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
    {0, 0, 0, 0, 0, 0, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1, -1, 0, 0, 0, 0, -1, -1, 0, 0}, // BBB, 0x16
    {0, 0, 0, 0, 0, 0, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1, -1, 0, 0, 0, 0, -1, -1, 0, 0}, // BBB, 0x17
    {1, 1, 1, 1, 1, 1, -1, -1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, 0, 0, 1, 1, -1, -1, 1, 1}, // MMB, 0x18
    {1, 1, 1, 1, 1, 1, -1, -1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, 0, 0, 1, 1, -1, -1, 1, 1}, // MMB, 0x19
    {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
    {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
    {1, 1, 1, 1, 1, 1, -1, -1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, 0, 0, 1, 1, -1, -1, 1, 1}, // MFB, 0x1c
    {1, 1, 1, 1, 1, 1, -1, -1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, 0, 0, 1, 1, -1, -1, 1, 1}  // MFB, 0x1d
};

//============================================================================//

void Emitter::checkForDualIssueBundles() {
    EmitterBb *bb;
    Bundle *bundle1, *bundle2;
    U_32 tmpl1, tmpl2;
    bool header_printed = false;

    for (int bbindex=0 ; bbindex<(int)bbs->size() ; bbindex++) {
        bb = bbs->at(bbindex);
        BundleVector & bundles = *(bb->bundles);
        for (int bi=0, bii=bundles.size()-1 ; bi<bii ; ) {
            bundle1 = bundles[bi];
            bundle2 = bundles[bi+1];
            tmpl1 = bundle1->getTmpl();
            tmpl2 = bundle2->getTmpl();
            if (!bundle1->hasStop() && Itanium2_DualIssueBundles[tmpl1][tmpl2]==0) {
                if (!header_printed) {
                    header_printed = true;
                    clog << "CHECK_DUAL_ISSUE: Method:"
                        << " bundles=" << codesize/IPF_BUNDLE_SIZE
                        << "; SIG="
                        << compilationinterface.getMethodToCompile()->getParentType()->getName()
                        << "." << compilationinterface.getMethodToCompile()->getName()
                        << compilationinterface.getMethodToCompile()->getSignatureString()
                        << "\n";
                }
                clog << "CHECK_DUAL_ISSUE: bbindex=" << bbindex
                    << ", node_id=" << bb->node->getId()
                    << "; bi=" << bi
                    << "; tmpl1=0x" << hex << tmpl1
                    << "; tmpl2=0x" << tmpl2 << dec
                    << "\n";

                bi += 1;
                continue;
            } else if (Itanium2_DualIssueBundles[tmpl1][tmpl2] == -1) {
                if (!header_printed) {
                    header_printed = true;
                    clog << "Method:"
                        << " bundles=" << codesize/IPF_BUNDLE_SIZE
                        << "; SIG="
                        << compilationinterface.getMethodToCompile()->getParentType()->getName()
                        << "." << compilationinterface.getMethodToCompile()->getName()
                        << compilationinterface.getMethodToCompile()->getSignatureString()
                        << "\n";
                }
                clog << "BAD templates: " << tmpl1 << ", " << tmpl2
                    << "\n";
            }

            if (bundle2->hasStop()) {
                bi += 1;
                continue;
            } else {
                bi += 2;
                continue;
            }
        }
    }

}

//============================================================================//

Bundle::Bundle(Cfg& cfg, U_32 itmp, Inst *i0, Inst *i1, Inst *i2) {
    indxtmpl = itmp;   // !!! THis is not template, but index in Bundle::BundleDesc[] !!!

    MemoryManager& mm          = cfg.getMM();
    OpndManager*   opndManager = cfg.getOpndManager();

    // slot 0
    if( i0==NULL ) {
        slot[0] = new(mm) Inst(mm, INST_NOP, PR(0), IMM(INST_BREAKPOINT_IMM_VALUE));
    } else {
        slot[0] = i0;
    }

    // slot 1
    if( i1==NULL ) {
        slot[1] = new(mm) Inst(mm, INST_NOP, PR(0), IMM(INST_BREAKPOINT_IMM_VALUE));
    } else {
        slot[1] = i1;
    }

    // slot 2
    if( i2==NULL ) {
        slot[2] = new(mm) Inst(mm, INST_NOP, PR(0), IMM(INST_BREAKPOINT_IMM_VALUE));
    } else {
        slot[2] = i2;
    }
}

//============================================================================//
void Bundle::emitBundleGeneral(void *whereToEmit) {
    uint64 * p  = (uint64 *)whereToEmit;
    uint64   s;

    p[0] = 0;
    p[1] = 0;

    p[0]  = getTmpl();

    s = getSlotBits(0);
    p[0] |= s << 5;

    s = getSlotBits(1);
    p[0] |= s << 46;
    p[1]  = s >> 18;

    s = getSlotBits(2);
    p[1] |= s << 23;
}

void Bundle::emitBundleBranch(void *whereToEmit, int * bundletarget) {
    uint64 * p  = (uint64 *)whereToEmit;
    uint64   s;
    U_32   itmp = getTmpl();

    p[0] = 0;
    p[1] = 0;

    p[0]  = itmp;

    if (itmp==0x16 || itmp==0x17) {
        s = getSlotBitsBranch(0, bundletarget[0]);
    } else {
        s = getSlotBits(0);
    }
    p[0] |= s << 5;

    if (itmp>=0x12 && itmp<=0x17) {
        s = getSlotBitsBranch(1, bundletarget[1]);
    } else {
        s = getSlotBits(1);
    }
    p[0] |= s << 46;
    p[1]  = s >> 18;

    if (itmp>=0x10) {
        s = getSlotBitsBranch(2, bundletarget[2]);
    } else {
        s = getSlotBits(2);
    }
    p[1] |= s << 23;
}

void Bundle::emitBundleExtended(void *whereToEmit) {
    uint64 * p  = (uint64 *)whereToEmit;
    uint64   s;
    uint64   s12[2];

    p[0] = 0;
    p[1] = 0;

    p[0]  = getTmpl();

    s = getSlotBits(0);
    p[0] |= s << 5;

    getSlotBitsExtended(s12, whereToEmit);
    p[0] |= s12[0] << 46;
    p[1]  = s12[0] >> 18;
    p[1] |= s12[1] << 23;
}

uint64 Bundle::getSlotBits(int slotindex) {
    return Encoder::getInstBits(Emitter::getExecUnitType(indxtmpl, slotindex)
            , slot[slotindex]);
}
uint64 Bundle::getSlotBitsBranch(int slotindex, int target) {
    return Encoder::getInstBitsBranch(Emitter::getExecUnitType(indxtmpl, slotindex)
            , slot[slotindex], target);
}
uint64 * Bundle::getSlotBitsExtended(uint64 *slots12, void *whereToEmit) {
    return Encoder::getInstBitsExtended(slot[1], slots12, whereToEmit);
}

//============================================================================//
void Bundle::print() {
    Inst * inst = getSlot(0);
    U_32 tmpl = getTmpl();

    IPF_LOG << "(" << tmpl << ")\n";
    IPF_LOG << IrPrinter::toString(inst);
    IPF_LOG << ( tmpl==0x0A || tmpl==0x0B ? " ;;" : "")
        << "\n";
    inst = getSlot(1);
    IPF_LOG << IrPrinter::toString(inst);
    IPF_LOG << ( tmpl==0x02 || tmpl==0x03 ? " ;;" : "")
        << "\n";
    inst = getSlot(2);
    IPF_LOG << IrPrinter::toString(inst);
    IPF_LOG << ( tmpl%2==1 ? " ;;" : "")
        << "\n";
}

//============================================================================//
#ifndef _GNU_SOURCE
#define _GNU_SOURCE
#endif
#ifndef _REENTRANT
#define _REENTRANT
#endif
#include <signal.h>
#include <errno.h>
#include <ucontext.h>

void sighandler(int sn, siginfo_t *si, void *_sc) {
    struct sigaction signal_action;
    struct ucontext * signal_ucontext;
    int saved_errno = errno;
    
    if (sn==SIGILL && si->si_code==ILL_BREAK && si->si_imm==INST_BREAKPOINT_IMM_VALUE) {
        signal_ucontext = (struct ucontext *)_sc;
    
        if ( (signal_ucontext->_u._mc.sc_ip & 0x03)==2 ) {
            signal_ucontext->_u._mc.sc_ip = (signal_ucontext->_u._mc.sc_ip & ~0x03) + 0x10;
        } else {
            signal_ucontext->_u._mc.sc_ip++;
        }
        //printf("-- sighandler() for signal %d, si_code %d, si_imm %x\n", sn, si->si_code, si->si_imm);
    
        signal_action.sa_flags = SA_SIGINFO;
        signal_action.sa_sigaction = sighandler;
        if (sigaction(SIGILL, &signal_action, NULL)) {
            printf("Sigaction returned error = %d\n", errno);
        }
    }
    
    errno = saved_errno;
    return;
}


//============================================================================//

EmitterBb::EmitterBb(Cfg & cfg, CompilationInterface & compilationinterface
        , BbNode  * node_, bool _break4cafe, bool _nop4cafe) :
    node(node_),
    insts(node->getInsts())
{
    MemoryManager& mm=cfg.getMM();
    OpndManager * opndManager = cfg.getOpndManager();
    Opnd * p0 = opndManager->getP0();

    isize=insts.size();
    stops=new(mm) vectorbool(isize);
    wregs=new(mm) vectorregs(isize);
    rregs=new(mm) vectorregs(isize);
    bundles=new(mm) BundleVector(cfg);
    consts=new(mm) vectorconst;
    bsize=0;

    if (!_break4cafe) {
        if (_nop4cafe) {
            bundles->addBundle(0x01
                , new(mm) Inst(mm, INST_NOP, p0, IMM(INST_BREAKPOINT_IMM_VALUE))
                , new(mm) Inst(mm, INST_NOP, p0, IMM(INST_BREAKPOINT_IMM_VALUE))
                , new(mm) Inst(mm, INST_NOP, p0, IMM(INST_BREAKPOINT_IMM_VALUE)));
        }
    } else {
        struct sigaction signal_action;
        
        signal_action.sa_flags = SA_SIGINFO;
        signal_action.sa_sigaction = sighandler;
        if (sigaction(SIGILL, &signal_action, NULL)) {
            printf("Sigaction returned error = %d\n", errno);
        }

        bundles->addBundle(0x01
            , new(mm) Inst(mm, INST_NOP, p0, IMM(INST_BREAKPOINT_IMM_VALUE))
            , new(mm) Inst(mm, INST_BREAK, p0, IMM(INST_BREAKPOINT_IMM_VALUE))
            , new(mm) Inst(mm, INST_NOP, p0, IMM(INST_BREAKPOINT_IMM_VALUE)));
    }

};

//============================================================================//
Emitter::Emitter(Cfg & cfg_, CompilationInterface & compilationinterface_, bool _break4cafe) :
        mm(cfg_.getMM()),
        cfg(cfg_),
        compilationinterface(compilationinterface_)
    {

    removeUselessInst(cfg, compilationinterface);
    removeIgnoreTypeInst(cfg, compilationinterface);

    (new(mm) IpfVerifier(cfg, compilationinterface))->verifyMethod();

    bbs = new(mm) vectorbb;
    BbNode  * node = (BbNode *)cfg.getEnterNode();
    EmitterBb * bbdesc;
    bool break4cafe = _break4cafe;
    bool nop4cafe = false;

    do {
        bbdesc = new(mm) EmitterBb(cfg, compilationinterface, node, break4cafe, nop4cafe);
        bbs->push_back(bbdesc);
        break4cafe = false;
        nop4cafe = false;
    } while( (node = node->getLayoutSucc()) != NULL );

};

//============================================================================//
int  Emitter::removeUselessInst(Cfg & cfg, CompilationInterface & compilationinterface) {
    BbNode  * node = (BbNode *)cfg.getEnterNode();
    int methoduseless = 0;
    int methodafter = 0;

    do {
        InstVector &insts = node->getInsts();
        int i;

        for( i=0 ; i < (int)insts.size() ; ) {
            Inst *inst = insts[i];
            InstCode icode = inst->getInstCode();
            OpndVector &opnds = inst->getOpnds();

            if (icode==INST_MOV) {
                if (inst->getNumOpnd()==3) {
                    if (((opnds[1]->isGReg() && opnds[2]->isGReg()) || (opnds[1]->isFReg() && opnds[2]->isFReg()))
                            && opnds[1]->getValue()==opnds[2]->getValue()) {
                        IPF_LOG << "USELESS: " << IrPrinter::toString(inst) << "\n";
                        insts.erase(insts.begin() + i);
                        methoduseless++;
                        continue;
                    }
                }
            }
            if (icode==INST_ADD || icode==INST_ADDS || icode==INST_ADDL) {
                if (inst->getNumOpnd()==4) {
                    if (opnds[2]->getValue()==0
                            && opnds[1]->getValue()==opnds[3]->getValue()) {
                        IPF_LOG << "USELESS: " << IrPrinter::toString(inst) << "\n";
                        insts.erase(insts.begin() + i);
                        methoduseless++;
                        continue;
                    }
                }
            }

            i++;
        }
        methodafter += i;
    } while( (node = node->getLayoutSucc()) != NULL );

    /* statistical data */
    if (0 && (methoduseless > 0)) {
        static int alluseless = 0;
        static int allafter = 0;
        alluseless += methoduseless;
        allafter += methodafter;
        if (methoduseless > 0) {
            IPF_LOG << "USELESS: method: " << methoduseless
                << "(" << (((float)methoduseless)/(methoduseless + methodafter))*100 << "%) instructions\n";
            IPF_LOG << "USELESS: all: " << alluseless
                << "(" << (((float)alluseless)/(alluseless + allafter))*100 << "%) instructions\n";
        }
    }

    if (methoduseless > 0) {
        IPF_LOG << "USELESS: removed " << methoduseless
            << "(" << (((float)methoduseless)/(methoduseless + methodafter) * 100) << "%) instructions\n";
    }
    return methoduseless;
}

//============================================================================//
int  Emitter::removeIgnoreTypeInst(Cfg & cfg, CompilationInterface & compilationinterface) {
    BbNode  * node = (BbNode *)cfg.getEnterNode();
    int ignoredcc = 0, i = 0;
    do {
        InstVector &insts = node->getInsts();

        for( i=0 ; i < (int)insts.size() ; ) {
            Inst *inst = insts[i];

            if (Encoder::isIgnoreInst(inst)) {
                IPF_LOG << "IGNORED: " << IrPrinter::toString(inst) << "\n";
                insts.erase(insts.begin() + i);
                continue;
            }
            i++;
        }
    } while( (node = node->getLayoutSucc()) != NULL );

    if (ignoredcc>0 && i>0) {
        IPF_LOG << "IGNORED: removed " << ignoredcc
            << "(" << (((float)ignoredcc)/(ignoredcc + i) * 100) << "%) instructions\n";
    }
    return ignoredcc;
}

//============================================================================//
InstructionType Emitter::getExecUnitType(int templateindex, int slotindex) {
    return (InstructionType)((Bundle::BundleDesc[templateindex].slots >> (slotindex * 8)) & 0xFF);
}

//============================================================================//
void Emitter::getTmpl(int bbindex, BundleDescription & tmp, Inst *i0, Inst *i1, Inst *i2, bool s0, bool s1, bool s2) {
    if(i0!=NULL) {
        tmp.slots = IT_SLOT0(Encoder::getInstType(i0));
    } else {
        tmp.slots = IT_SLOT0(IT_ANY);
    }
    tmp.stops = (s0 ? 1 : 0);

    if(i1!=NULL) {
        tmp.slots |= IT_SLOT1(Encoder::getInstType(i1));
    } else {
        tmp.slots |= IT_SLOT1(IT_ANY);
    }
    tmp.stops |= (s1 ? 2 : 0);

    if( i2!=NULL ) {
        tmp.slots |= IT_SLOT2(Encoder::getInstType(i2));
    } else {
        tmp.slots |= IT_SLOT2(IT_ANY);
    }
    tmp.stops |= (s2 ? 4 : 0);
}

int Emitter::findTmpl(const BundleDescription & tmp) {
    for( int j=0 ; j<TEMPLATES_COUNT ; j++ ) {
        if( (Bundle::BundleDesc[j].slots & tmp.slots)==Bundle::BundleDesc[j].slots
                && (Bundle::BundleDesc[j].stops == tmp.stops) ) {
            return j;
        }
    }
    return -1;
}

//============================================================================//
void Emitter::getWriteDpndBitset(Inst * inst, RegistersBitset * regs)
{
    OpndVector & opnds = inst->getOpnds();
    if(opnds.size() <= 1) return;

    U_32 dstcount=inst->getNumDst();
    Opnd *opnd;

    for( U_32 i=0 ; i<dstcount ; i++ ) {
        opnd = opnds[i+1];
        switch (opnd->getOpndKind()) {
        case OPND_G_REG:
            regs->GR.set(opnd->getValue());
            break;
        case OPND_F_REG:
            regs->FR.set(opnd->getValue());
            break;
        case OPND_P_REG:
            regs->PR.set(opnd->getValue());
            break;
        case OPND_B_REG:
            regs->BR.set(opnd->getValue());
            break;
        default:
            break;
        }
    }
}

//============================================================================//
void Emitter::getReadDpndBitset(Inst * inst, RegistersBitset * regs)
{
    OpndVector & opnds = inst->getOpnds();
    if(opnds.size() <= 1) return;

    U_32 dstcount=inst->getNumDst();
    U_32 opndcount=inst->getNumOpnd();
    Opnd *opnd;

    for( U_32 i=1+dstcount ; i<opndcount ; i++ ) {
        opnd = opnds[i];
        switch (opnd->getOpndKind()) {
        case OPND_G_REG:
            regs->GR.set(opnd->getValue());
            break;
        case OPND_F_REG:
            regs->FR.set(opnd->getValue());
            break;
        case OPND_P_REG:
            regs->PR.set(opnd->getValue());
            break;
        case OPND_B_REG:
            regs->BR.set(opnd->getValue());
            break;
        default:
            break;
        }
    }
    int p=opnds[0]->getValue();
    if( p ) {
        regs->PR.set(p);
    }
}

//============================================================================//
bool Emitter::tricking(InstVector & insts, MemoryManager& mm, Cfg& cfg) {
    RegistersBitset * regs;
    Inst *inst;

    for( int i=0 ; i < (int)insts.size() ; i++ ) {
        inst = insts[i];
        // regs masks
        regs = new(mm) RegistersBitset();
        getWriteDpndBitset(inst, regs);
        if (regs->GR.test(33)) {
            OpndManager * opndManager = cfg.getOpndManager();
            insts.insert(insts.begin() + i
                , new(mm) Inst(mm, INST_BREAK, opndManager->getP0(), opndManager->newImm(INST_BREAKPOINT_IMM_VALUE)));
            i++;
        }
    }
    return true;
}

//============================================================================//
bool Emitter::parsing() {
    bool ret = true;

    datasize = 0;
    for (int bbindex=0, bbssize=(int)bbs->size() ; bbindex<bbssize ; bbindex++) {
        ret &= parsing(bbindex);
    }

    return ret;
}

bool Emitter::parsing(int bbindex) {
    EmitterBb * bb = bbs->at(bbindex);
    InstVector & insts = bb->insts;
    vectorregs * wr = bb->wregs;
    vectorregs * rr = bb->rregs;
    Inst *inst;
    RegistersBitset * regs;
    U_32 dstcount;
    U_32 opndcount;
    Opnd         * opnd;
    vectorconst  * consts = bb->consts;
    Constant     * constant;

    for( int i=0 ; i < (int)insts.size() ; i++ ) {
        inst = insts[i];
        InstCode instCode = inst->getInstCode();
        OpndVector & opnds = inst->getOpnds();

        if (instCode==INST_BR13 || instCode==INST_BRL13) {
            instCode = (instCode == INST_BR13 ? INST_BR : INST_BRL);
        }

        // if inst is branch and target is DATA_NODE_REF
        // set istarget flag for target bb
        if (instCode==INST_BR || instCode==INST_BRL) {
            int is13 = (instCode==INST_BRL13 || instCode==INST_BR13 ? 1 : 0);  // must be 1 or 0
            opnd = opnds[is13 + 1];
            if (opnd->getDataKind() == DATA_NODE_REF)  {
                int targetind = getBbNodeIndex(((NodeRef*) opnd)->getNode());
                bbs->at(targetind)->istarget=true;
            }
        }

        // regs masks
        regs = new(mm) RegistersBitset();
        getWriteDpndBitset(inst, regs);
        wr->at(i) = regs;

        regs = new(mm) RegistersBitset();
        getReadDpndBitset(inst, regs);
        rr->at(i) = regs;

        // constants
        dstcount=inst->getNumDst();
        opndcount=inst->getNumOpnd();

        for( U_32 j=1 ; j<opndcount ; j++ ) {
            opnd = opnds[j];
            if (opnd->isImm()) {
                if ( opnd->getDataKind() == DATA_CONST_REF) {
                    constant = ((ConstantRef *)opnd)->getConstant();
                    consts->push_back(opnd);
                    datasize += constant->getSize();
                } else if ( opnd->getDataKind() == DATA_SWITCH_REF) {
                    constant = ((ConstantRef *)opnd)->getConstant();
                    consts->push_back(opnd);
                    datasize += ((SwitchConstant *)constant)->getSize();
                }
            }
        }
    }

    return true;
}
//============================================================================//
bool Emitter::stopping() {
    bool ret = true;

    for (int bbindex=0 ; bbindex<(int)bbs->size() ; bbindex++) {
        ret &= stopping(bbindex);
    }

    return ret;
}

bool Emitter::stopping(int bbindex) {
    EmitterBb * bb = bbs->at(bbindex);
    InstVector & insts = bb->insts;
    long sizebb = insts.size();
    if (sizebb==0) return true;

    vectorbool * stops = bb->stops;
    vectorregs * wr = bb->wregs;
    vectorregs * rr = bb->rregs;
    Inst *inst1, *inst2;
    InstCode icode1, icode2;
    RegistersBitset * regs1w, * regs2w, * regs2r;
    long start, stop, hardstop;

    for( start=0, stop=sizebb ; start < (sizebb - 1) ; ) {
        hardstop = -1;
        for (long i = start; i < (stop-1) ; i++) {
            inst1 = insts[i];
            icode1 = inst1->getInstCode();
            if (icode1==INST_BRL || icode1==INST_BRL13) {
                hardstop=i;
                break;
            } else if (icode1 == INST_ALLOC) {
                if (i>0) stops->at(i-1) = true;
            }
            if (Encoder::isIgnoreInst(inst1)) continue;
            if (icode1 >= INST_ST_FIRST && icode1 <= INST_ST_LAST) continue;

            regs1w = wr->at(i);
            if(!regs1w->any()) continue;

            for (long j = i + 1; j < stop; j++) {
                inst2 = insts[j];
                icode2 = inst2->getInstCode();
                if (icode2 == INST_ALLOC) {
                    if (j>0) stops->at(j-1) = true;
                }
                if (Encoder::isIgnoreInst(inst2)) continue;

                regs2w = wr->at(j);
                regs2r = rr->at(j);
                if(!regs2w->any() && !regs2r->any()) continue;

                if (Encoder::isBranchInst(inst2)) {
                    if( (Encoder::getInstType(icode1) & IT_F)
                            && (regs1w->PR & (regs2w->PR | regs2r->PR)).any() ) {
                        stop=j;
                        break;
                    }
                    continue;
                }

                if( (regs1w->GR & (regs2w->GR | regs2r->GR)).any()
                        || (regs1w->FR & (regs2w->FR | regs2r->FR)).any()
                        || (regs1w->PR & (regs2w->PR | regs2r->PR)).any()
                        || (regs1w->BR & (regs2w->BR | regs2r->BR)).any() ) {
                    stop=j;
                    break;
                }
            }
        }
        if (hardstop>=0) {
            stops->at(hardstop) = true;
            start=hardstop+1;
            stop=sizebb;
        } else if( stop==sizebb ) {
            start++;
        } else {
            stops->at(stop-1) = true;
            start=stop;
            stop=sizebb;
        }
    }
    stops->at(stops->size()-1) = true;

    return true;
}

//============================================================================//
bool Emitter::bundling() {
    EmitterBb * bb;
    char * off=0;
    bool ret = true;

    for (int bbindex=0 ; bbindex<(int)bbs->size() ; bbindex++) {
        ret &= bundling(bbindex);
        bb = bbs->at(bbindex);
        bb->bsize = bb->bundles->size();
        bb->codeoff = off;
        bb->codesize = bb->bsize * IPF_BUNDLE_SIZE;
        // align bb if istarget==true
        if (false && bb->istarget) { // switch off aligning
            uint16 bytes4align = (bb->codesize % IPF_CODE_ALIGNMENT) == 0
                    ? 0
                    : IPF_CODE_ALIGNMENT - (bb->codesize % IPF_CODE_ALIGNMENT);
            if (bytes4align>0 && (bytes4align%IPF_BUNDLE_SIZE)==0) {
                bb->codesize += bytes4align;
                uint16 bundles4align = bytes4align/IPF_BUNDLE_SIZE;
                OpndManager * opndManager = cfg.getOpndManager();
                Opnd * p0 = opndManager->getP0();
                for (uint16 i=0 ; i<bundles4align ; i++) {
                    bb->bundles->addBundle(0x00
                        , new(mm) Inst(mm, INST_NOP, p0, IMM(INST_BREAKPOINT_IMM_VALUE))
                        , new(mm) Inst(mm, INST_NOP, p0, IMM(INST_BREAKPOINT_IMM_VALUE))
                        , new(mm) Inst(mm, INST_NOP, p0, IMM(INST_BREAKPOINT_IMM_VALUE)));
                }

            }
        }
        off = (char *)off + bb->codesize;
    }
    codesize = (long)((char *)off);

    return ret;
}
bool Emitter::bundling(int bbindex) {
    EmitterBb * bb = bbs->at(bbindex);
    InstVector & insts = bb->insts;
    long   sizebb = insts.size();
    if (sizebb==0) return true;

    vectorbool * stops = bb->stops;
    BundleVector * bundles = bb->bundles;
    BundleDescription tmp = {0,0,0};
    int   iTmpl=-1;
    Inst *inst0=NULL, *inst1=NULL, *inst2=NULL, *inst3=NULL;
    bool  stop0=false, stop1=false, stop2=false, stop3=false;
    bool  stop0_f=false, stop1_f=false, stop2_f=false, stop3_f=false; // inst is first in group
    bool  stop0_l=false, stop1_l=false, stop2_l=false; // inst is last in group
    int   it0=0, it1=0, it2=0, it3=0; // insts type
    long  i0, i1, i2, i3;

    for ( i0=0 ; i0 < sizebb ; ) {
        inst0=Encoder::resolvePseudo(cfg, insts[i0]);
        if (Encoder::isIgnoreInst(inst0)) { i0++; continue; }
        stop0=stops->at(i0);

        for ( i1=i0+1 ; i1<sizebb ; ) {
            inst1=Encoder::resolvePseudo(cfg, insts[i1]);
            if (Encoder::isIgnoreInst(inst1)) { i1++; continue; }
            stop1=stops->at(i1);
            break;
        }
        if ( i1 >= sizebb ) { inst1=NULL; }

        for ( i2=i1+1 ; i2<sizebb ; ) {
            inst2=Encoder::resolvePseudo(cfg, insts[i2]);
            if (Encoder::isIgnoreInst(inst2)) { i2++; continue; }
            stop2=stops->at(i2);
            break;
        }
        if ( i2 >= sizebb ) { inst2=NULL; }

        for ( i3=i2+1 ; i3<sizebb ; ) {
            inst3=Encoder::resolvePseudo(cfg, insts[i3]);
            if (Encoder::isIgnoreInst(inst3)) { i3++; continue; }
            stop3=stops->at(i3);
            break;
        }
        if ( i3 >= sizebb ) { inst3=NULL; }

        it0 = Encoder::getInstType(inst0);
        it1 = Encoder::getInstType(inst1);
        it2 = Encoder::getInstType(inst2);
        it3 = Encoder::getInstType(inst3);

        stop0_l = (it0 & IT_GL)==IT_GL;
        stop1_l = (it1 & IT_GL)==IT_GL;
        stop2_l = (it2 & IT_GL)==IT_GL;
        stop0_f = (it0 & IT_GF)==IT_GF;
        stop1_f = (it1 & IT_GF)==IT_GF;
        stop2_f = (it2 & IT_GF)==IT_GF;
        stop3_f = (it3 & IT_GF)==IT_GF;

        /*********************************************
         * Special case for br.call
         * br.ret will return to next bundle, so
         * all instructions after br.call must be nop
         *********************************************/
        if (inst0->getInstCode()==INST_BR || inst0->getInstCode()==INST_BR13) {
            CompVector & cmpls0 = inst0->getComps();
            if (cmpls0.size()>0 && cmpls0[0]==CMPLT_BTYPE_CALL) {
                inst1=NULL;
                inst2=NULL;
            }
        } else if (inst1!=NULL && (inst1->getInstCode()==INST_BR || inst1->getInstCode()==INST_BR13)) {
            CompVector & cmpls1 = inst1->getComps();
            if (cmpls1.size()>0 && cmpls1[0]==CMPLT_BTYPE_CALL) {
                inst2=NULL;
            }
        }

        /*********************************************
         * Special case for inst0==LX type (brl,...)
         *********************************************/
        if ( Encoder::getInstType(inst0->getInstCode()) & IT_L ) {
            inst1=NULL;
            inst2=NULL;
            getTmpl(bbindex, tmp, NULL, inst0, NULL
                , false, false, stop0 || stop0_l || stop1_f);
            iTmpl=findTmpl(tmp);
            if( iTmpl>=0 ) {
                bundles->addBundle(iTmpl, NULL, inst0, NULL);
                i0 += 1;
                continue;
            }
            IPF_ERR << "BUNDLING ERROR: CAN'T FIND TEMPLATE !\n";
            IPF_ERR << "BUNDLING ERROR: " << IrPrinter::toString(inst0) << "\n";
            IPF_ASSERT(0);
        }

        /********************************
         * Special case for inst1==LX type (brl,...)
         ********************************/
        if (inst1!=NULL && (Encoder::getInstType(inst1->getInstCode()) & IT_L)) {
            inst2=NULL;
            getTmpl(bbindex, tmp, inst0, inst1, NULL
                , stop0 || stop0_l || stop1_f, false, stop1 || stop1_l || stop2_f);
            iTmpl=findTmpl(tmp);
            if( iTmpl>=0 ) {
                bundles->addBundle(iTmpl, inst0, inst1, NULL);
                i0 = i1 + 1;
                continue;
            }
            inst1=NULL;
        }

        /********************************
         * inst1!=NULL && inst2!=NULL
         ********************************/
        if (inst1!=NULL && inst2!=NULL) {
            getTmpl(bbindex, tmp, inst0, inst1, inst2
                , stop0 || stop0_l || stop1_f, stop1 || stop1_l || stop2_f, stop2 || stop2_l || stop3_f);
            iTmpl=findTmpl(tmp);
            if( iTmpl>=0 ) {
                bundles->addBundle(iTmpl, inst0, inst1, inst2);
                i0 = i2 + 1;
                continue;
            }
        }

        /********************************
         * inst2==NULL && inst1!=LX type (brl,...)
         ********************************/
        if (inst1!=NULL) {
            getTmpl(bbindex, tmp, inst0, inst1, NULL
                , stop0 || stop0_l || stop1_f, stop1 || stop1_l || stop2_f, false);
            iTmpl=findTmpl(tmp);
            if( iTmpl>=0 ) {
                bundles->addBundle(iTmpl, inst0, inst1, NULL);
                i0 = i1 + 1;
                continue;
            }
            getTmpl(bbindex, tmp, inst0, inst1, NULL
                , stop0 || stop0_l || stop1_f, false, stop1 || stop1_l || stop2_f);
            iTmpl=findTmpl(tmp);
            if( iTmpl>=0 ) {
                bundles->addBundle(iTmpl, inst0, inst1, NULL);
                i0 = i1 + 1;
                continue;
            }

            getTmpl(bbindex, tmp, inst0, NULL, inst1
                , stop0 || stop0_l || stop1_f, false, stop1 || stop1_l || stop2_f);
            iTmpl=findTmpl(tmp);
            if( iTmpl>=0 ) {
                bundles->addBundle(iTmpl, inst0, NULL, inst1);
                i0 = i1 + 1;
                continue;
            }
            getTmpl(bbindex, tmp, inst0, NULL, inst1
                , false, stop0 || stop0_l || stop1_f, stop1 || stop1_l || stop2_f);
            iTmpl=findTmpl(tmp);
            if( iTmpl>=0 ) {
                bundles->addBundle(iTmpl, inst0, NULL, inst1);
                i0 = i1 + 1;
                continue;
            }

            getTmpl(bbindex, tmp, NULL, inst0, inst1
                , false, stop0 || stop0_l || stop1_f, stop1 || stop1_l || stop2_f);
            iTmpl=findTmpl(tmp);
            if( iTmpl>=0 ) {
                bundles->addBundle(iTmpl, NULL,inst0, inst1);
                i0 = i1 + 1;
                continue;
            }
        }

        /********************************
         * inst1==NULL
         ********************************/
        getTmpl(bbindex, tmp, inst0, NULL, NULL
            , stop0 || stop0_l || stop1_f, false, false);
        iTmpl=findTmpl(tmp);
        if( iTmpl>=0 ) {
            bundles->addBundle(iTmpl, inst0, NULL, NULL);
            i0 += 1;
            continue;
        }
        getTmpl(bbindex, tmp, inst0, NULL, NULL
            , false, stop0 || stop0_l || stop1_f, false);
        iTmpl=findTmpl(tmp);
        if( iTmpl>=0 ) {
            bundles->addBundle(iTmpl, inst0, NULL, NULL);
            i0 += 1;
            continue;
        }
        getTmpl(bbindex, tmp, inst0, NULL, NULL
            , false, false, stop0 || stop0_l || stop1_f);
        iTmpl=findTmpl(tmp);
        if( iTmpl>=0 ) {
            bundles->addBundle(iTmpl, inst0, NULL, NULL);
            i0 += 1;
            continue;
        }

        getTmpl(bbindex, tmp, NULL, inst0, NULL
            , false, stop0 || stop0_l || stop1_f, false);
        iTmpl=findTmpl(tmp);
        if( iTmpl>=0 ) {
            bundles->addBundle(iTmpl, NULL, inst0, NULL);
            i0 += 1;
            continue;
        }
        getTmpl(bbindex, tmp, NULL, inst0, NULL
            , false, false, stop0 || stop0_l || stop1_f);
        iTmpl=findTmpl(tmp);
        if( iTmpl>=0 ) {
            bundles->addBundle(iTmpl, NULL, inst0, NULL);
            i0 += 1;
            continue;
        }

        getTmpl(bbindex, tmp, NULL, NULL, inst0
            , false, false, stop0 || stop0_l || stop1_f);
        iTmpl=findTmpl(tmp);
        if( iTmpl>=0 ) {
            bundles->addBundle(iTmpl, NULL, NULL, inst0);
            i0 += 1;
            continue;
        }

        IPF_ERR << "ERROR: CAN'T FIND TEMPLATE !!!\n";
        IPF_ASSERT(0);

        i0++;
    }

    return true;
}

//============================================================================//
bool Emitter::emitData() {
    if (datasize==0) return true;

    bool          ret = true;
    EmitterBb   * bb;
    char        * p;
    Opnd        * opnd;

    dataoff = (char *)compilationinterface.allocateDataBlock(datasize
        , L2_CACHE_LINE_SIZE);
    assert(dataoff != NULL);
    if ( dataoff == NULL ) return false;

    p = dataoff;

    for (int bbindex=0 ; bbindex<(int)bbs->size() ; bbindex++) {
        bb = bbs->at(bbindex);
        for ( int i=0, ii=bb->consts->size() ; i < ii ; i++ ) {
            opnd = bb->consts->at(i);
            if (opnd->isImm()) {
                if ( opnd->getDataKind() == DATA_CONST_REF) {
                    Constant    * c;

                    c = ((ConstantRef *)opnd)->getConstant();
                    switch (c->getDataKind()) {
                    case DATA_I64:
                        *((int64 *)p) = ((Int64Constant *)c)->getValue();
                        c->setAddress(p);
                        p += sizeof(int64);
                        break;
                    case DATA_S:
                        *((float *)p) = ((FloatConstant *)c)->getValue();
                        c->setAddress(p);
                        p += sizeof(float);
                        break;
                    case DATA_D:
                        *((double *)p) = ((DoubleConstant *)c)->getValue();
                        c->setAddress(p);
                        p += sizeof(double);
                        break;
                    default:
                        IPF_ERR << "DATA UNKNOWN\n";
                        break;
                    }
                } else if ( opnd->getDataKind() == DATA_SWITCH_REF) {
                    SwitchConstant    * c;

                    c = (SwitchConstant *)((ConstantRef *)opnd)->getConstant();
                    *((uint64 *)p) = (uint64)opnd;  // need to fill with actual
                                                    // values of node's addresses
                                                    // after code emitting!
                    c->setAddress(p);
                    p += c->getSize();
                }
            } else {
                IPF_LOG << "DATA UNKNOWN\n";
                assert(0);
            }
        }
    }

    return ret;
}

//============================================================================//
bool Emitter::fixSwitchTables() {
    if ( datasize==0 ) return true;
    if ( dataoff == NULL ) return true;

    bool          ret = true;
    EmitterBb   * bb;
    void        * p;
    Opnd        * opnd;
    SwitchConstant    * c;
    Node * node;
    Edge * edge;

    for (int bbindex=0 ; bbindex<(int)bbs->size() ; bbindex++) {
        bb = bbs->at(bbindex);
        for ( int i=0, ii=bb->consts->size() ; i < ii ; i++ ) {
            opnd = bb->consts->at(i);
            if (opnd->isImm() && opnd->getDataKind()==DATA_SWITCH_REF) {
                c = (SwitchConstant *)((ConstantRef *)opnd)->getConstant();
                p = c->getAddress();
                for (int j=0, jj=c->getChoiceCount() ; j<jj ; j++) {
                    edge = c->getEdge(j);
                    node = edge->getTarget();
                    *((uint64 *)p) = (uint64)(codeoff + (int64)getBbNodeOff((BbNode *)node));
                    p = (uint64 *)p +1;
                }
            }
        }
    }

    return ret;
}

//============================================================================//
bool Emitter::emitCode() {
    EmitterBb *bb;
    BundleVector * bundles;
    Bundle * bundle;
    int    target[3];
    char *bboff = 0;
    char *off = 0;
    Inst *inst;

    codeoff = (char *)compilationinterface.allocateCodeBlock(
            codesize, IPF_CODE_ALIGNMENT, CodeBlockHeatDefault, 0, false);
    assert(codeoff != NULL);
    IPF_LOG << endl;
    if ( codeoff ) {
        off=codeoff;
        for (int bbindex=0 ; bbindex<(int)bbs->size() ; bbindex++) {
            bb = bbs->at(bbindex);
            // sa
            bb->node->setAddress((uint64)off);
            bboff = off;
            bundles = bb->bundles;
            for(int i=0, ii=(int)bundles->size() ; i<ii ; i++ ) {
                bundle = bundles->at(i);
                for (U_32 si=0 ; si < IPF_SLOTS_COUNT ; si++) {
                    inst = bundle->getSlot(si);
                    inst->setAddr((U_32)(off - bboff) + si);
                }

                if ( isBranchBundle(bundle, codeoff, off, target) ) {
                    // bundle contains B type inst
                    bundle->emitBundleBranch(off, target);
                } else if ( isExtendedBundle(bundle) ) {
                    // bundle contains L+X type inst
                    bundle->emitBundleExtended(off);

                    inst = bundle->getSlot(1);
                    InstCode     icode  = inst->getInstCode();
                    unsigned int is13 = (icode==INST_BRL13 ? 1 : 0);  // must be 1 or 0
                    if ((icode==INST_BRL  || icode==INST_BRL13)
                            && (inst->getComps())[0]==CMPLT_BTYPE_CALL
                            && (inst->getOpnds()[is13 + 2])->getDataKind()==DATA_METHOD_REF) {
                        if (((((uint64)off) | (((uint64)0x4cafe) << 32)) & ~((uint64)0x4cafe << 32))==(uint64)off) {
                            registerDirectCall(inst, ((uint64)off) | (((uint64)0x4cafe) << 32));
                        } else {
                            IPF_ERR << "\n";
                            assert(0);
                        }
                    }
                } else {
                    bundle->emitBundleGeneral(off);
                }
                off = off + IPF_BUNDLE_SIZE;
            }
        }
        IPF_LOG << "END code emitting: "
            << compilationinterface.getMethodToCompile()->getParentType()->getName()
            << "." << compilationinterface.getMethodToCompile()->getName()
            << compilationinterface.getMethodToCompile()->getSignatureString()
            << endl;

        return true;
    }
    return false;
}

bool Emitter::isBranchBundle(Bundle * bundle, char * baseoff, char * bundleoff, int * branchtargets) {
    bool ret = false;

    if ( bundle->getTmpl() > 15 ) {
        Inst   * inst;
        Opnd   * opnd;
        InstCode     icode;
        unsigned int is13;  // must be 1 or 0

        for (int i=0 ; i<IPF_SLOTS_COUNT ; i++ ) {
            branchtargets[i] = 0;
            inst = bundle->getSlot(i);
            if(Encoder::isBranchInst(inst)) {
                icode  = inst->getInstCode();
                is13 = (icode==INST_BRL13 || icode==INST_BR13 ? 1 : 0);  // must be 1 or 0
                ret = true;
                opnd = inst->getOpnd(is13 + 1);
                if (opnd->getDataKind() == DATA_NODE_REF)  {
                    branchtargets[i] = (long)getBbNodeOff(((NodeRef*) opnd)->getNode()) - (long)(bundleoff - baseoff);
                }
            }
        }
    }
    return ret;
}

char * Emitter::getBbNodeOff(BbNode * node) {
    for (int i=0 ; i<(int)bbs->size() ; i++) {
        if (bbs->at(i)->node == node) {
            return bbs->at(i)->codeoff;
        }
    }
    return (char *)-1;
}

int Emitter::getBbNodeIndex(BbNode * node) {
    for (int i=0 ; i<(int)bbs->size() ; i++) {
        if (bbs->at(i)->node == node) {
            return i;
        }
    }
    return -1;
}

bool Emitter::emit() {
    bool ret = true;

    // 0 pass: parsing insts
    //     - clear ignored insts
    //     - define registers read/write  masks
    //     - create vector of constants
    //     - create vector of brunches
    ret &= parsing();
    if (!ret) { IPF_ERR << "Bad results for parsing\n"; return ret; }

    // 1 pass: emit data
    ret &= emitData();
    if (!ret) { IPF_ERR << "Bad results for emitData\n"; return ret; }

    // 2 pass: define stops
    ret &= stopping();
    if (!ret) { IPF_ERR << "Bad results for stopping\n"; return ret; }

    // 3 pass: bundling instructions (also saving indexes of bundles with branch insts)
    ret &= bundling();
    if (!ret) { IPF_ERR << "Bad results for bundling\n"; return ret; }

    // 4 pass: emits bundles
    ret &= emitCode();
    if (!ret) { IPF_ERR << "Bad results for emitCode\n"; return ret; }

    // 5 pass: fix switch tables
    ret &= fixSwitchTables();
    if (!ret) { IPF_ERR << "Bad results for fixSwitchTables\n"; return ret; }

    // checkForDualIssueBundles();

    if (LOG_ON) {
        printInsts(" Result of stopping() ");
        printBundles(" Result of bundling() ");
        printCodeBlock(" Result of emitting() ");
        printDisasm(" Result of emitting(disasm) ");
    }

    return ret;
}

void Emitter::printBundles(char * cap) {
    if (LOG_ON) {
        IPF_LOG << "-----------" << cap << "-----------------------------\n";
        for (int i=0 ; i<(int)bbs->size() ; i++) {
            printBundles(i);
        }
        IPF_LOG << "\n";
    }
}

void Emitter::printBundles(int bbindex) {
    BundleVector * bundles = bbs->at(bbindex)->bundles;
    Bundle * bndl;

    IPF_LOG << ".L" << bbs->at(bbindex)->node->getId()
        << " (0x" << hex << bbs->at(bbindex)->node->getAddress() << dec << ")\n";
    for (long i = 0, ii=bundles->size() ; i < ii ; i++) {
        bndl = bundles->at(i);
        if( bndl==NULL ) {
            IPF_LOG << i;
            IPF_LOG << "  \tNULL\n"
                      << "  \tNULL\n"
                      << "  \tNULL\n";
            IPF_LOG << "\n";
        } else {
            IPF_LOG << i;
            bndl->print();
            IPF_LOG << "\n";
        }
    }
}

void Emitter::printInsts(char *cap) {
    IPF_LOG << "\n-----------" << cap << "-----------------------------\n";
    for (int i=0 ; i<(int)bbs->size() ; i++) {
        printInsts(i);
    }
    IPF_LOG << "\n";
}

void Emitter::printInsts(int bbindex) {
    InstVector & insts = bbs->at(bbindex)->insts;
    vectorbool * stops = bbs->at(bbindex)->stops;
    Inst *inst;

    IPF_LOG << ".L" << bbs->at(bbindex)->node->getId() << "\n";
    for (U_32 i = 0, ii=insts.size() ; i < ii ; i++) {
        inst = insts[i];
        if( inst==NULL ) {
            IPF_LOG << IrPrinter::toString(inst);
        } else {
            IPF_LOG << IrPrinter::toString(inst);
            IPF_LOG << (stops->at(i) ? " ;;" : "");
        }
        IPF_LOG << "\n";
    }
}

void Emitter::printCodeBlock(char * cap) {
    char     printbuf[256];
    char   * off = codeoff;
    uint64 * p, tmpl, i0, i1, i2;

    IPF_LOG << "\n-----------" << cap << "-----------------------------\n";
    sprintf(printbuf, "%-11.11s       %-11.11s       %-11.11s       %-8.8s\n", "slot2", "slot1", "slot0", "template");
    IPF_LOG << printbuf;
    for(int i=0 ; i<codesize; i += IPF_BUNDLE_SIZE) {
        p = (uint64 *)off;

        tmpl = p[0] & 0x1F;
        i0 = (p[0] & 0x3FFFFFFFFFE0) >> 5;
        i1 = (((p[0] & ~0x1F) & ~0x3FFFFFFFFFE0) >> 46) | ((p[1] & 0x7FFFFF) << 18);
        i2 = (p[1] & ~0x7FFFFF) >> 23;

        sprintf(printbuf, "%11.11llx       %11.11llx       %11.11llx       %2.2x      \n", i2, i1, i0, (unsigned)tmpl);
        IPF_LOG << printbuf;
        off += IPF_BUNDLE_SIZE;
    }
    IPF_LOG << "---------------------------------------------------\n";
}

void Emitter::registerDirectCall(Inst * inst, uint64 data)
{
    InstCode     icode  = inst->getInstCode();
    unsigned int is13 = (icode==INST_BRL13 ? 1 : 0);  // must be 1 or 0

    assert((icode==INST_BRL || icode==INST_BRL13)
        && (inst->getComps())[0]==CMPLT_BTYPE_CALL);
    Opnd * target = (inst->getOpnds())[is13 + 2];
    assert(target->isImm() && target->getDataKind()==DATA_METHOD_REF);
    MethodDesc * method = ((MethodRef *)target)->getMethod();

    compilationinterface.setNotifyWhenMethodIsRecompiled(method, (void *)data);
    if (LOG_ON) {
        IPF_LOG << "Registered call to " << method->getParentType()->getName()
            << "." << method->getName()
            << " : data=0x" << hex << data << dec
            << " for recompiled method event" << endl;
    }
}

#include <dlfcn.h>
#include <libgen.h>

void Emitter::printDisasm(char * cap) {
    static bool load_done = false;
    static unsigned (*disasm)(const char *, char *, unsigned) = NULL;

    if (!load_done) {
        char buf[PATH_MAX+1];

        // Resolve full path to module
        string sz("");
        int len = 0;

        len = readlink("/proc/self/exe", buf, sizeof(buf)-1);
        if (len < 0) {
            buf[0]='.';
            buf[1]='/';
            buf[2]='\0';
        } else {
            buf[len] = 0;
        }
        char * slash = strrchr(buf, '/');
        if (slash) {
            *(slash) = '\0';
        }

        sz.append(buf);
        sz.append("/libdisasm.so");
        std::cout << "Loading `" << sz << "'...";

        char * path = strdup(sz.c_str());
        void * handle = dlopen(path, RTLD_NOW);
        free(path);
        disasm = (unsigned (*)(const char *, char *, unsigned))
            (handle == NULL ? NULL : dlsym(handle, "disasm"));
        load_done = true;

        if (disasm==NULL) {
            std::cout << "CAN'T LOAD" << std::endl;
            return;
        } else {
            std::cout << "OK" << std::endl;
        }
    }
    if (disasm==NULL) {
        return;
    }

    string str("");
    char buf[100];
    char * off = codeoff;

    for (unsigned i=0 ; i<codesize ; off=codeoff+i) {
        unsigned l = disasm((const char*)off, buf, sizeof(buf)-1);

        for (int bbindex=0 ; bbindex<(int)bbs->size() ; bbindex++) {
            EmitterBb *bb = bbs->at(bbindex);
            char * bboff = (char *)bb->node->getAddress();

            if (bboff==off) {
                char   bbid[64];

                sprintf(bbid, "%i (%p)", (int)bb->node->getId(), bboff);
                str.append("\n.L");
                str.append(bbid);
                break;
            }
        }
        if (buf[0]=='[') {
            str.append("\n");
            buf[5] = '\0';
            str.append(buf);
            str.append("\n      ");
            str.append(buf + 6);
            str.append("\n");
        } else {
            str.append(buf);
            str.append("\n");
        }
        i += l;
    }

    IPF_LOG << endl << "-----------" << cap << "-----------------------" << endl;
    IPF_LOG << str;
}

} // IPF
} // Jitrino