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

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


#ifndef _INST_H_
#define _INST_H_

#include "MemoryManager.h"
#include "Stl.h"
#include "VMInterface.h"
#include "Dlink.h"
#include "Type.h"
#include "Opcode.h"
#include "Opnd.h"
#include "Log.h"
#include "ControlFlowGraph.h"

#include "open/types.h"

#include <assert.h>
#include <stdio.h>
#include <iostream>

namespace Jitrino {

class   OpndRenameTable;
class   IRBuilder;
class   IRManager;
class   InstFactory;
class   PiCondition;
class   DominatorTree;

//
// forward declarations of the different instruction formats
//
class   Inst;
class   LabelInst;
class   DispatchLabelInst;
class   CatchLabelInst;
class   MethodEntryInst;
class   MethodMarkerInst;
class   TypeInst;
class   VarAccessInst;
class   FieldAccessInst;
class   BranchInst;
class   SwitchInst;
class   ConstInst;
class   MethodInst;
class   TokenInst;
class   LinkingExcInst;
class   CallInst;
class   JitHelperCallInst;
class   VMHelperCallInst;
class   PhiInst;
class   MultiSrcInst;
class   MethodCallInst;
class   TauPiInst;

//
// visitor pattern for the different instruction formats
//
class InstFormatVisitor {
public:
    virtual ~InstFormatVisitor() {}
    virtual void accept(Inst*) = 0;
    virtual void accept(BranchInst*) = 0;
    virtual void accept(CallInst*) = 0;
    virtual void accept(CatchLabelInst*) = 0;
    virtual void accept(ConstInst*) = 0;
    virtual void accept(DispatchLabelInst*) = 0;
    virtual void accept(JitHelperCallInst*) = 0;
    virtual void accept(VMHelperCallInst*) = 0;
    virtual void accept(FieldAccessInst*) = 0;
    virtual void accept(LabelInst*) = 0;
    virtual void accept(MethodCallInst*) = 0;
    virtual void accept(MethodEntryInst*) = 0;
    virtual void accept(MethodInst*) = 0;
    virtual void accept(MethodMarkerInst*) = 0;
    virtual void accept(MultiSrcInst*) = 0;
    virtual void accept(PhiInst*) = 0;
    virtual void accept(TauPiInst*) = 0;
    virtual void accept(SwitchInst*) = 0;
    virtual void accept(TokenInst*) = 0;
    virtual void accept(TypeInst*) = 0;
    virtual void accept(VarAccessInst*) = 0;
};

//
// Base Instruction class.
//
#define MAX_INST_SRCS 2

class Inst : public CFGInst {
public:
    virtual ~Inst() {}

    Inst* getNextInst() const {return (Inst*)next();}
    Inst* getPrevInst() const {return (Inst*)prev();}

    bool isHeaderCriticalInst() const {return getOpcode() == Op_Catch || isLabel();}

    Type::Tag    getType() const {
        return operation.getType();
    }

    Opcode      getOpcode() const   {
        return operation.getOpcode();
    }

    Modifier    getModifier() const {
        return operation.getModifier();
    }

    Operation getOperation() const {return operation;}

    U_32 getId() const {return id;}

    PersistentInstructionId getPersistentInstructionId() const {return pid; }

    void   setPersistentInstructionId(PersistentInstructionId id) {pid = id; }

    Opnd*  getDst() const {return dst;}

    void setType(Type::Tag newType) {
        operation.setType(newType);
    }

    void setModifier(Modifier newMod) {
        operation.setModifier(newMod);
    }

    void setDst(Opnd* newDst) {
        if (dst && dst->isNull() == false && dst->isVarOpnd() == false && (dst->getInst() == this))
            dst->setInst(0);
        dst = newDst;
        if (dst && dst->isNull() == false && dst->isVarOpnd() == false)
            dst->setInst(this);
    }

    U_32  getNumSrcOperands() const    {return numSrcs;}

    Opnd*   getSrc(U_32 srcIndex) const {
        assert(srcIndex < numSrcs);
        if (srcIndex >= MAX_INST_SRCS)
            return getSrcExtended(srcIndex);
        return srcs[srcIndex];
    }

    void  setSrc(U_32 srcIndex, Opnd* src) {
        assert(srcIndex < numSrcs);
        if (srcIndex >= MAX_INST_SRCS)
            setSrcExtended(srcIndex, src);
        else
            srcs[srcIndex] = src;
    }

    virtual void visit(InstFormatVisitor& visitor)  {visitor.accept(this);}
    //
    // for down-casting to a derived Inst class
    // we de-virtualize these so the C++ compiler can do CSE on isFoo() in most uses
    //
    BranchInst* asBranchInst() const {
        if (isBranch()) return (BranchInst*)this; else return NULL;
    }
    CallInst* asCallInst() const {
        if (isCall()) return (CallInst*)this; else return NULL;
    }
    CatchLabelInst* asCatchLabelInst() const {
        if (isCatchLabel()) return (CatchLabelInst*)this; else return NULL;
    }
    ConstInst* asConstInst() const {
        if (isConst()) return (ConstInst*)this; else return NULL;
    }
    DispatchLabelInst* asDispatchLabelInst() const {
        if (isDispatchLabel()) return (DispatchLabelInst*)this; else return NULL;
    }
    FieldAccessInst* asFieldAccessInst() const {
        if (isFieldAccess()) return (FieldAccessInst*)this; else return NULL;
    }
    JitHelperCallInst* asJitHelperCallInst() const {
        if (isJitHelperCallInst()) return (JitHelperCallInst*) this; else return NULL;
    }
    VMHelperCallInst* asVMHelperCallInst() const {
        if (isVMHelperCallInst()) return (VMHelperCallInst*) this; else return NULL;
    }
    LabelInst* asLabelInst() const {
        if (isLabel()) return (LabelInst*)this; else return NULL;
    }
    MethodCallInst* asMethodCallInst() const {
        if (isMethodCall()) return (MethodCallInst*)this; else return NULL;
    }
    MethodEntryInst* asMethodEntryInst() const {
        if (isMethodEntry()) return (MethodEntryInst*)this; else return NULL;
    }
    MethodInst* asMethodInst() const {
        if (isMethod()) return (MethodInst*)this; else return NULL;
    }
    MethodMarkerInst* asMethodMarkerInst() const {
        if (isMethodMarker()) return(MethodMarkerInst*)this; else return NULL;
    }
    MultiSrcInst* asMultiSrcInst() const {
        if (isMultiSrcInst()) return (MultiSrcInst*)this; else return NULL;
    }
    PhiInst* asPhiInst() const { 
        if (isPhi()) return (PhiInst*)this; else return NULL;
    }
    TauPiInst *asTauPiInst() const {
        if (isTauPi()) return (TauPiInst*)this; else return NULL;
    }
    SwitchInst* asSwitchInst() const {
        if (isSwitch()) return (SwitchInst *)this; else return NULL;
    }
    TokenInst* asTokenInst() const {
        if (isToken()) return (TokenInst*)this; else return NULL;
    }
    TypeInst* asTypeInst() const {
        if (isType()) return (TypeInst*) this; else return NULL; 
    }
    VarAccessInst* asVarAccessInst() const {
        if (isVarAccess()) return (VarAccessInst*) this; else return NULL;
    }

    void        print(::std::ostream&) const;
    bool        isSigned() const {
        return operation.isSigned();
    }

    virtual bool isBranch() const { return false; };
    virtual bool isCall() const { return false; };
    virtual bool isCatchLabel() const { return false; };
    virtual bool isConst() const { return false; };
    virtual bool isDispatchLabel() const { return false; };
    virtual bool isFieldAccess() const { return false; };
    virtual bool isJitHelperCallInst() const { return false; };
    virtual bool isVMHelperCallInst() const { return false; };
    virtual bool isMethodCall() const { return false; };
    virtual bool isMethodEntry() const { return false; };
    virtual bool isMethod() const { return false; };
    virtual bool isMethodMarker() const { return false; };
    virtual bool isMultiSrcInst() const { return false; };
    bool isPhi() const { return (getOpcode() == Op_Phi); };
    bool isTauPi() const { return (getOpcode() == Op_TauPi); };
    bool isSwitch() const { return (getOpcode() == Op_Switch); };
    virtual bool isToken() const { return false; };
    virtual bool isType() const { return false; };
    virtual bool isVarAccess() const { return false; };

    bool isThrow() const ;
    bool isReturn() const     {return getOpcode() == Op_Return;    }
    bool isLdVar() const      {return getOpcode() == Op_LdVar;     }
    bool isLdVarAddr() const  {return getOpcode() == Op_LdVarAddr; }
    bool isStVar() const      {return getOpcode() == Op_StVar;     }
    bool isJSR() const        {return getOpcode() == Op_JSR;       }
    bool isRet() const        {return getOpcode() == Op_Ret;       }

    bool isUnconditionalBranch() const {return getOpcode() == Op_Jump;}
    bool isConditionalBranch() const  {return getOpcode() == Op_Branch;}

    ComparisonModifier getComparisonModifier() const {
        return operation.getComparisonModifier();
    }
    void setComparisonModifier(ComparisonModifier newmod) {
        operation.setComparisonModifier(newmod);
    }
    SignedModifier getSignedModifier() const {
        return operation.getSignedModifier();
    }
    void setSignedModifier(SignedModifier newmod) {
        operation.setSignedModifier(newmod);
    }
    OverflowModifier getOverflowModifier() const {
        return operation.getOverflowModifier();
    }
    void setOverflowModifier(OverflowModifier newmod) {
        operation.setOverflowModifier(newmod);
    }
    ShiftMaskModifier getShiftMaskModifier() const {
        return operation.getShiftMaskModifier();
    }
    void setShiftMaskModifier(ShiftMaskModifier mod) {
        operation.setShiftMaskModifier(mod);
    }
    StrictModifier getStrictModifier() const {
        return operation.getStrictModifier();
    }
    void setStrictModifier(StrictModifier mod) {
        operation.setStrictModifier(mod);
    }
    DefArgModifier getDefArgModifier() const {
        return operation.getDefArgModifier();
    }
    void setDefArgModifier(DefArgModifier mod) {
        operation.setDefArgModifier(mod);
    }
    StoreModifier getStoreModifier() const {
        return operation.getStoreModifier();
    }
    void setStoreModifier(StoreModifier mod) {
        operation.setStoreModifier(mod);
    }
    ExceptionModifier getExceptionModifier() const {
        return operation.getExceptionModifier();
    }
    void setExceptionModifier(ExceptionModifier mod) {
        operation.setExceptionModifier(mod);
    }
    AutoCompressModifier getAutoCompressModifier() const {
        return operation.getAutoCompressModifier();
    }
    void setAutoCompressModifier(AutoCompressModifier mod) {
        operation.setAutoCompressModifier(mod);
    }
    SpeculativeModifier getSpeculativeModifier() const {
        return operation.getSpeculativeModifier();
    }
    void setSpeculativeModifier(SpeculativeModifier mod) {
        operation.setSpeculativeModifier(mod);
    }
    ThrowModifier getThrowModifier() const {
        return operation.getThrowModifier();
    }
    void setThrowModifier(ThrowModifier mod) {
        operation.setThrowModifier(mod);
    }
    NewModifier1 getNewModifier1() const {
        return operation.getNewModifier1();
    }
    void setNewModifier1(NewModifier1 mod) {
        operation.setNewModifier1(mod);
    }
    NewModifier2 getNewModifier2() const {
        return operation.getNewModifier2();
    }
    void setNewModifier2(NewModifier2 mod) {
        operation.setNewModifier2(mod);
    }


protected:
    //
    // Constructors
    //
    Inst(Opcode op, Modifier modifier, Type::Tag, Opnd* dst);
    Inst(Opcode op, Modifier modifier, Type::Tag, Opnd* dst, Opnd* src);
    Inst(Opcode op, Modifier modifier, Type::Tag, Opnd* dst, Opnd* src1, Opnd* src2);
    Inst(Opcode op, Modifier modifier, Type::Tag, Opnd* dst, Opnd* src1, Opnd* src2, Opnd *src3);
    Inst(Opcode op, Modifier modifier, Type::Tag, Opnd* dst, U_32 nSrcs);
    //
    // fields
    //
    Operation operation;
    U_32  numSrcs;
    Opnd*   srcs[MAX_INST_SRCS];
    Opnd*   dst;
    PersistentInstructionId pid;
    U_32  id;
    
    
    // called from CFG to detect BB->BB block edges
    virtual Edge::Kind getEdgeKind(const Edge* edge) const;
    
    virtual void removeRedundantBranch();

    //
    // protected accessor methods that deriving classes should override
    //
    virtual Opnd* getSrcExtended(U_32 srcIndex) const;
    virtual void  setSrcExtended(U_32 srcIndex, Opnd* src) {assert(0);}
    virtual void  handlePrintEscape(::std::ostream&, char code) const;
private:
    friend class InstFactory;
    void printFormatString(::std::ostream&, const char*) const;
};

class LabelInst : public Inst {
public:
    U_32    getLabelId() const            {return labelId;}
    void      setLabelId(U_32 id_)    {labelId = id_;}
    bool      isLabel() const               {return true;}
    virtual bool isDispatchLabel() const    {return false;}
    virtual bool isCatchLabel() const       {return false;}
    void      setState(void *stat)     {state = stat;} 
    void *    getState()               {return state;}
    void visit(InstFormatVisitor& visitor)  {visitor.accept(this);}
    virtual void printId(::std::ostream&) const;
protected:
    LabelInst(U_32 id)
             : Inst(Op_Label, Modifier(), Type::Void, OpndManager::getNullOpnd()),
               labelId(id), state(NULL) {}
    LabelInst(Opcode opc, U_32 id)
             : Inst(opc, Modifier(), Type::Void, OpndManager::getNullOpnd()),
               labelId(id), state(NULL) {}
    virtual void handlePrintEscape(::std::ostream&, char code) const;
private:
    friend class InstFactory;
    U_32   labelId;
    
    void*    state;     
};

class DispatchLabelInst: public LabelInst {
public:
    bool    isDispatchLabel() const {return true;}
    void visit(InstFormatVisitor& visitor)  {visitor.accept(this);}
    void printId(::std::ostream&) const;
protected:
    friend class InstFactory;
    DispatchLabelInst(U_32 labelId) : LabelInst(labelId) {}
    virtual void handlePrintEscape(::std::ostream&, char code) const;
};

class CatchLabelInst: public LabelInst {
public:
    bool      isCatchLabel() const     {return true; }
    void visit(InstFormatVisitor& visitor)  {visitor.accept(this);}
    U_32    getOrder() const         {return order;}
    Type*     getExceptionType() const {return exception;}
    void printId(::std::ostream&) const;
protected:
    CatchLabelInst(U_32 id, U_32 ord, Type *except)
              : LabelInst(id), order(ord), exception(except) {}
    virtual void handlePrintEscape(::std::ostream&, char code) const;
private:
    friend class InstFactory;
    U_32   order;
    Type     *exception;
};

class MethodEntryInst : public LabelInst {
public:
    MethodDesc* getMethodDesc() {return methodDesc;}
    void visit(InstFormatVisitor& visitor)  {visitor.accept(this);}
    bool isMethodEntry() const { return true; }
protected:
    MethodEntryInst(U_32 id, MethodDesc* md)
        : LabelInst(Op_MethodEntry, id), methodDesc(md){}
    virtual void handlePrintEscape(::std::ostream&, char code) const;
private:
    friend class InstFactory;
    MethodDesc* methodDesc;
};

class MethodMarkerInst : public Inst {
public:
    void visit(InstFormatVisitor& visitor)  {visitor.accept(this);}
    bool isMethodMarker() const { return true; }
    enum Kind {Entry, Exit};
    bool isMethodEntryMarker() { return kind == Entry; }
    bool isMethodExitMarker() { return kind == Exit; }
    MethodDesc *getMethodDesc() { return methodDesc; }

    void removeOpnd() {
        setSrc(0, OpndManager::getNullOpnd());
        if (numSrcs) numSrcs--;
    }

protected:
    virtual void handlePrintEscape(::std::ostream&, char code) const;
private:
    friend class InstFactory;

    MethodMarkerInst(Kind k, MethodDesc* md) :
            Inst(k==Entry? Op_MethodEntry : Op_MethodEnd, Modifier(), Type::Void, 
            OpndManager::getNullOpnd()), kind(k), methodDesc(md), retOpnd(NULL) {}

    MethodMarkerInst(Kind k, MethodDesc* md, Opnd *resOpnd) :
            Inst(k==Entry? Op_MethodEntry : Op_MethodEnd, Modifier(), Type::Void, 
            OpndManager::getNullOpnd()), kind(k), methodDesc(md), retOpnd(resOpnd) {}

    MethodMarkerInst(Kind k, MethodDesc* md, Opnd *obj, Opnd *resOpnd) :
    Inst(k==Entry? Op_MethodEntry : Op_MethodEnd, Modifier(), Type::Void, OpndManager::getNullOpnd(),
            obj), kind(k), methodDesc(md), retOpnd(resOpnd) { 
        assert(obj && !obj->isNull()); 

    }
    Kind        kind;
    MethodDesc* methodDesc;
    Opnd* retOpnd;
};

//
// indicate exception information
//

class BranchInst : public Inst {
public:
    bool       isBranch() const        {return true;}
    void visit(InstFormatVisitor& visitor)  {visitor.accept(this);}

    void       replaceTargetLabel(LabelInst* target) {targetLabel = target;}
    LabelInst* getTargetLabel() const      {return targetLabel;}
    void       swapTargets(LabelInst *target);
    Edge       *getTakenEdge(U_32 condition);
protected:
    virtual void handlePrintEscape(::std::ostream&, char code) const;
    virtual Edge::Kind getEdgeKind(const Edge* edge) const;
    virtual void updateControlTransferInst(Node* oldTarget, Node* newTarget); 
private:
    friend class InstFactory;
    BranchInst(Opcode op, LabelInst* target)
        : Inst(op, Modifier(), Type::Void, OpndManager::getNullOpnd()), targetLabel(target) {};
    BranchInst(Opcode op, Opnd* src, LabelInst* target)
        : Inst(op, Modifier(), Type::Boolean, OpndManager::getNullOpnd(), src), 
          targetLabel(target) {}
    BranchInst(Opcode op,
               ComparisonModifier mod,
               Type::Tag type,
               Opnd* src,
               LabelInst* target)
        : Inst(op, mod, type, OpndManager::getNullOpnd(), src), targetLabel(target) {}
    BranchInst(Opcode op,
               ComparisonModifier mod,
               Type::Tag type,
               Opnd* src1,
               Opnd* src2,
               LabelInst* target)
        : Inst(op, mod, type, OpndManager::getNullOpnd(), src1, src2), targetLabel(target) {}
    LabelInst*  targetLabel;
};

class SwitchInst : public Inst {
public:
    LabelInst* getTarget(U_32 i) {
        assert(i < numTargets);
        return targetInsts[i];
    }
    LabelInst** getTargets() { return targetInsts; }
    void visit(InstFormatVisitor& visitor)  {visitor.accept(this);}
    bool isSwitch() const {return true;}
    LabelInst* getDefaultTarget() const {return defaultTargetInst;}
    U_32     getNumTargets() {return numTargets;}
    void       replaceTargetLabel(U_32 i, LabelInst* target) {
        assert(i < numTargets);
        targetInsts[i] = target;
    }
    void       replaceDefaultTargetLabel(LabelInst* target) { defaultTargetInst = target; }

protected:
    virtual void handlePrintEscape(::std::ostream&, char code) const;
    virtual Edge::Kind getEdgeKind(const Edge* edge) const;
    virtual void updateControlTransferInst(Node* oldTarget, Node* newTarget); 
private:
    friend class InstFactory;
    SwitchInst(Opnd* src, LabelInst** targets, U_32 nTargets, LabelInst* defTarget)
        : Inst(Op_Switch, Modifier(), Type::Void, OpndManager::getNullOpnd(), src),
          targetInsts(targets), defaultTargetInst(defTarget), numTargets(nTargets) {
    }
    LabelInst** targetInsts;
    LabelInst*  defaultTargetInst;
    U_32      numTargets;
};

class ConstInst : public Inst {
public:
    union ConstValue {
        void*    i;    // I  (can be NULL for ldnull)
        I_32    i4;   // I4
        int64    i8;   // I8
        float    s;    // Single
        double   d;    // Double
        struct {
            I_32 dword1;
            I_32 dword2;
        };
        ConstValue() {dword1=dword2=0;}
    };
    void visit(InstFormatVisitor& visitor)  {visitor.accept(this);}
    virtual bool isConst() const {return true;}
    ConstValue    getValue()    {return value;}
protected:
    virtual void handlePrintEscape(::std::ostream&, char code) const;
private:
    friend class InstFactory;
    ConstInst(Opnd* d, ConstValue cv)
        : Inst(Op_LdConstant, Modifier(), d->getType()->tag, d) { value = cv; }
    ConstInst(Opnd* d, I_32 i4)
        : Inst(Op_LdConstant, Modifier(), Type::Int32, d)  {value.i4 = i4;}
    ConstInst(Opnd* d, int64 i8)
        : Inst(Op_LdConstant, Modifier(), Type::Int64, d)  {value.i8 = i8;}
    ConstInst(Opnd* d, float fs)
        : Inst(Op_LdConstant, Modifier(), Type::Single, d) {value.s = fs;}
    ConstInst(Opnd* d, double fd)
        : Inst(Op_LdConstant, Modifier(), Type::Double, d)  {value.d = fd;}
    ConstInst(Opnd* d, void* ptr)
        : Inst(Op_LdConstant, Modifier(), d->getType()->tag, d)  {value.i = ptr;}
    ConstInst(Opnd* d)
        : Inst(Op_LdConstant, Modifier(), Type::NullObject, d) {value.i=NULL;}
    ConstValue value;
};

class TokenInst : public Inst {
public:
    void visit(InstFormatVisitor& visitor)  {visitor.accept(this);}
    U_32 getToken() const   {return token;}
    MethodDesc*    getEnclosingMethod()     {return enclosingMethod;}
    bool isToken() const                    {return true;}
protected:
    virtual void handlePrintEscape(::std::ostream&, char code) const;
private:
    friend class InstFactory;
    TokenInst(Opcode opc, Modifier mod, Type::Tag type, Opnd* d, U_32 t, MethodDesc* encMethod)
        : Inst(opc, mod, type, d), token(t), enclosingMethod(encMethod) {}

    U_32      token;
    MethodDesc* enclosingMethod;
};

// for Throw_LinkingException
class LinkingExcInst : public Inst {
public:
    void visit(InstFormatVisitor& visitor)  {visitor.accept(this);}
    Class_Handle     getEnclosingClass()  {return enclosingClass;}
    U_32           getCPIndex() const   {return cp_index;}
    U_32           getOperation() const {return operation;}
private:
    friend class InstFactory;
    LinkingExcInst(Opcode opc, Modifier mod, Type::Tag type, Opnd* d,
                   Class_Handle encClass, U_32 cp_ndx, U_32 _operation)
        : Inst(opc, mod, type, d),
          enclosingClass(encClass), cp_index(cp_ndx), operation(_operation) {}

    Class_Handle     enclosingClass;
    U_32           cp_index;
    U_32           operation;
};

// for ldvar, ldvara & stvar instructions
class VarAccessInst : public Inst {
public:
    void visit(InstFormatVisitor& visitor)  {visitor.accept(this);}
    bool     isVarAccess() const {return true;}
    VarOpnd* getVar() {
        if (isStVar())
            return (dst->isVarOpnd()) ? (VarOpnd*)dst : NULL;
        else
            return (getSrc(0)->isVarOpnd()) ? (VarOpnd*)getSrc(0) : NULL;
    }
    VarOpnd* getBaseVar() {
        if (isStVar()) {
            if (dst->isVarOpnd())
                return dst->asVarOpnd();
            else if (dst->isSsaVarOpnd())
                return (dst->asSsaVarOpnd()->getVar());
            else
                return 0;
        } else {
            Opnd *src0 = getSrc(0);
            if (src0->isVarOpnd())
                return src0->asVarOpnd();
            else if (src0->isSsaVarOpnd())
                return (src0->asSsaVarOpnd()->getVar());
            else
                return 0;
        }
    }
    VarAccessInst*  getNextVarAccessInst()    {return nextVarAccessInst;}
protected:
    virtual void     handlePrintEscape(::std::ostream&, char code) const;
private:
    friend class InstFactory;
    // ldvar & ldvara:
    VarAccessInst(Opcode op, Type::Tag type, Opnd* dst, VarOpnd* var)
                 : Inst(op, Modifier(), type, dst, var) {
        nextVarAccessInst = var->getVarAccessInsts();
        var->addVarAccessInst(this);
    }
    // stvar:
    VarAccessInst(Opcode op, Type::Tag type, VarOpnd* var, Opnd* src)
                 : Inst(op, Modifier(), type, var, src){
        nextVarAccessInst = var->getVarAccessInsts();
        var->addVarAccessInst(this);
    }
    // SsaVar forms
    // ldvar & ldvara:
    VarAccessInst(Opcode op, Type::Tag type, Opnd* dst, SsaVarOpnd* var)
                 : Inst(op, Modifier(), type, dst, var) {
        VarOpnd *orgvar = var->getVar();
        nextVarAccessInst = orgvar->getVarAccessInsts();
        orgvar->addVarAccessInst(this);
    }
    // stvar:
    VarAccessInst(Opcode op, Type::Tag type, SsaVarOpnd* var, Opnd* src)
        : Inst(op, Modifier(), type, var, src){
        VarOpnd *orgvar = var->getVar();
        nextVarAccessInst = orgvar->getVarAccessInsts();
        orgvar->addVarAccessInst(this);
    }
    VarAccessInst*   nextVarAccessInst;
};

class MultiSrcInst : public Inst {
public:
    void visit(InstFormatVisitor& visitor)  {visitor.accept(this);}
    bool isMultiSrcInst() const { return true; }
protected:
    MultiSrcInst(Opcode op, Modifier mod, Type::Tag ty, Opnd* dst)
        : Inst(op, mod, ty, dst), extendedSrcs(0), extendedSrcSpace(0) {}
    MultiSrcInst(Opcode op, Modifier mod, Type::Tag ty, Opnd* dst, Opnd* src)
        : Inst(op, mod, ty, dst, src), extendedSrcs(0), extendedSrcSpace(0) {}
    MultiSrcInst(Opcode op, Modifier mod, Type::Tag ty, Opnd* dst, Opnd* src1, Opnd* src2)
        : Inst(op, mod, ty, dst, src1, src2), extendedSrcs(0), extendedSrcSpace(0) {};
    MultiSrcInst(Opcode op,
                 Modifier mod,
                 Type::Tag ty,
                 Opnd* dst,
                 U_32 nSrcs_,
                 Opnd** srcs_)
        : Inst(op, mod, ty, dst, nSrcs_),
          extendedSrcs(srcs_), extendedSrcSpace(nSrcs_)
    {
        switch (nSrcs_) {
        default:    
        case 2:     srcs[1] = srcs_[1];
        case 1:     srcs[0] = srcs_[0];
        case 0:     break;
        }
        for (U_32 i=2; i < nSrcs_; i++) {
            srcs_[i-MAX_INST_SRCS] = srcs_[i];
            srcs_[i] = 0;
        }
    }
private:
    friend class InstFactory;
    Opnd* getSrcExtended(U_32 srcIndex) const {
        assert(srcIndex < (extendedSrcSpace + MAX_INST_SRCS));
        return extendedSrcs[srcIndex - MAX_INST_SRCS];
    }
    void  setSrcExtended(U_32 srcIndex, Opnd* src) {
        assert(srcIndex < (extendedSrcSpace + MAX_INST_SRCS));
        extendedSrcs[srcIndex - MAX_INST_SRCS] = src;
    }
    Opnd**    extendedSrcs;
    U_32    extendedSrcSpace;

    void initSrcs(U_32 nSrcs_, Opnd**srcs_) {
        switch (nSrcs_) {
        default:    
        case 2:     srcs[1] = srcs_[1];
        case 1:     srcs[0] = srcs_[0];
        case 0:     break;
        }
        for (U_32 i=2; i < nSrcs_; i++) {
            srcs_[i-MAX_INST_SRCS] = srcs_[i];
            extendedSrcs = srcs_ + MAX_INST_SRCS;
        }
    }
public:
    void  setNumSrcs(U_32 nSrcs) {
        assert(nSrcs <= numSrcs);
        numSrcs = nSrcs;
    }
};

class TypeInst : public MultiSrcInst {
public:
    Type*    getTypeInfo() {return type;}
    void visit(InstFormatVisitor& visitor)  {visitor.accept(this);}
    bool isType() const {return true; }
protected:
    TypeInst(Opcode op, Modifier mod, Type::Tag ty, Opnd* dst, Type* td)
        : MultiSrcInst(op, mod, ty, dst), type(td) {}
    TypeInst(Opcode op, Modifier mod, Type::Tag ty, Opnd* dst,
             Opnd* src, Type* td)
        : MultiSrcInst(op, mod, ty, dst, src), type(td) {}
    TypeInst(Opcode op, Modifier mod, Type::Tag ty, Opnd* dst,
             Opnd* src1, Opnd* src2, Type* td)
        : MultiSrcInst(op, mod, ty, dst, src1, src2), type(td) {}
    TypeInst(Opcode op, Modifier mod, Type::Tag ty, Opnd* dst,
             U_32 nArgs, Opnd** args_, Type* td)
        : MultiSrcInst(op, mod, ty, dst, nArgs, args_), type(td){}
    virtual void handlePrintEscape(::std::ostream&, char code) const;
private:
    friend class InstFactory;
    Type*    type;
};

// for LoadField, LoadFieldAddr, LoadStatic, LoadStaticAddr, StoreStatic, StoreField
class FieldAccessInst : public MultiSrcInst {
public:
    void visit(InstFormatVisitor& visitor)  {visitor.accept(this);}
    FieldDesc* getFieldDesc()    {return fieldDesc;}
    bool isFieldAccess() const {return true;}
protected:
    virtual void handlePrintEscape(::std::ostream&, char code) const;
private:
    friend class InstFactory;
    FieldAccessInst(Opcode op,
                    Modifier mod,
                    Type::Tag type,
                    Opnd* dst,
                    FieldDesc* fd)
        : MultiSrcInst(op, mod, type, dst), fieldDesc(fd) {}
    FieldAccessInst(Opcode op,
                    Modifier mod,
                    Type::Tag type,
                    Opnd* dst,
                    Opnd* src,
                    FieldDesc* fd)
        : MultiSrcInst(op, mod, type, dst, src), fieldDesc(fd) {}
    FieldAccessInst(Opcode op,
                    Modifier mod,
                    Type::Tag type,
                    Opnd* dst,
                    Opnd* src1,
                    Opnd* src2,
                    FieldDesc* fd)
        : MultiSrcInst(op, mod, type, dst, src1, src2), fieldDesc(fd) {}
    FieldAccessInst(Opcode op,
                    Modifier mod,
                    Type::Tag type,
                    Opnd* dst,
                    U_32 numSrcs,
                    Opnd** srcs,
                    FieldDesc* fd)
        : MultiSrcInst(op, mod, type, dst, numSrcs, srcs), fieldDesc(fd) {}
    FieldDesc* fieldDesc;
};

class MethodInst : public MultiSrcInst {
public:
    void visit(InstFormatVisitor& visitor)  {visitor.accept(this);}
    bool isMethod() const        {return true;}
    MethodDesc* getMethodDesc()    {return methodDesc;}
    void        setMethodDesc(MethodDesc* desc) {methodDesc = desc;}
protected:
    virtual void handlePrintEscape(::std::ostream&, char code) const;
    friend class InstFactory;
    MethodInst(Opcode op, Modifier mod, Type::Tag type, Opnd* dst, MethodDesc* md)
        : MultiSrcInst(op, mod, type, dst), methodDesc(md) {}
    MethodInst(Opcode op,
               Modifier mod,
               Type::Tag type,
               Opnd* dst,
               U_32 nArgs,
               Opnd ** srcs,
               MethodDesc* md)
        : MultiSrcInst(op, mod, type, dst, nArgs, srcs), methodDesc(md) {}
    MethodInst(Opcode op,
               Modifier mod,
               Type::Tag type,
               Opnd* dst,
               Opnd* base,
               MethodDesc* md)
        : MultiSrcInst(op, mod, type, dst, base), methodDesc(md) {}
    MethodInst(Opcode op,
               Modifier mod,
               Type::Tag type,
               Opnd* dst,
               Opnd* base,
               Opnd* extra,
               MethodDesc* md)
        : MultiSrcInst(op, mod, type, dst, base, extra), methodDesc(md) {}
private:

    MethodDesc* methodDesc;
};

class MethodCallInst : public MethodInst {
public:
    void visit(InstFormatVisitor& visitor)  {visitor.accept(this);}
    bool isMethodCall() const {return true;}

private:
    friend class InstFactory;
    MethodCallInst(Opcode op, Modifier mod,
                   Type::Tag type,
                   Opnd* dst,
                   U_32 nArgs,
                   Opnd** args_,
                   MethodDesc* md,
                   MemoryManager& mem_mgr)
        : MethodInst(op, mod, type, dst, nArgs, args_, md){}
};

// for call instructions
class CallInst : public Inst {
public:
    bool isCall() const {return true; }
    void visit(InstFormatVisitor& visitor)  {visitor.accept(this);}
    Opnd*   getFunPtr()             {return srcs[0];}
    U_32  getNumArgs() const      {return getNumSrcOperands()-1;}
    Opnd*   getArg(U_32 argIndex) {return getSrc(argIndex+1);}
    Opnd**  getArgs()               {args[0] = srcs[1]; return args;}
private:
    friend class InstFactory;

    CallInst(Opcode op, Modifier mod,
             Type::Tag type,
             Opnd* dst,
             Opnd* ptr,
             U_32 nArgs,
             Opnd** args_,
             MemoryManager& mem_mgr)
        : Inst(op, mod, type, dst, nArgs+1)
    {
        args = args_;
        switch (nArgs) {
        default:    
        case 1:     srcs[1] = args_[0];
        case 0:     srcs[0] = ptr;
        }
    }
    Opnd* getSrcExtended(U_32 srcIndex) const {
        assert(srcIndex != 1);
        return args[srcIndex - 1];
    }
    void  setSrcExtended(U_32 srcIndex, Opnd* src) {
        assert(srcIndex != 1);
        args[srcIndex - 1] = src;
    }
    Opnd**    args;
};

// JIT helper calls
class JitHelperCallInst : public Inst {
public:
    void visit(InstFormatVisitor& visitor)  {visitor.accept(this);}
    bool isJitHelperCallInst() const { return true; }
    JitHelperCallId getJitHelperId() const {return jitHelperId;}
private:
    virtual void handlePrintEscape(::std::ostream&, char code) const;
    friend class InstFactory;
    JitHelperCallInst(Opcode op,
                      Modifier mod,
                      Type::Tag type,
                      Opnd* dst,
                      U_32 nArgs,
                      Opnd** args_,
                      JitHelperCallId id) : Inst(op, mod, type, dst, nArgs),
                                            jitHelperId(id) {
        args = NULL;
        switch (nArgs) {
        default:    args = args_ + MAX_INST_SRCS;
        case 2:     srcs[1] = args_[1];
        case 1:     srcs[0] = args_[0];
        case 0:     break;
        }
    }
    Opnd* getSrcExtended(U_32 srcIndex) const {
        return args[srcIndex - MAX_INST_SRCS];
    }
    void  setSrcExtended(U_32 srcIndex, Opnd* src) {
        args[srcIndex - MAX_INST_SRCS] = src;
    }
    Opnd**    args;
    JitHelperCallId jitHelperId;
};

// VM helper calls
class VMHelperCallInst : public Inst {
public:
    void visit(InstFormatVisitor& visitor)  {visitor.accept(this);}
    bool isVMHelperCallInst() const { return true; }
    VM_RT_SUPPORT getVMHelperId() const {return vmHelperId;}
    bool isThrowLazy() const {return vmHelperId == VM_RT_THROW_LAZY;}
private:
    virtual void handlePrintEscape(::std::ostream&, char code) const;
    friend class InstFactory;
    VMHelperCallInst(Opcode op,
                     Modifier mod,
                     Type::Tag type,
                     Opnd* dst,
                     U_32 nArgs,
                     Opnd** args_,
                     VM_RT_SUPPORT id) 
                     : Inst(op, mod, type, dst, nArgs), vmHelperId(id)
    {
        args = args_;
        switch (nArgs) {
        default:
        case 2:     srcs[1] = args_[1];
        case 1:     srcs[0] = args_[0];
        case 0:     break;
        }
    }
    Opnd* getSrcExtended(U_32 srcIndex) const {
        return args[srcIndex];
    }
    void  setSrcExtended(U_32 srcIndex, Opnd* src) {
        args[srcIndex] = src;
    }
    Opnd**    args;
    VM_RT_SUPPORT vmHelperId;
};


// phi instructions
class PhiInst : public MultiSrcInst {
public:
    void visit(InstFormatVisitor& visitor)  {visitor.accept(this);}
    bool isMultiSrcInst() const { return false; }
    bool isPhi() const { return true; }
private:
    friend class InstFactory;
    PhiInst(Type::Tag type, Opnd* dst, U_32 nArgs, Opnd** args_ )
        : MultiSrcInst(Op_Phi, Modifier(), type, dst, nArgs, args_)
    {
    }
    bool isHeaderCriticalInst() const {return true;}
};

// pi instructions
class TauPiInst : public Inst {
public:
    void visit(InstFormatVisitor& visitor) { visitor.accept(this);}
    bool isTauPi() const { return true; }
    const PiCondition *getCond() const { return cond; };
protected:
    virtual void handlePrintEscape(::std::ostream&, char code) const;
private:
    friend class InstFactory;
    friend class InsertPi; // needs to update the cond below;
    TauPiInst(Type::Tag type, Opnd* dst, Opnd* src, Opnd *tau, PiCondition *cond0)
        : Inst(Op_TauPi, Modifier(), type, dst, src, tau),
          cond(cond0)
    {
    }
    PiCondition *cond;
};

class InstFactory {
public:
    MemoryManager& getMemManager() {return memManager;}
    Inst*    clone(Inst* inst, OpndManager& opndManager, OpndRenameTable *table);
    // Numeric compute
    Inst*    makeAdd(Modifier mod, Opnd* dst, Opnd* src1, Opnd* src2);
    Inst*    makeSub(Modifier mod, Opnd* dst, Opnd* src1, Opnd* src2);
    Inst*    makeMul(Modifier mod, Opnd* dst, Opnd* src1, Opnd* src2);
    Inst*    makeTauDiv(Modifier mod, Opnd* dst, Opnd* src1, Opnd* src2, Opnd *tauCheckedOpnds);
    Inst*    makeTauRem(Modifier mod, Opnd* dst, Opnd* src1, Opnd* src2, Opnd *tauCheckedOpnds);
    Inst*    makeNeg(Opnd* dst, Opnd* src);
    Inst*    makeMulHi(Modifier mod, Opnd* dst, Opnd* src1, Opnd* src2);
    Inst*    makeMin(Opnd* dst, Opnd* src1, Opnd* src2);
    Inst*    makeMax(Opnd* dst, Opnd* src1, Opnd* src2);
    Inst*    makeAbs(Opnd* dst, Opnd* src1);
    // Bitwise
    Inst*    makeAnd(Opnd* dst, Opnd* src1, Opnd* src2);
    Inst*    makeOr(Opnd* dst, Opnd* src1, Opnd* src2);
    Inst*    makeXor(Opnd* dst, Opnd* src1, Opnd* src2);
    Inst*    makeNot(Opnd* dst, Opnd* src);
    // Selection
    Inst*    makeSelect(Opnd* dst, Opnd* src1, Opnd* src2, Opnd* src3);
    // conversion
    Inst*    makeConv(Modifier mod, Type::Tag toType, Opnd* dst, Opnd* src);
    Inst*    makeConvZE(Modifier mod, Type::Tag toType, Opnd* dst, Opnd* src);
    Inst*    makeConvUnmanaged(Modifier mod, Type::Tag toType, Opnd* dst, Opnd* src);
    // shifts
    Inst*    makeShladd(Opnd* dst, Opnd* value, Opnd* shiftAmount, Opnd *addTo); // shiftAmount must be constant
    Inst*    makeShl(Modifier mod, Opnd* dst, Opnd* value, Opnd* shiftAmount);
    Inst*    makeShr(Modifier mod1, Opnd* dst, Opnd* value, Opnd* shiftAmount);
    // comparison
    Inst*    makeCmp(ComparisonModifier mod, Type::Tag type, Opnd* dst, Opnd* src1, Opnd* src2);
    Inst*    makeCmp3(ComparisonModifier mod, Type::Tag type, Opnd* dst, Opnd* src1, Opnd* src2);
    // Control flow
    Inst*    makeBranch(ComparisonModifier mod, Type::Tag, Opnd* src1, Opnd* src2, LabelInst* labelInst);
    Inst*    makeBranch(ComparisonModifier mod, Type::Tag, Opnd* src, LabelInst* labelInst);
    Inst*    makeJump(LabelInst* labelInst);
    Inst*    makeSwitch(Opnd* src, U_32 nLabels, LabelInst** labelInsts, LabelInst* defaultLabel);
    Inst*    makeDirectCall(Opnd* dst, 
                            Opnd* tauNullChecked, Opnd* tauTypesChecked,
                            U_32 numArgs, Opnd** args, 
                            MethodDesc*);
    Inst*    makeTauVirtualCall(Opnd* dst, 
                                Opnd* tauNullChecked, Opnd *tauTypesChecked,
                                U_32 numArgs, Opnd** args, 
                                MethodDesc*);
    Inst*    makeIndirectCall(Opnd* dst, Opnd* funPtr,
                              Opnd* tauNullCheckedFirstArg, Opnd *tauTypesChecked, 
                              U_32 numArgs, Opnd** args);
    Inst*    makeIndirectMemoryCall(Opnd* dst, Opnd* funPtr, 
                                    Opnd *tauNullCheckedFirstArg, 
                                    Opnd *tauTypesChecked,
                                    U_32 numArgs, Opnd** args);
    Inst*    makeJitHelperCall(Opnd* dst, JitHelperCallId id, 
                               Opnd* tauNullChecked, Opnd* tauTypesChecked, 
                               U_32 numArgs, Opnd** args);
    Inst*    makeVMHelperCall(Opnd* dst, VM_RT_SUPPORT id, U_32 numArgs,
                               Opnd** args);
    
    Inst*    makeIdentHC(Opnd* dst, Opnd* src);

    Inst*    makeReturn(Opnd* src);
    Inst*    makeReturn();    // void return type
    Inst*    makeCatch(Opnd* dst);
    Inst*    makeCatchLabel(U_32 labelId, U_32 exceptionOrder, Type* exceptionType);
    CatchLabelInst*    makeCatchLabel(U_32 exceptionOrder, Type* exceptionType);
    Inst*    makeThrow(ThrowModifier mod, Opnd* exceptionObj);
    Inst*    makePseudoThrow();
    Inst*    makeThrowSystemException(CompilationInterface::SystemExceptionId exceptionId);
    Inst*    makeThrowLinkingException(Class_Handle encClass, U_32 CPIndex, U_32 operation);
    Inst*    makeLeave(LabelInst* labelInst);
    Inst*    makeJSR(LabelInst* labelInst);
    Inst*    makeRet(Opnd *src);       // JSR-RET pair
    Inst*    makeSaveRet(Opnd *dst);   // JSR-RET pair
    // load, store, & mov
    Inst*    makeCopy(Opnd* dst, Opnd* src);
    Inst*    makeDefArg(Modifier, Opnd* arg);
    Inst*    makeLdConst(Opnd* dst, I_32 val);
    Inst*    makeLdConst(Opnd* dst, int64 val);
    Inst*    makeLdConst(Opnd* dst, float val);
    Inst*    makeLdConst(Opnd* dst, double val);
    Inst*    makeLdConst(Opnd* dst, ConstInst::ConstValue val);
    Inst*    makeLdNull(Opnd* dst);
    Inst*    makeLdRef(Modifier mod, Opnd* dst, MethodDesc* enclosingMethod, U_32 token);
    Inst*    makeLdVar(Opnd* dst, VarOpnd* var);
    Inst*    makeLdVar(Opnd* dst, SsaVarOpnd* var);
    Inst*    makeLdVarAddr(Opnd* dst, VarOpnd* var);
    Inst*    makeTauLdInd(Modifier, Type::Tag type, Opnd* dst, Opnd* ptr, 
                          Opnd *tauNonNullBase, Opnd *tauAddressInRange);
    Inst*    makeTauLdField(Modifier, Type* type, Opnd* dst, Opnd* base,
                            Opnd *tauNonNullBase, Opnd *tauObjectTypeChecked, 
                            FieldDesc*);
    Inst*    makeLdStatic(Modifier, Type* type, Opnd* dst, FieldDesc*);
    Inst*    makeTauLdElem(Modifier, Type* type, Opnd* dst, Opnd* array, Opnd* index,
                           Opnd *tauNonNullBase, Opnd *tauAddressInRange);
    Inst*    makeLdFieldAddr(Opnd* dst, Opnd* base, FieldDesc*);
    Inst*    makeLdStaticAddr(Opnd* dst, FieldDesc*);
    Inst*    makeLdElemAddr(Type* type, Opnd* dst, Opnd* array, Opnd* index);
    Inst*    makeTauLdVTableAddr(Opnd* dst, Opnd* base, Opnd *tauBaseNonNull);
    Inst*    makeTauLdIntfcVTableAddr(Opnd* dst, Opnd* base, Type* vtableType);
    Inst*    makeTauLdVirtFunAddr(Opnd* dst, Opnd* vtable, 
                                  Opnd *tauVtableHasDesc,
                                  MethodDesc*);
    Inst*    makeTauLdVirtFunAddrSlot(Opnd* dst, Opnd* vtable,
                                      Opnd *tauVtableHasDesc, MethodDesc*);
    Inst*    makeLdFunAddr(Opnd* dst, MethodDesc*);
    Inst*    makeLdFunAddrSlot(Opnd* dst, MethodDesc*);
    Inst*    makeGetVTableAddr(Opnd* dst, ObjectType *type);
    Inst*    makeGetClassObj(Opnd* dst, ObjectType *type);
    Inst*    makeTauArrayLen(Opnd* dst, Type::Tag type, Opnd* base, Opnd *tauBaseNonNull,
                             Opnd *tauBaseIsArray);
    Inst*    makeLdArrayBaseAddr(Type* type, Opnd* dst, Opnd* array);
    Inst*    makeAddScaledIndex(Opnd* dst, Opnd* base, Opnd* index);
    Inst*    makeStVar(VarOpnd* var, Opnd* src);
    Inst*    makeStVar(SsaVarOpnd* var, Opnd* src);
    Inst*    makeTauStInd(Modifier, Type::Tag, Opnd* src, Opnd* ptr, Opnd *tauNonNullBase,
                          Opnd *tauAddressInRange, Opnd *tauElemTypeChecked);
    Inst*    makeTauStField(Modifier, Type::Tag type, Opnd* src, Opnd* base,
                            Opnd *tauNonNullBase, Opnd *tauObjectHasField,
                            Opnd *tauFieldTypeChecked,
                            FieldDesc*);
    Inst*    makeTauStElem(Modifier, Type::Tag, Opnd* src, Opnd* array, Opnd* index,
                           Opnd *tauNonNullBase, Opnd *tauAddressInRange, 
                           Opnd *tauElemTypeChecked);
    Inst*    makeTauStStatic(Modifier, Type::Tag type, Opnd* src, 
                             Opnd *tauFieldTypeChecked, FieldDesc*);
    Inst*    makeTauStRef(Modifier, Type::Tag, Opnd* src, Opnd* pointer, Opnd* objectbase,
                       Opnd *tauNonNullBase, Opnd *tauAddressInRange, Opnd *tauElemTypeChecked);
    // checks
    Inst*    makeTauCheckBounds(Opnd *dst, Opnd* arrayLen, Opnd* index);
    Inst*    makeTauCheckLowerBound(Opnd *dst, Opnd* lb, Opnd* idx); // tests (lb <= idx);
    Inst*    makeTauCheckUpperBound(Opnd *dst, Opnd* idx, Opnd* ub); // tests (idx < ub);
    Inst*    makeTauCheckNull(Opnd* dst, Opnd* base);
    Inst*    makeTauCheckZero(Opnd* dst, Opnd* src);
    Inst*    makeTauCheckDivOpnds(Opnd* dst, Opnd* src1, Opnd* src2);
    Inst*    makeTauCheckElemType(Opnd* dst, Opnd* array, Opnd* src, Opnd *tauNullChecked,
                                  Opnd *tauIsArray);
    Inst*    makeTauCheckFinite(Opnd* dst, Opnd* src);
    // alloc
    Inst*    makeNewObj(Opnd* dst, Type* type);
    Inst*    makeNewArray(Opnd* dst, Opnd* numElems, Type* elemType);
    Inst*    makeNewMultiArray(Opnd* dst, U_32 dimensions, Opnd** numElems, Type* elemType);
    // sync
    Inst*    makeTauMonitorEnter(Opnd* src, Opnd *tauSrcNonNull);
    Inst*    makeTauMonitorExit(Opnd* src, Opnd *tauSrcNonNull);
    Inst*    makeTypeMonitorEnter(Type *type);
    Inst*    makeTypeMonitorExit(Type *type);
    // lowered parts of monitor enter/exit
    Inst*    makeLdLockAddr(Opnd *dst, Opnd *obj);   // result is ref:int16
    Inst*    makeIncRecCount(Opnd *obj, Opnd *oldValue);
    Inst*    makeTauBalancedMonitorEnter(Opnd* dst, Opnd *src, Opnd *lockAddr,
                                         Opnd *tauSrcNonNull); // result is I_32
    Inst*    makeBalancedMonitorExit(Opnd* src, Opnd *lockAddr, Opnd *enterDst);
    Inst*    makeTauOptimisticBalancedMonitorEnter(Opnd* dst, Opnd *src, Opnd *lockAddr,
                                                   Opnd *tauSrcNonNull); // result is I_32
    Inst*    makeOptimisticBalancedMonitorExit(Opnd* src, Opnd *lockAddr, Opnd *enterDst);
    Inst*    makeMonitorEnterFence(Opnd* src);  // elided MonitorEnter, just enforce memory model
    Inst*    makeMonitorExitFence(Opnd* src);   // elided MonitorExit, just enforce memory model
    // type checking
    Inst*    makeTauStaticCast(Opnd* dst, Opnd* src, Opnd *tauCastChecked, 
                               Type* type);
    Inst*    makeTauCast(Opnd* dst, Opnd* src, Opnd *tauNullChecked, Type* type);
    Inst*    makeTauAsType(Opnd* dst, Opnd* src, Opnd *tauNullChecked, Type* type);
    Inst*    makeTauInstanceOf(Opnd* dst, Opnd* src, Opnd *tauCheckedNull, Type* type);
    Inst*    makeInitType(Type* type);
    // labels
    LabelInst*  makeLabel();
    // method entry/exit
    LabelInst*    makeMethodEntryLabel(MethodDesc* methodDesc);
    Inst*    makeMethodMarker(MethodMarkerInst::Kind kind, MethodDesc* methodDesc, 
            Opnd *obj, Opnd *retOpnd);
    Inst*    makeMethodMarker(MethodMarkerInst::Kind kind, MethodDesc* methodDesc, Opnd *retOpnd);
    Inst*    makeMethodMarker(MethodMarkerInst::Kind kind, MethodDesc* methodDesc);


    // SSA
    Inst*    makePhi(Opnd* dst, U_32 numOpnds, Opnd** opnds); // array is copied
    Inst*    makeTauPi(Opnd* dst, Opnd* src, Opnd *tau, PiCondition *cond);

    // profile counter increment
    Inst*    makeIncCounter(U_32 val);
    Inst*    makePrefetch(Opnd* addr); // prefetch

    // compressed references
    Inst*    makeUncompressRef(Opnd* dst, Opnd* compref);
    Inst*    makeCompressRef(Opnd* dst, Opnd* uncompref);
    Inst*    makeLdFieldOffset(Opnd* dst, FieldDesc *fieldDesc);
    Inst*    makeLdFieldOffsetPlusHeapbase(Opnd* dst, FieldDesc *fieldDesc);
    Inst*    makeLdArrayBaseOffset(Opnd* dst, Type *elemType);
    Inst*    makeLdArrayBaseOffsetPlusHeapbase(Opnd* dst, Type *elemType);
    Inst*    makeLdArrayLenOffset(Opnd* dst, Type *elemType);
    Inst*    makeLdArrayLenOffsetPlusHeapbase(Opnd* dst, Type *elemType);
    Inst*    makeAddOffset(Opnd* dst, Opnd* ref, Opnd* offset);
    Inst*    makeAddOffsetPlusHeapbase(Opnd* dst, Opnd* ref, Opnd* offset);

    // new tau methods
    Inst*    makeTauPoint(Opnd *dst);
    Inst*    makeTauEdge(Opnd *dst);
    Inst*    makeTauAnd(Opnd *dst, U_32 numOpnds, Opnd** opnds); // array is copied
    Inst*    makeTauUnsafe(Opnd *dst);
    Inst*    makeTauSafe(Opnd *dst);
    Inst*    makeTauCheckCast(Opnd *taudst, Opnd* src, Opnd* tauCheckedNull, Type* type);
    Inst*    makeTauHasType(Opnd *taudst, Opnd* src, Type* type);
    Inst*    makeTauHasExactType(Opnd *taudst, Opnd* src, Type* type);
    Inst*    makeTauIsNonNull(Opnd *taudst, Opnd* src);
    
    //
    //
    //
    U_32   createLabelNumber()     {return maxNumLabels++; }
    U_32   getMaxNumLabels()       {return maxNumLabels;   }
    U_32   getNumInsts()           {return numInsts;       }
    
private:
    U_32   maxNumLabels;        // number of labels generated
    U_32   numInsts;            // number of instructions generated
    MemoryManager& memManager;

    //
    // Private constructor
    //
    // We only allow IRManager to create an InstFactory.
    //
    friend class IRManager;
    InstFactory(MemoryManager& mm, MethodDesc & md);

    //
    // private helpers for making different types of instructions
    //
    Opnd**  copyOpnds(Opnd** srcs, U_32 numSrcs);
    Opnd**  copyOpnds(Opnd* src1, Opnd** srcs, U_32 numSrcs);
    Opnd**  copyOpnds(Opnd* src1, Opnd* src2, Opnd** srcs, U_32 numSrcs);

    //
    // methods for copying instructions
    //
    friend class CloneVisitor;
    Inst*               makeClone(Inst*, OpndManager&, OpndRenameTable&);
    LabelInst*          makeClone(LabelInst*, OpndManager&, OpndRenameTable&);
    DispatchLabelInst*  makeClone(DispatchLabelInst*, OpndManager&, OpndRenameTable&);
    CatchLabelInst*     makeClone(CatchLabelInst*, OpndManager&, OpndRenameTable&);
    MethodEntryInst*    makeClone(MethodEntryInst*, OpndManager&, OpndRenameTable&);
    MethodMarkerInst*   makeClone(MethodMarkerInst*, OpndManager&, OpndRenameTable&);
    BranchInst*         makeClone(BranchInst*, OpndManager&, OpndRenameTable&);
    SwitchInst*         makeClone(SwitchInst*, OpndManager&, OpndRenameTable&);
    ConstInst*          makeClone(ConstInst*, OpndManager&, OpndRenameTable&);
    TokenInst*          makeClone(TokenInst*, OpndManager&, OpndRenameTable&);
    LinkingExcInst*     makeClone(LinkingExcInst*, OpndManager&, OpndRenameTable&);
    VarAccessInst*      makeClone(VarAccessInst*, OpndManager&, OpndRenameTable&);
    TypeInst*           makeClone(TypeInst*, OpndManager&, OpndRenameTable&);
    FieldAccessInst*    makeClone(FieldAccessInst*, OpndManager&, OpndRenameTable&);
    MethodInst*         makeClone(MethodInst*, OpndManager&, OpndRenameTable&);
    MethodCallInst*     makeClone(MethodCallInst*, OpndManager&, OpndRenameTable&);
    CallInst*           makeClone(CallInst*, OpndManager&, OpndRenameTable&);
    JitHelperCallInst*  makeClone(JitHelperCallInst*, OpndManager&, OpndRenameTable&);
    VMHelperCallInst*   makeClone(VMHelperCallInst*, OpndManager&, OpndRenameTable&);
    PhiInst*            makeClone(PhiInst*, OpndManager&, OpndRenameTable&);
    MultiSrcInst*       makeClone(MultiSrcInst*, OpndManager&, OpndRenameTable&);
public:
    Inst* makeInst(Opcode op, Modifier mod, Type::Tag, Opnd* dst);
    Inst* makeInst(Opcode op, Modifier mod, Type::Tag, Opnd* dst, Opnd* src);
    Inst* makeInst(Opcode op,
                   Modifier mod,
                   Type::Tag,
                   Opnd* dst,
                   Opnd* src1,
                   Opnd* src2);
    // add a new source at end of sources
    void appendSrc(MultiSrcInst*, Opnd *newSrc);

private:
    // makes a copy of a LabelInst
    LabelInst*          makeLabelInst(U_32 labelId);
    LabelInst*          makeLabelInst(Opcode opc, U_32 labelId);
    DispatchLabelInst*  makeDispatchLabelInst(U_32 labelId);
    CatchLabelInst*     makeCatchLabelInst(U_32 lableId,
                                       U_32 ord,
                                       Type *exceptionType);
    MethodEntryInst*    makeMethodEntryInst(U_32 labelId, MethodDesc*) ;
    MethodMarkerInst*   makeMethodMarkerInst(MethodMarkerInst::Kind, MethodDesc*, 
            Opnd *obj, Opnd *retOpnd);
    MethodMarkerInst*   makeMethodMarkerInst(MethodMarkerInst::Kind, MethodDesc*, Opnd *retOpnd);
    MethodMarkerInst*   makeMethodMarkerInst(MethodMarkerInst::Kind, MethodDesc*);

    BranchInst* makeBranchInst(Opcode, LabelInst* target);
    BranchInst* makeBranchInst(Opcode, Opnd *src, LabelInst* target);
    BranchInst* makeBranchInst(Opcode, ComparisonModifier mod, 
                               Type::Tag, Opnd* src, LabelInst* target);
    BranchInst* makeBranchInst(Opcode,
                               ComparisonModifier mod,
                               Type::Tag,
                               Opnd* src1,
                               Opnd* src2,
                               LabelInst* target);
    SwitchInst* makeSwitchInst(Opnd* src,
                               LabelInst** targets,
                               U_32 nTargets,
                               LabelInst* defTarget);
    ConstInst* makeConstInst(Opnd* dst, I_32 i4);
    ConstInst* makeConstInst(Opnd* dst, int64 i8) ;
    ConstInst* makeConstInst(Opnd* dst, float fs);
    ConstInst* makeConstInst(Opnd* dst, double fd) ;
    ConstInst* makeConstInst(Opnd* dst, ConstInst::ConstValue cv);
    ConstInst* makeConstInst(Opnd* dst);
    //
    // fix parameter names!
    //
    TokenInst* makeTokenInst(Opcode opc, Modifier mod, Type::Tag, Opnd* dst, U_32 t, MethodDesc* encMethod);
    LinkingExcInst* makeLinkingExcInst(Opcode opc, Modifier mod, Type::Tag type, Opnd* dst,
                                       Class_Handle encClass, U_32 CPIndex, U_32 operation);
    VarAccessInst* makeVarAccessInst(Opcode, Type::Tag, Opnd* dst, VarOpnd* var);
    VarAccessInst* makeVarAccessInst(Opcode, Type::Tag, VarOpnd* var, Opnd* src);
    VarAccessInst* makeVarAccessInst(Opcode, Type::Tag, Opnd* dst,
                                     SsaVarOpnd* var);
    VarAccessInst* makeVarAccessInst(Opcode, Type::Tag, SsaVarOpnd* var,
                                     Opnd* src);
    TypeInst* makeTypeInst(Opcode, Modifier mod, Type::Tag, Opnd* dst, Type*);
    TypeInst* makeTypeInst(Opcode, Modifier mod, Type::Tag, Opnd* dst, Opnd* src, Type*);
    TypeInst* makeTypeInst(Opcode,
                           Modifier mod,
                           Type::Tag,
                           Opnd* dst,
                           Opnd* src1,
                           Opnd* src2,
                           Type* td);
    TypeInst* makeTypeInst(Opcode,
                           Modifier mod,
                           Type::Tag,
                           Opnd* dst,
                           Opnd* src1,
                           Opnd* src2,
                           Opnd* src3,
                           Type* td);
    TypeInst* makeTypeInst(Opcode,
                           Modifier mod,
                           Type::Tag,
                           Opnd* dst,
                           Opnd* src1,
                           Opnd* src2,
                           Opnd* src3,
                           Opnd* src4,
                           Type* td);
    TypeInst* makeTypeInst(Opcode,
                           Modifier mod,
                           Type::Tag,
                           Opnd* dst,
                           U_32 nArgs,
                           Opnd** args,
                           Type*);
    FieldAccessInst* makeFieldAccessInst(Opcode, Modifier mod, Type::Tag, Opnd* dst, FieldDesc*);
    FieldAccessInst* makeFieldAccessInst(Opcode, Modifier mod, Type::Tag, Opnd* dst, Opnd* src, FieldDesc*);
    FieldAccessInst* makeFieldAccessInst(Opcode,
                                         Modifier mod,
                                         Type::Tag type,
                                         Opnd* dst,
                                         Opnd* src1,
                                         Opnd* src2,
                                         FieldDesc* fd);
    FieldAccessInst* makeFieldAccessInst(Opcode,
                                         Modifier mod,
                                         Type::Tag type,
                                         Opnd* dst,
                                         U_32 nSrcs,
                                         Opnd** srcs,
                                         FieldDesc* fd);
    MethodInst* makeMethodInst(Opcode, Modifier mod, Type::Tag type, Opnd* dst, MethodDesc* md);
    MethodInst* makeMethodInst(Opcode,
                               Modifier mod,
                               Type::Tag,
                               Opnd* dst,
                               U_32 nArgs,
                               MethodDesc*);
    MethodInst* makeMethodInst(Opcode,
                               Modifier mod,
                               Type::Tag type,
                               Opnd* dst,
                               Opnd* base,
                               MethodDesc*);
    MethodInst* makeMethodInst(Opcode,
                               Modifier mod,
                               Type::Tag type,
                               Opnd* dst,
                               Opnd* base,
                               Opnd* tauVtableHasMethod,
                               MethodDesc*);
    MethodInst* makeMethodInst(Opcode,
                               Modifier mod,
                               Type::Tag,
                               Opnd* dst,
                               U_32 nArgs,
                               Opnd** args_,
                               MethodDesc*);
    MethodCallInst* makeMethodCallInst(Opcode,
                                       Modifier mod,
                                       Type::Tag,
                                       Opnd* dst,
                                       U_32 nArgs,
                                       Opnd** args_,
                                       MethodDesc*);
    CallInst* makeCallInst(Opcode op, Modifier mod,
                           Type::Tag,
                           Opnd* dst,
                           Opnd* ptr,
                           U_32 nArgs,
                           Opnd** args);
    JitHelperCallInst* makeJitHelperCallInst(Opcode op, 
                                             Modifier mod,
                                             Type::Tag,
                                             Opnd* dst,
                                             U_32 nArgs,
                                             Opnd** args_,
                                             JitHelperCallId id);
    VMHelperCallInst* makeVMHelperCallInst(Opcode op, 
                                           Modifier mod,
                                           Type::Tag,
                                           Opnd* dst,
                                           U_32 nArgs,
                                           Opnd** args_,
                                           VM_RT_SUPPORT id);


    PhiInst* makePhiInst(Type::Tag type, Opnd* dst, U_32 nArgs, Opnd** args_);

    MultiSrcInst* makeMultiSrcInst(Opcode, Modifier mod, Type::Tag, Opnd* dst);
    MultiSrcInst* makeMultiSrcInst(Opcode, Modifier mod, Type::Tag, Opnd* dst, Opnd* src);
    MultiSrcInst* makeMultiSrcInst(Opcode, Modifier mod, Type::Tag, Opnd* dst, Opnd* src1, Opnd* src2);
    MultiSrcInst* makeMultiSrcInst(Opcode, Modifier mod, Type::Tag, Opnd* dst, Opnd* src1, Opnd* src2, Opnd* src3);
    MultiSrcInst* makeMultiSrcInst(Opcode, Modifier mod, Type::Tag, Opnd* dst, Opnd* src1, Opnd* src2, Opnd* src3, Opnd* src4);
    MultiSrcInst* makeMultiSrcInst(Opcode, Modifier mod, Type::Tag, Opnd* dst, U_32 nSrcs, Opnd** srcs);
};

//
// Basic container class for instructions
//
class InstDeque : StlDeque<Inst*> {
public:
    InstDeque(MemoryManager& mm) : StlDeque<Inst*>(mm) {}
    bool  isEmpty() const       {return empty();}
    Inst* popFront()            {Inst* inst=front();pop_front();return inst;}
    Inst* popBack()             {Inst* inst=back();pop_back();return inst;}
    void  pushFront(Inst* inst) {push_front(inst);}
    void  pushBack(Inst* inst)  {push_back(inst);}
};


class InstOptimizer {
public:
    virtual ~InstOptimizer() {}
    // returns 0 or an optimized version of inst;
    virtual Inst*
    optimizeInst(Inst* inst) {
        return dispatch(inst);
    }
    // Numeric compute
    virtual Inst*
    caseAdd(Inst* inst)=0; //              {return caseDefault(inst);}

    virtual Inst*
    caseMul(Inst* inst)=0; //                 {return caseDefault(inst);}

    virtual Inst*
    caseSub(Inst* inst)=0; //                 {return caseDefault(inst);}

    virtual Inst*
    caseTauDiv(Inst* inst)=0;//              {return caseDefault(inst);}

    virtual Inst*
    caseTauRem(Inst* inst)=0; //                 {return caseDefault(inst);}

    virtual Inst*
    caseNeg(Inst* inst)=0; //                 {return caseDefault(inst);}

    virtual Inst*
    caseMulHi(Inst* inst)=0;//               {return caseDefault(inst);}

    virtual Inst*
    caseMin(Inst* inst)=0;//                 {return caseDefault(inst);}

    virtual Inst*
    caseMax(Inst* inst)=0;//                 {return caseDefault(inst);}

    virtual Inst*
    caseAbs(Inst* inst)=0;//                 {return caseDefault(inst);}

    // Bitwise
    virtual Inst*
    caseAnd(Inst* inst)=0;//                 {return caseDefault(inst);}

    virtual Inst*
    caseOr(Inst* inst)=0;//                  {return caseDefault(inst);}

    virtual Inst*
    caseXor(Inst* inst)=0;//                 {return caseDefault(inst);}

    virtual Inst*
    caseNot(Inst* inst)=0;//                 {return caseDefault(inst);}

    // selection
    virtual Inst*
    caseSelect(Inst* inst)=0;//              {return caseDefault(inst);}

    // conversion
    virtual Inst*
    caseConv(Inst* inst)=0;//                {return caseDefault(inst);}

    // conversion
    virtual Inst*
    caseConvZE(Inst* inst)=0;//                {return caseDefault(inst);}

    // conversion
    virtual Inst*
    caseConvUnmanaged(Inst* inst)=0;//                {return caseDefault(inst);}

    // shifts
    virtual Inst*
    caseShladd(Inst* inst)=0;//                 {return caseDefault(inst);}

    virtual Inst*
    caseShl(Inst* inst)=0;//                 {return caseDefault(inst);}

    virtual Inst*
    caseShr(Inst* inst)=0;//                 {return caseDefault(inst);}

    // comparison
    virtual Inst*
    caseCmp(Inst* inst)=0;//                {return caseDefault(inst);}

    virtual Inst*
    caseCmp3(Inst* inst)=0;//               {return caseDefault(inst);}

    // Control flow
    virtual Inst*
    caseBranch(BranchInst* inst)=0;//       {return caseDefault(inst);}

    virtual Inst*
    caseJump(BranchInst* inst)=0;//         {return caseDefault(inst);}

    virtual Inst*
    caseSwitch(SwitchInst* inst)=0;//       {return caseDefault(inst);}

    virtual Inst*
    caseDirectCall(MethodCallInst* inst)=0;//  {return caseDefault(inst);}

    virtual Inst*
    caseTauVirtualCall(MethodCallInst* inst)=0;// {return caseDefault(inst);}

    virtual Inst*
    caseIndirectCall(CallInst* inst)=0;//   {return caseDefault(inst);}

    virtual Inst*
    caseIndirectMemoryCall(CallInst* inst)=0;//{return caseDefault(inst);}

    virtual Inst*
    caseJitHelperCall(JitHelperCallInst* inst)=0;//{return caseDefault(inst);}

    virtual Inst*
    caseVMHelperCall(VMHelperCallInst* inst)=0;//{return caseDefault(inst);}

    virtual Inst*
    caseReturn(Inst* inst)=0;//             {return caseDefault(inst);}

    virtual Inst*
    caseCatch(Inst* inst)=0;//              {return caseDefault(inst);}

    virtual Inst*
    caseThrow(Inst* inst)=0;//              {return caseDefault(inst);}

    virtual Inst*
    casePseudoThrow(Inst* inst)=0;//        {return caseDefault(inst);}

    virtual Inst*
    caseThrowSystemException(Inst* inst)=0;// {return caseDefault(inst);}

    virtual Inst*
    caseThrowLinkingException(Inst* inst)=0;// {return caseDefault(inst);}

    virtual Inst*
    caseLeave(Inst* inst)=0;//              {return caseDefault(inst);}

    virtual Inst*
    caseJSR(Inst* inst)=0;//          {return caseDefault(inst);}

    virtual Inst*
    caseRet(Inst* inst)=0;//                {return caseDefault(inst);}

    virtual Inst*
    caseSaveRet(Inst* inst)=0;//            {return caseDefault(inst);}

    // load, store & mov
    virtual Inst*
    caseCopy(Inst* inst)=0;//               {return caseDefault(inst);}

    virtual Inst*
    caseDefArg(Inst* inst)=0;//             {return caseDefault(inst);}

    virtual Inst*
    caseLdConstant(ConstInst* inst)=0;//    {return caseDefault(inst);}

    virtual Inst*
    caseLdNull(ConstInst* inst)=0;//        {return caseDefault(inst);}

    virtual Inst*
    caseLdRef(TokenInst* inst)=0;//         {return caseDefault(inst);}

    virtual Inst*
    caseLdVar(Inst* inst)=0;//              {return caseDefault(inst);}

    virtual Inst*
    caseLdVarAddr(Inst* inst)=0;//          {return caseDefault(inst);}

    virtual Inst*
    caseTauLdInd(Inst* inst)=0;//         {return caseDefault(inst);}

    virtual Inst*
    caseTauLdField(FieldAccessInst* inst)=0;//{return caseDefault(inst);}

    virtual Inst*
    caseLdStatic(FieldAccessInst* inst)=0;//{return caseDefault(inst);}

    virtual Inst*
    caseTauLdElem(TypeInst* inst)=0;//             {return caseDefault(inst);}

    virtual Inst*
    caseLdFieldAddr(FieldAccessInst* inst)=0;//{return caseDefault(inst);}

    virtual Inst*
    caseLdStaticAddr(FieldAccessInst* inst)=0;//{return caseDefault(inst);}

    virtual Inst*
    caseLdElemAddr(TypeInst* inst)=0;//         {return caseDefault(inst);}

    virtual Inst*
    caseTauLdVTableAddr(Inst* inst)=0;//       {return caseDefault(inst);}

    virtual Inst*
    caseTauLdIntfcVTableAddr(TypeInst* inst)=0;//{return caseDefault(inst);}

    virtual Inst*
    caseTauLdVirtFunAddr(MethodInst* inst)=0;//{return caseDefault(inst);}

    virtual Inst*
    caseTauLdVirtFunAddrSlot(MethodInst* inst)=0;//{return caseDefault(inst);}

    virtual Inst*
    caseLdFunAddr(MethodInst* inst)=0;//    {return caseDefault(inst);}

    virtual Inst*
    caseLdFunAddrSlot(MethodInst* inst)=0;//{return caseDefault(inst);}

    virtual Inst*
    caseGetVTableAddr(TypeInst* inst)=0;//      {return caseDefault(inst);}

    virtual Inst*
    caseGetClassObj(TypeInst* inst)=0;//      {return caseDefault(inst);}

    virtual Inst*
    caseTauArrayLen(Inst* inst)=0;//           {return caseDefault(inst);}

    virtual Inst*
    caseLdArrayBaseAddr(Inst* inst)=0;//    {return caseDefault(inst);}

    virtual Inst*
    caseAddScaledIndex(Inst* inst)=0;// {return caseDefault(inst);}

    virtual Inst*
    caseStVar(Inst* inst)=0;//              {return caseDefault(inst);}

    virtual Inst*
    caseTauStInd(Inst* inst)=0;//         {return caseDefault(inst);}

    virtual Inst*
    caseTauStField(Inst* inst)=0;//            {return caseDefault(inst);}

    virtual Inst*
    caseTauStElem(Inst* inst)=0;//             {return caseDefault(inst);}

    virtual Inst*
    caseTauStStatic(Inst* inst)=0;//           {return caseDefault(inst);}

    virtual Inst*
    caseTauStRef(Inst* inst)=0;//              {return caseDefault(inst);}

    // checks
    virtual Inst*
    caseTauCheckBounds(Inst* inst)=0;//        {return caseDefault(inst);}

    virtual Inst*
    caseTauCheckLowerBound(Inst* inst)=0;//      {return caseDefault(inst);}

    virtual Inst*
    caseTauCheckUpperBound(Inst* inst)=0;//      {return caseDefault(inst);}

    virtual Inst*
    caseTauCheckNull(Inst* inst)=0;//          {return caseDefault(inst);}

    virtual Inst*
    caseTauCheckZero(Inst* inst)=0;//          {return caseDefault(inst);}

    virtual Inst*
    caseTauCheckDivOpnds(Inst* inst)=0;//      {return caseDefault(inst);}
    
    virtual Inst*
    caseTauCheckElemType(Inst* inst)=0;//      {return caseDefault(inst);}

    virtual Inst*
    caseTauCheckFinite(Inst* inst)=0;//         {return caseDefault(inst);}

    // alloc

    virtual Inst*
    caseNewObj(Inst* inst)=0;//             {return caseDefault(inst);}

    virtual Inst*
    caseNewArray(Inst* inst)=0;//           {return caseDefault(inst);}

    virtual Inst*
    caseNewMultiArray(Inst* inst)=0;//      {return caseDefault(inst);}

    // sync

    virtual Inst*
    caseTauMonitorEnter(Inst* inst)=0;//       {return caseDefault(inst);}

    virtual Inst*
    caseTauMonitorExit(Inst* inst)=0;//        {return caseDefault(inst);}

    virtual Inst*
    caseTypeMonitorEnter(Inst* inst)=0;//   {return caseDefault(inst);}

    virtual Inst*
    caseTypeMonitorExit(Inst* inst)=0;//    {return caseDefault(inst);}

    virtual Inst*
    caseLdLockAddr(Inst* inst)=0;//       {return caseDefault(inst);}

    virtual Inst*
    caseIncRecCount(Inst* inst)=0;//       {return caseDefault(inst);}

    virtual Inst*
    caseTauBalancedMonitorEnter(Inst* inst)=0;//       {return caseDefault(inst);}

    virtual Inst*
    caseBalancedMonitorExit(Inst* inst)=0;//        {return caseDefault(inst);}

    virtual Inst*
    caseTauOptimisticBalancedMonitorEnter(Inst* inst)=0;//{return caseDefault(inst);}

    virtual Inst*
    caseOptimisticBalancedMonitorExit(Inst* inst)=0;// {return caseDefault(inst);}

    virtual Inst*
    caseMonitorEnterFence(Inst* inst)=0;//       {return caseDefault(inst);}

    virtual Inst*
    caseMonitorExitFence(Inst* inst)=0;//        {return caseDefault(inst);}

    // type checking
    virtual Inst*
    caseTauStaticCast(TypeInst* inst)=0;//     {return caseDefault(inst);}

    virtual Inst*
    caseTauCast(TypeInst* inst)=0;//           {return caseDefault(inst);}

    virtual Inst*
    caseSizeof(TypeInst* inst)=0;//         {return caseDefault(inst);}

    virtual Inst*
    caseTauAsType(TypeInst* inst)=0;//         {return caseDefault(inst);}

    virtual Inst*
    caseTauInstanceOf(TypeInst* inst)=0;//     {return caseDefault(inst);}

    virtual Inst*
    caseInitType(TypeInst* inst)=0;//       {return caseDefault(inst);}

    // labels

    virtual Inst*
    caseLabel(Inst* inst)=0;//              {return caseDefault(inst);}

    // type checking
    virtual Inst*
    caseCatchLabelInst(Inst* inst)=0;//     {return caseDefault(inst);}

    // method entry/exit
    virtual Inst*
    caseMethodEntryLabel(Inst* inst)=0;//   {return caseDefault(inst);}

    virtual Inst*
    caseMethodEntry(Inst* inst)=0;//        {return caseDefault(inst);}

    virtual Inst*
    caseMethodEnd(Inst* inst)=0;//          {return caseDefault(inst);}

    // source markers
    virtual Inst*
    caseMethodMarker(Inst* inst)=0;//       {return caseDefault(inst);}

    virtual Inst*
    casePhi(Inst* inst)=0;//                {return caseDefault(inst);}

    virtual Inst*
    caseTauPi(TauPiInst* inst)=0;//                 {return caseDefault(inst);}

    virtual Inst*
    caseIncCounter(Inst* inst)=0;//         {return caseDefault(inst);}

    virtual Inst*
    casePrefetch(Inst* inst)=0;//         {return caseDefault(inst);}

    // compressed references

    virtual Inst*
    caseUncompressRef(Inst* inst)=0;// {return caseDefault(inst);}

    virtual Inst*
    caseCompressRef(Inst* inst)=0;// {return caseDefault(inst);}

    virtual Inst*
    caseLdFieldOffset(Inst* inst)=0;// {return caseDefault(inst);}

    virtual Inst*
    caseLdFieldOffsetPlusHeapbase(Inst* inst)=0;// {return caseDefault(inst);}

    virtual Inst*
    caseLdArrayBaseOffset(Inst* inst)=0;// {return caseDefault(inst);}

    virtual Inst*
    caseLdArrayBaseOffsetPlusHeapbase(Inst* inst)=0;// {return caseDefault(inst);}

    virtual Inst*
    caseLdArrayLenOffset(Inst* inst)=0;// {return caseDefault(inst);}

    virtual Inst*
    caseLdArrayLenOffsetPlusHeapbase(Inst* inst)=0;// {return caseDefault(inst);}

    virtual Inst*
    caseAddOffset(Inst* inst)=0;// {return caseDefault(inst);}

    virtual Inst*
    caseAddOffsetPlusHeapbase(Inst* inst)=0;// {return caseDefault(inst);}

    // new tau methods
    virtual Inst*
    caseTauPoint(Inst* inst)=0;//         {return caseDefault(inst);}

    virtual Inst*
    caseTauEdge(Inst* inst)=0;//         {return caseDefault(inst);}

    virtual Inst*
    caseTauAnd(Inst* inst)=0;//         {return caseDefault(inst);}

    virtual Inst*
    caseTauSafe(Inst* inst)=0;//         {return caseDefault(inst);}

    virtual Inst*
    caseTauUnsafe(Inst* inst)=0;//         {return caseDefault(inst);}

    virtual Inst*
    caseTauCheckCast(TypeInst* inst)=0;//         {return caseDefault(inst);}

    virtual Inst*
    caseTauHasType(TypeInst* inst)=0;//         {return caseDefault(inst);}

    virtual Inst*
    caseTauHasExactType(TypeInst* inst)=0;//         {return caseDefault(inst);}

    virtual Inst*
    caseTauIsNonNull(Inst* inst)=0;//         {return caseDefault(inst);}

    virtual Inst*
    caseIdentHC(Inst* inst)=0;//         {return caseDefault(inst);}
    
    virtual Inst*
    caseDefault(Inst* inst)=0;//            {return NULL;}

protected:
    Inst* dispatch(Inst*);

};

} //namespace Jitrino 

#endif // _INST_H_