//===-- llvm/MC/MCInst.h - MCInst class -------------------------*- C++ -*-===//
//
//                     The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file contains the declaration of the MCInst and MCOperand classes, which
// is the basic representation used to represent low-level machine code
// instructions.
//
//===----------------------------------------------------------------------===//

#ifndef LLVM_MC_MCINST_H
#define LLVM_MC_MCINST_H

#include "llvm/MC/MCValue.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/Support/DataTypes.h"
#include "llvm/Support/DebugLoc.h"

namespace llvm {

/// MCOperand - Instances of this class represent operands of the MCInst class.
/// This is a simple discriminated union.
class MCOperand {
  enum MachineOperandType {
    kInvalid,                 ///< Uninitialized.
    kRegister,                ///< Register operand.
    kImmediate,               ///< Immediate operand.
    kMBBLabel,                ///< Basic block label.
    kMCValue                  ///< Relocatable immediate operand.
  };
  unsigned char Kind;
  
  union {
    unsigned RegVal;
    int64_t ImmVal;
    MCValue MCValueVal;
    struct {
      unsigned FunctionNo;
      unsigned BlockNo;
    } MBBLabel;
  };
public:
  
  MCOperand() : Kind(kInvalid) {}
  MCOperand(const MCOperand &RHS) { *this = RHS; }

  bool isValid() const { return Kind != kInvalid; }
  bool isReg() const { return Kind == kRegister; }
  bool isImm() const { return Kind == kImmediate; }
  bool isMBBLabel() const { return Kind == kMBBLabel; }
  bool isMCValue() const { return Kind == kMCValue; }
  
  /// getReg - Returns the register number.
  unsigned getReg() const {
    assert(isReg() && "This is not a register operand!");
    return RegVal;
  }

  /// setReg - Set the register number.
  void setReg(unsigned Reg) {
    assert(isReg() && "This is not a register operand!");
    RegVal = Reg;
  }
  
  int64_t getImm() const {
    assert(isImm() && "This is not an immediate");
    return ImmVal;
  }
  void setImm(int64_t Val) {
    assert(isImm() && "This is not an immediate");
    ImmVal = Val;
  }
  
  unsigned getMBBLabelFunction() const {
    assert(isMBBLabel() && "Wrong accessor");
    return MBBLabel.FunctionNo; 
  }
  unsigned getMBBLabelBlock() const {
    assert(isMBBLabel() && "Wrong accessor");
    return MBBLabel.BlockNo; 
  }

  const MCValue &getMCValue() const {
    assert(isMCValue() && "This is not an MCValue");
    return MCValueVal;
  }
  void setMCValue(const MCValue &Val) {
    assert(isMCValue() && "This is not an MCValue");
    MCValueVal = Val;
  }
  
  static MCOperand CreateReg(unsigned Reg) {
    MCOperand Op;
    Op.Kind = kRegister;
    Op.RegVal = Reg;
    return Op;
  }
  static MCOperand CreateImm(int64_t Val) {
    MCOperand Op;
    Op.Kind = kImmediate;
    Op.ImmVal = Val;
    return Op;
  }
  static MCOperand CreateMBBLabel(unsigned Fn, unsigned MBB) {
    MCOperand Op;
    Op.Kind = kMBBLabel;
    Op.MBBLabel.FunctionNo = Fn;
    Op.MBBLabel.BlockNo = MBB;
    return Op;
  }
  static MCOperand CreateMCValue(const MCValue &Val) {
    MCOperand Op;
    Op.Kind = kMCValue;
    Op.MCValueVal = Val;
    return Op;
  }
};

  
/// MCInst - Instances of this class represent a single low-level machine
/// instruction. 
class MCInst {
  unsigned Opcode;
  SmallVector<MCOperand, 8> Operands;
public:
  MCInst() : Opcode(~0U) {}
  
  void setOpcode(unsigned Op) { Opcode = Op; }
  
  unsigned getOpcode() const { return Opcode; }
  DebugLoc getDebugLoc() const { return DebugLoc(); }
  
  const MCOperand &getOperand(unsigned i) const { return Operands[i]; }
  MCOperand &getOperand(unsigned i) { return Operands[i]; }
  unsigned getNumOperands() const { return Operands.size(); }
  
  void addOperand(const MCOperand &Op) {
    Operands.push_back(Op);
  }
};


} // end namespace llvm

#endif
