/*
 *  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
 *
 */

#ifndef _IPF_CODE_SELECTOR_H_
#define _IPF_CODE_SELECTOR_H_

#include "CodeGenIntfc.h"
#include "VMInterface.h"
#include "IpfCfg.h"
#include "IpfOpndManager.h"

namespace Jitrino {
namespace IPF {

#define NOT_IMPLEMENTED_C(name) { IPF_ERR << name << " INSTRUCTION NOT IMPLEMENTED" << endl; return NULL; }
#define NOT_IMPLEMENTED_V(name) { IPF_ERR << name << " INSTRUCTION NOT IMPLEMENTED" << endl; }

//========================================================================================//
// IpfMethodCodeSelector
//========================================================================================//

class IpfMethodCodeSelector : public MethodCodeSelector::Callback {
public:
                         IpfMethodCodeSelector(Cfg&, CompilationInterface&);
    MethodDesc           *getMethodDesc();

    void                 genVars(U_32, VarCodeSelector&);
    void                 setMethodDesc(MethodDesc*);
    void                 genCFG(U_32, CFGCodeSelector&, bool);
//    void                 setProfileInfo(CodeProfiler*) {}
    virtual              ~IpfMethodCodeSelector() {}

protected:
    MemoryManager        &mm;
    Cfg                  &cfg;
    CompilationInterface &compilationInterface;
    MethodDesc           *methodDesc;
    OpndVector           opnds;
    NodeVector           nodes;
};

//========================================================================================//
// IpfVarCodeSelector
//========================================================================================//

class IpfVarCodeSelector : public VarCodeSelector::Callback {
public:
                  IpfVarCodeSelector(Cfg&, OpndVector&);
    U_32        defVar(Type*, bool, bool);
    void          setManagedPointerBase(U_32, U_32);

protected:
    MemoryManager &mm;
    Cfg           &cfg;
    OpndVector    &opnds;
    OpndManager   *opndManager;
};

//========================================================================================//
// IpfCfgCodeSelector
//========================================================================================//

class IpfCfgCodeSelector : public CFGCodeSelector::Callback {
public:
                         IpfCfgCodeSelector(Cfg&, NodeVector&, OpndVector&, CompilationInterface&);
    U_32               genDispatchNode(U_32, U_32, const StlVector<MethodDesc*>&, double);
    U_32               genBlock(U_32, U_32, BlockKind, BlockCodeSelector&, double);
    U_32               genUnwindNode(U_32, U_32, double);
    U_32               genExitNode(U_32, double);
    void                 genUnconditionalEdge(U_32, U_32, double);
    void                 genTrueEdge(U_32, U_32, double);
    void                 genFalseEdge(U_32, U_32, double);
    void                 genSwitchEdges(U_32, U_32, U_32*, double*, U_32);
    void                 genExceptionEdge(U_32, U_32, double);
    void                 genCatchEdge(U_32, U_32, U_32, Type*, double);
    void                 genExitEdge(U_32, U_32, double);
    void                 setLoopInfo(U_32, bool, bool, U_32);
    void                 setPersistentId(U_32, U_32);
    virtual              ~IpfCfgCodeSelector() {}

protected:
    MemoryManager        &mm;
    Cfg                  &cfg;
    NodeVector           &nodes;
    OpndVector           &opnds;
    CompilationInterface &compilationInterface;
    OpndManager          *opndManager;
};

//========================================================================================//
// IpfInstCodeSelector
//========================================================================================//

class IpfInstCodeSelector : public InstructionCallback {

public:
    IpfInstCodeSelector(Cfg&, BbNode&, OpndVector&, CompilationInterface&);

    //---------------------------------------------------------------------------//
    // Arithmetic
    //---------------------------------------------------------------------------//

    CG_OpndHandle *add(ArithmeticOp::Types, CG_OpndHandle*, CG_OpndHandle*);
    CG_OpndHandle *sub(ArithmeticOp::Types, CG_OpndHandle*, CG_OpndHandle*);
    CG_OpndHandle *mul(ArithmeticOp::Types, CG_OpndHandle*, CG_OpndHandle*);

    CG_OpndHandle *addRef(RefArithmeticOp::Types, CG_OpndHandle*, CG_OpndHandle*);
    CG_OpndHandle *subRef(RefArithmeticOp::Types, CG_OpndHandle*, CG_OpndHandle*);
    CG_OpndHandle *diffRef(bool, CG_OpndHandle*, CG_OpndHandle*);

    CG_OpndHandle *tau_div(DivOp::Types, CG_OpndHandle*, CG_OpndHandle*, CG_OpndHandle*);
    CG_OpndHandle *tau_rem(DivOp::Types, CG_OpndHandle*, CG_OpndHandle*, CG_OpndHandle*);

    CG_OpndHandle *neg    (NegOp::Types, CG_OpndHandle*);
    CG_OpndHandle *min_op (NegOp::Types, CG_OpndHandle*, CG_OpndHandle*);
    CG_OpndHandle *max_op (NegOp::Types, CG_OpndHandle*, CG_OpndHandle*);
    CG_OpndHandle *abs_op (NegOp::Types, CG_OpndHandle*);

    CG_OpndHandle *and_  (IntegerOp::Types, CG_OpndHandle*, CG_OpndHandle*);
    CG_OpndHandle *or_   (IntegerOp::Types, CG_OpndHandle*, CG_OpndHandle*);
    CG_OpndHandle *xor_  (IntegerOp::Types, CG_OpndHandle*, CG_OpndHandle*);
    CG_OpndHandle *not_  (IntegerOp::Types, CG_OpndHandle*);
    CG_OpndHandle *shl   (IntegerOp::Types, CG_OpndHandle*, CG_OpndHandle*);
    CG_OpndHandle *shr   (IntegerOp::Types, CG_OpndHandle*, CG_OpndHandle*);
    CG_OpndHandle *shru  (IntegerOp::Types, CG_OpndHandle*, CG_OpndHandle*);
    CG_OpndHandle *shladd(IntegerOp::Types, CG_OpndHandle*, U_32, CG_OpndHandle*);

    CG_OpndHandle *convToInt(ConvertToIntOp::Types, bool, bool, ConvertToIntOp::OverflowMod, Type*, CG_OpndHandle*);
    CG_OpndHandle *convToFp(ConvertToFpOp::Types, Type*, CG_OpndHandle*);

    CG_OpndHandle *ldc_i4(I_32);
    CG_OpndHandle *ldc_i8(int64);
    CG_OpndHandle *ldc_s(float);
    CG_OpndHandle *ldc_d(double);
    CG_OpndHandle *ldnull(bool);
    CG_OpndHandle *ldVar(Type*, U_32);
    void          stVar(CG_OpndHandle*, U_32);
    CG_OpndHandle *defArg(U_32, Type*);

    CG_OpndHandle *cmp   (CompareOp::Operators, CompareOp::Types, CG_OpndHandle*, CG_OpndHandle*, int);
    CG_OpndHandle *czero (CompareZeroOp::Types, CG_OpndHandle*);
    CG_OpndHandle *cnzero(CompareZeroOp::Types, CG_OpndHandle*);

    CG_OpndHandle *copy(CG_OpndHandle*);
    CG_OpndHandle *tau_staticCast(ObjectType*, CG_OpndHandle*, CG_OpndHandle*);

    //---------------------------------------------------------------------------//
    // Branch & Call
    //---------------------------------------------------------------------------//

    void          branch(CompareOp::Operators, CompareOp::Types, CG_OpndHandle*, CG_OpndHandle*);
    void          bzero (CompareZeroOp::Types, CG_OpndHandle*);
    void          bnzero(CompareZeroOp::Types, CG_OpndHandle*);
    void          tableSwitch(CG_OpndHandle*, U_32);       

    CG_OpndHandle *call(U_32, CG_OpndHandle**, Type*, MethodDesc*);
    CG_OpndHandle *tau_call(U_32, CG_OpndHandle**, Type*, MethodDesc*, CG_OpndHandle*, CG_OpndHandle*);
    CG_OpndHandle *tau_calli(U_32,CG_OpndHandle**, Type*, CG_OpndHandle*, CG_OpndHandle*, CG_OpndHandle*);
    void          ret();
    void          ret(CG_OpndHandle*);

    //---------------------------------------------------------------------------//
    // Exceptions & checks
    //---------------------------------------------------------------------------//

    void          throwException(CG_OpndHandle*, bool);
    void          throwException(ObjectType* excType);// generater code to throw noted type exception
    void          throwSystemException(CompilationInterface::SystemExceptionId);
    void          throwLinkingException(Class_Handle, U_32, U_32);
    CG_OpndHandle *catchException(Type*);

    CG_OpndHandle *tau_checkNull(CG_OpndHandle *, bool);
    CG_OpndHandle *tau_checkBounds(CG_OpndHandle*, CG_OpndHandle*);
    CG_OpndHandle *tau_checkLowerBound(CG_OpndHandle*, CG_OpndHandle*);
    CG_OpndHandle *tau_checkUpperBound(CG_OpndHandle*, CG_OpndHandle*);
    CG_OpndHandle *tau_checkElemType(CG_OpndHandle*, CG_OpndHandle*, CG_OpndHandle*, CG_OpndHandle*);
    CG_OpndHandle *tau_checkZero(CG_OpndHandle*);
    CG_OpndHandle *tau_checkCast(ObjectType*, CG_OpndHandle*, CG_OpndHandle*);

    //---------------------------------------------------------------------------//
    // Memory operations
    //---------------------------------------------------------------------------//

    void          tau_stInd(CG_OpndHandle*, CG_OpndHandle*, Type::Tag, bool, CG_OpndHandle*, CG_OpndHandle*, CG_OpndHandle*);
    CG_OpndHandle *tau_ldInd(Type*, CG_OpndHandle*, Type::Tag, bool, bool, CG_OpndHandle*, CG_OpndHandle*);
    CG_OpndHandle *ldString(MethodDesc*, U_32, bool);
    CG_OpndHandle *ldLockAddr(CG_OpndHandle*);
    CG_OpndHandle *tau_ldVirtFunAddr(Type*, CG_OpndHandle*, MethodDesc*, CG_OpndHandle*);
    CG_OpndHandle *tau_ldVTableAddr(Type*, CG_OpndHandle*, CG_OpndHandle*);
    CG_OpndHandle *getVTableAddr(Type*, ObjectType*);
    CG_OpndHandle *getClassObj(Type*, ObjectType*);
    CG_OpndHandle *ldFieldAddr(Type*, CG_OpndHandle*, FieldDesc*);
    CG_OpndHandle *ldStaticAddr(Type*, FieldDesc*);

    CG_OpndHandle *tau_instanceOf(ObjectType*, CG_OpndHandle*, CG_OpndHandle*);
    void          initType(Type*);
    CG_OpndHandle *newObj(ObjectType*); 
    CG_OpndHandle *newArray(ArrayType*, CG_OpndHandle*);
    CG_OpndHandle *newMultiArray(ArrayType*, U_32, CG_OpndHandle**);
    CG_OpndHandle *ldElemBaseAddr(CG_OpndHandle*);
    CG_OpndHandle *addElemIndex(Type *, CG_OpndHandle *, CG_OpndHandle *);
    CG_OpndHandle *tau_arrayLen(Type*, ArrayType*, Type*, CG_OpndHandle*, CG_OpndHandle*, CG_OpndHandle*);

    //---------------------------------------------------------------------------//
    // Monitors
    //---------------------------------------------------------------------------//

    void          tau_monitorEnter(CG_OpndHandle*, CG_OpndHandle*);
    void          tau_monitorExit (CG_OpndHandle*, CG_OpndHandle*);
    void          typeMonitorEnter(NamedType*);
    void          typeMonitorExit (NamedType*);
    CG_OpndHandle *tau_balancedMonitorEnter(CG_OpndHandle*, CG_OpndHandle*, CG_OpndHandle*);
    void          balancedMonitorExit     (CG_OpndHandle*, CG_OpndHandle*, CG_OpndHandle*);

    //---------------------------------------------------------------------------//
    // Methods that are not used (but implemented)
    //---------------------------------------------------------------------------//

    CG_OpndHandle *tauPoint()                      { return opndManager->getTau(); }
    CG_OpndHandle *tauEdge()                       { return opndManager->getTau(); }
    CG_OpndHandle *tauUnsafe()                     { return opndManager->getTau(); }
    CG_OpndHandle *tauSafe()                       { return opndManager->getTau(); }
    CG_OpndHandle *tauAnd(U_32, CG_OpndHandle**) { return opndManager->getTau(); }
    void          opndMaybeGlobal(CG_OpndHandle* opnd)            {}
    void          setCurrentPersistentId(PersistentInstructionId) {}
    void          clearCurrentPersistentId()                      {}
    void          setCurrentHIRInstBCOffset(uint16)               {}
    uint16        getCurrentHIRInstBCOffset() const         {return 0xFFFF;}

    //---------------------------------------------------------------------------//
    // Methods that are not going to be implemented
    //---------------------------------------------------------------------------//

    CG_OpndHandle *mulhi(MulHiOp::Types, CG_OpndHandle*, CG_OpndHandle*)   { NOT_IMPLEMENTED_C("mulhi"); }
    CG_OpndHandle *pred_czero (CompareZeroOp::Types, CG_OpndHandle*)       { NOT_IMPLEMENTED_C("pred_czero") }
    CG_OpndHandle *pred_cnzero(CompareZeroOp::Types, CG_OpndHandle*)       { NOT_IMPLEMENTED_C("pred_cnzero") }
    CG_OpndHandle *tau_checkDivOpnds(CG_OpndHandle*, CG_OpndHandle*)       { NOT_IMPLEMENTED_C("tau_checkDivOpnds") }
    CG_OpndHandle *ldFunAddr(Type*, MethodDesc*)                           { NOT_IMPLEMENTED_C("ldFunAddr") } 
    CG_OpndHandle *uncompressRef(CG_OpndHandle *compref)                   { NOT_IMPLEMENTED_C("uncompressRef") }
    CG_OpndHandle *compressRef(CG_OpndHandle *ref)                         { NOT_IMPLEMENTED_C("compressRef") }
    CG_OpndHandle *ldFieldOffset(FieldDesc*)                               { NOT_IMPLEMENTED_C("ldFieldOffset") }
    CG_OpndHandle *ldFieldOffsetPlusHeapbase(FieldDesc*)                   { NOT_IMPLEMENTED_C("ldFieldOffsetPlusHeapbase") }
    CG_OpndHandle *ldArrayBaseOffset(Type*)                                { NOT_IMPLEMENTED_C("ldArrayBaseOffset") }
    CG_OpndHandle *ldArrayLenOffset(Type*)                                 { NOT_IMPLEMENTED_C("ldArrayLenOffset") }
    CG_OpndHandle *ldArrayBaseOffsetPlusHeapbase(Type*)                    { NOT_IMPLEMENTED_C("ldArrayBaseOffsetPlusHeapbase") }
    CG_OpndHandle *ldArrayLenOffsetPlusHeapbase(Type*)                     { NOT_IMPLEMENTED_C("ldArrayLenOffsetPlusHeapbase") }
    CG_OpndHandle *addOffset(Type*, CG_OpndHandle*, CG_OpndHandle*)        { NOT_IMPLEMENTED_C("addOffset") }
    CG_OpndHandle *ldElemAddr(CG_OpndHandle*,CG_OpndHandle*)               { NOT_IMPLEMENTED_C("ldElemAddr") }
    CG_OpndHandle *ldStatic(Type*, FieldDesc*, Type::Tag, bool)            { NOT_IMPLEMENTED_C("ldStatic") }
    CG_OpndHandle *ldVarAddr(U_32)                                       { NOT_IMPLEMENTED_C("ldVarAddr") }
    CG_OpndHandle *ldToken(Type*, MethodDesc*, U_32)                     { NOT_IMPLEMENTED_C("ldToken") }
    CG_OpndHandle *tau_cast(ObjectType*, CG_OpndHandle*, CG_OpndHandle*)   { NOT_IMPLEMENTED_C("tau_cast") }
    CG_OpndHandle *tau_asType(ObjectType*, CG_OpndHandle*, CG_OpndHandle*) { NOT_IMPLEMENTED_C("tau_asType") }
    CG_OpndHandle *box(ObjectType*, CG_OpndHandle*)                        { NOT_IMPLEMENTED_C("box") }
    CG_OpndHandle *unbox(Type*, CG_OpndHandle*)                            { NOT_IMPLEMENTED_C("unbox") }
    CG_OpndHandle *ldValueObj(Type*, CG_OpndHandle*)                       { NOT_IMPLEMENTED_C("ldValueObj") }
    CG_OpndHandle *tau_ckfinite(CG_OpndHandle*)                            { NOT_IMPLEMENTED_C("tau_ckfinite") }
    CG_OpndHandle *callhelper(U_32, CG_OpndHandle**, Type*, JitHelperCallOp::Id) { NOT_IMPLEMENTED_C("callhelper") }
    CG_OpndHandle *tau_callvirt(U_32, CG_OpndHandle**, Type*, MethodDesc*, CG_OpndHandle*, CG_OpndHandle*)  { NOT_IMPLEMENTED_C("tau_callvirt") }
    CG_OpndHandle *select(CompareOp::Types, CG_OpndHandle*, CG_OpndHandle*, CG_OpndHandle*) { NOT_IMPLEMENTED_C("select") }
    CG_OpndHandle *cmp3(CompareOp::Operators,CompareOp::Types, CG_OpndHandle*, CG_OpndHandle*) { NOT_IMPLEMENTED_C("cmp3") }
    CG_OpndHandle *tau_optimisticBalancedMonitorEnter(CG_OpndHandle*, CG_OpndHandle*, CG_OpndHandle*) { NOT_IMPLEMENTED_C("tau_optimisticBalancedMonitorEnter") }
    CG_OpndHandle *addOffsetPlusHeapbase(Type*, CG_OpndHandle*, CG_OpndHandle*) { NOT_IMPLEMENTED_C("addOffsetPlusHeapbase") }
    CG_OpndHandle *tau_ldField(Type*, CG_OpndHandle*, Type::Tag, FieldDesc*, bool, CG_OpndHandle*, CG_OpndHandle*) { NOT_IMPLEMENTED_C("tau_ldField") }
    CG_OpndHandle *tau_ldElem(Type*, CG_OpndHandle*, CG_OpndHandle*, bool, CG_OpndHandle*, CG_OpndHandle*) { NOT_IMPLEMENTED_C("tau_ldElem") }
    void          incCounter(Type*, U_32)                               { NOT_IMPLEMENTED_V("incCounter") }
    void          incRecursionCount(CG_OpndHandle*, CG_OpndHandle*)       { NOT_IMPLEMENTED_V("incRecursionCount") }
    void          monitorEnterFence(CG_OpndHandle*)                       { NOT_IMPLEMENTED_V("monitorEnterFence") }
    void          monitorExitFence(CG_OpndHandle*)                        { NOT_IMPLEMENTED_V("monitorExitFence") }
    void          stValueObj(CG_OpndHandle*, CG_OpndHandle*)              { NOT_IMPLEMENTED_V("stValueObj") }
    void          initValueObj(Type*, CG_OpndHandle*)                     { NOT_IMPLEMENTED_V("initValueObj") }
    void          copyValueObj(Type*, CG_OpndHandle*, CG_OpndHandle*)     { NOT_IMPLEMENTED_V("copyValueObj") }
    void          prefetch(CG_OpndHandle*)                                { NOT_IMPLEMENTED_V("prefetch") }
    void          jump()                                                  { NOT_IMPLEMENTED_V("jump") }
    void          throwLazyException(U_32, CG_OpndHandle**, MethodDesc*) { NOT_IMPLEMENTED_V("throwLazyException") }
    void          tau_stStatic(CG_OpndHandle*, FieldDesc*, Type::Tag, bool, CG_OpndHandle*) { NOT_IMPLEMENTED_V("tau_stStatic") } 
    void          tau_stField(CG_OpndHandle*, CG_OpndHandle*, Type::Tag, FieldDesc*, bool, CG_OpndHandle*, CG_OpndHandle*, CG_OpndHandle*) { NOT_IMPLEMENTED_V("tau_stField") }
    void          tau_stElem(CG_OpndHandle*, CG_OpndHandle*, CG_OpndHandle*, bool, CG_OpndHandle*, CG_OpndHandle*, CG_OpndHandle*) { NOT_IMPLEMENTED_V("tau_stElem") }
    void          optimisticBalancedMonitorExit(CG_OpndHandle*, CG_OpndHandle*, CG_OpndHandle*) { NOT_IMPLEMENTED_V("optimisticBalancedMonitorExit") }

    //---------------------------------------------------------------------------//
    // TRANSITION
    //---------------------------------------------------------------------------//

    CG_OpndHandle* callvmhelper(U_32, CG_OpndHandle**, Type*
                        , VM_RT_SUPPORT) { NOT_IMPLEMENTED_C("unbox") }

    CG_OpndHandle* convUPtrToObject(ObjectType*, CG_OpndHandle*)              { NOT_IMPLEMENTED_C("convUPtrToObject") }
    CG_OpndHandle* convToUPtr(PtrType*, CG_OpndHandle*)                       { NOT_IMPLEMENTED_C("convToUPtr") }
    CG_OpndHandle *tau_ldIntfTableAddr(Type*, CG_OpndHandle*, NamedType*, CG_OpndHandle*) { NOT_IMPLEMENTED_C("tau_ldIntfTableAddr"); }
    CG_OpndHandle* tau_ldIntfTableAddr(Type*, CG_OpndHandle*, NamedType*);
    CG_OpndHandle* addElemIndexWithLEA(Type*, CG_OpndHandle*, CG_OpndHandle*) { NOT_IMPLEMENTED_C("addElemIndexWithLEA") }
    CG_OpndHandle* ldRef(Type*, MethodDesc*, unsigned int, bool); 
    void           pseudoInst()                                               {}
    void           methodEntry(MethodDesc*);
    void           methodEnd(MethodDesc*, CG_OpndHandle*);
    void           tau_stRef(CG_OpndHandle*, CG_OpndHandle*, CG_OpndHandle*, Type::Tag, bool, CG_OpndHandle*, CG_OpndHandle*, CG_OpndHandle*) { NOT_IMPLEMENTED_V("tau_stRef") }

    //---------------------------------------------------------------------------//
    // convertors from HLO to IPF::CG types
    //---------------------------------------------------------------------------//

    static DataKind  toDataKind(IntegerOp::Types type);
    static DataKind  toDataKind(Type::Tag tag);                    
    static OpndKind  toOpndKind(Type::Tag tag);                    
    static DataKind  toDataKind(NegOp::Types type);
    static OpndKind  toOpndKind(NegOp::Types type);
    static DataKind  toDataKind(ArithmeticOp::Types type);
    static OpndKind  toOpndKind(ArithmeticOp::Types type);
    static DataKind  toDataKind(RefArithmeticOp::Types type);
    static DataKind  toDataKind(ConvertToIntOp::Types type, bool isSigned);
    static OpndKind  toOpndKind(DivOp::Types type);
    static DataKind  toDataKind(DivOp::Types type);
    static InstCode  toInstCmp(CompareOp::Types type);
    static InstCode  toInstCmp(CompareZeroOp::Types type);
    static Completer toCmpltCrel(CompareOp::Operators cmpOp, bool isFloating);
    static Completer toCmpltSz(DataKind dataKind);

protected:

    // Create new inst and add it in current node
    void      addInst(Inst* inst);
    Inst&     addNewInst(InstCode instCode_, 
                  CG_OpndHandle *op1=NULL, CG_OpndHandle *op2=NULL, CG_OpndHandle *op3=NULL, 
                  CG_OpndHandle *op4=NULL, CG_OpndHandle *op5=NULL, CG_OpndHandle *op6=NULL);
    Inst&     addNewInst(InstCode instCode_, Completer comp1,
                  CG_OpndHandle *op1=NULL, CG_OpndHandle *op2=NULL, CG_OpndHandle *op3=NULL, 
                  CG_OpndHandle *op4=NULL, CG_OpndHandle *op5=NULL, CG_OpndHandle *op6=NULL);
    Inst&     addNewInst(InstCode instCode_, Completer comp1, Completer comp2,
                  CG_OpndHandle *op1=NULL, CG_OpndHandle *op2=NULL, CG_OpndHandle *op3=NULL, 
                  CG_OpndHandle *op4=NULL, CG_OpndHandle *op5=NULL, CG_OpndHandle *op6=NULL);
    Inst&     addNewInst(InstCode instCode_, Completer comp1, Completer comp2, Completer comp3,
                  CG_OpndHandle *op1=NULL, CG_OpndHandle *op2=NULL, CG_OpndHandle *op3=NULL, 
                  CG_OpndHandle *op4=NULL, CG_OpndHandle *op5=NULL, CG_OpndHandle *op6=NULL);
        
    // CG helper methods
    void      directCall(U_32, Opnd**, RegOpnd*, Opnd*, RegOpnd*, Completer=CMPLT_WH_SPTK);
    void      indirectCall(U_32, Opnd**, RegOpnd*, RegOpnd*, RegOpnd*, Completer=CMPLT_WH_SPTK);
    void      makeCallArgs(U_32, Opnd**, Inst*, RegOpnd*);
    RegOpnd   *makeConvOpnd(RegOpnd*);
    void      makeRetVal(RegOpnd*, RegOpnd*, RegOpnd*);

    void      add(RegOpnd*, CG_OpndHandle*, CG_OpndHandle*);
    void      sub(RegOpnd*, CG_OpndHandle*, CG_OpndHandle*);
    void      cmp(InstCode, Completer, RegOpnd*, RegOpnd*, CG_OpndHandle*, CG_OpndHandle*);
    void      cmp(Completer, RegOpnd*, RegOpnd*, CG_OpndHandle*, CG_OpndHandle*);
    void      binOp(InstCode, RegOpnd*, CG_OpndHandle*, CG_OpndHandle*);
    void      shift(InstCode, RegOpnd*, CG_OpndHandle*, CG_OpndHandle*, int);
    void      minMax(RegOpnd*, CG_OpndHandle*, CG_OpndHandle*, bool);
    void      xma(InstCode, RegOpnd*, CG_OpndHandle*, CG_OpndHandle*);
    void      saturatingConv4(RegOpnd*, CG_OpndHandle*);
    void      saturatingConv8(RegOpnd*, CG_OpndHandle*);
    void      divDouble(RegOpnd*, CG_OpndHandle*, CG_OpndHandle*, bool rem = false);
    void      divFloat(RegOpnd*, CG_OpndHandle*, CG_OpndHandle*, bool rem = false);
    void      divInt(RegOpnd*, CG_OpndHandle*, CG_OpndHandle*, bool rem = false);
    void      divLong(RegOpnd*, CG_OpndHandle*, CG_OpndHandle*, bool rem = false);
    void      ldc(RegOpnd*, int64 val);
    void      sxt(CG_OpndHandle *src_, int16 refSize, Completer srcSize = CMPLT_INVALID);
    void      zxt(CG_OpndHandle *src_, int16 refSize, Completer srcSize = CMPLT_INVALID);
    RegOpnd   *toRegOpnd(CG_OpndHandle*);
    void      ipfBreakCounted(int);
    void      ipfBreakCounted(RegOpnd*, Completer, int);
    void      ipfBreakCounted(RegOpnd*);
    
    MemoryManager         &mm;
    Cfg                   &cfg;
    BbNode                &node;
    OpndVector            &opnds;
    CompilationInterface  &compilationInterface;
    OpndManager           *opndManager;
    
    RegOpnd               *p0;
};

} //namespace IPF
} //namespace Jitrino 

#endif // _IPF_CODE_SELECTOR_H_