← Back to branch summary

~ubuntu-branches/ubuntu/feisty/clamav/feisty

« back to all changes in this revision

Viewing changes to libclamav/c++/llvm/include/llvm/MC/MCInst.h

  • Committer: Bazaar Package Importer
  • Author(s): Kees Cook
  • Date: 2007-02-20 10:33:44 UTC
  • mto: This revision was merged to the branch mainline in revision 16.
  • Revision ID: james.westby@ubuntu.com-20070220103344-zgcu2psnx9d98fpa
Tags: upstream-0.90
Import upstream version 0.90

Show diffs side-by-side

added added

removed removed

Lines of Context:
libclamav/c++/llvm/include/llvm/MC/MCInst.h
1
 
//===-- llvm/MC/MCInst.h - MCInst class -------------------------*- C++ -*-===//
2
 
//
3
 
//                     The LLVM Compiler Infrastructure
4
 
//
5
 
// This file is distributed under the University of Illinois Open Source
6
 
// License. See LICENSE.TXT for details.
7
 
//
8
 
//===----------------------------------------------------------------------===//
9
 
//
10
 
// This file contains the declaration of the MCInst and MCOperand classes, which
11
 
// is the basic representation used to represent low-level machine code
12
 
// instructions.
13
 
//
14
 
//===----------------------------------------------------------------------===//
15
 
 
16
 
#ifndef LLVM_MC_MCINST_H
17
 
#define LLVM_MC_MCINST_H
18
 
 
19
 
#include "llvm/ADT/SmallVector.h"
20
 
#include "llvm/ADT/StringRef.h"
21
 
#include "llvm/System/DataTypes.h"
22
 
 
23
 
namespace llvm {
24
 
class raw_ostream;
25
 
class MCAsmInfo;
26
 
class MCInstPrinter;
27
 
class MCExpr;
28
 
 
29
 
/// MCOperand - Instances of this class represent operands of the MCInst class.
30
 
/// This is a simple discriminated union.
31
 
class MCOperand {
32
 
  enum MachineOperandType {
33
 
    kInvalid,                 ///< Uninitialized.
34
 
    kRegister,                ///< Register operand.
35
 
    kImmediate,               ///< Immediate operand.
36
 
    kExpr                     ///< Relocatable immediate operand.
37
 
  };
38
 
  unsigned char Kind;
39
 
  
40
 
  union {
41
 
    unsigned RegVal;
42
 
    int64_t ImmVal;
43
 
    const MCExpr *ExprVal;
44
 
  };
45
 
public:
46
 
  
47
 
  MCOperand() : Kind(kInvalid) {}
48
 
 
49
 
  bool isValid() const { return Kind != kInvalid; }
50
 
  bool isReg() const { return Kind == kRegister; }
51
 
  bool isImm() const { return Kind == kImmediate; }
52
 
  bool isExpr() const { return Kind == kExpr; }
53
 
  
54
 
  /// getReg - Returns the register number.
55
 
  unsigned getReg() const {
56
 
    assert(isReg() && "This is not a register operand!");
57
 
    return RegVal;
58
 
  }
59
 
 
60
 
  /// setReg - Set the register number.
61
 
  void setReg(unsigned Reg) {
62
 
    assert(isReg() && "This is not a register operand!");
63
 
    RegVal = Reg;
64
 
  }
65
 
  
66
 
  int64_t getImm() const {
67
 
    assert(isImm() && "This is not an immediate");
68
 
    return ImmVal;
69
 
  }
70
 
  void setImm(int64_t Val) {
71
 
    assert(isImm() && "This is not an immediate");
72
 
    ImmVal = Val;
73
 
  }
74
 
  
75
 
  const MCExpr *getExpr() const {
76
 
    assert(isExpr() && "This is not an expression");
77
 
    return ExprVal;
78
 
  }
79
 
  void setExpr(const MCExpr *Val) {
80
 
    assert(isExpr() && "This is not an expression");
81
 
    ExprVal = Val;
82
 
  }
83
 
  
84
 
  static MCOperand CreateReg(unsigned Reg) {
85
 
    MCOperand Op;
86
 
    Op.Kind = kRegister;
87
 
    Op.RegVal = Reg;
88
 
    return Op;
89
 
  }
90
 
  static MCOperand CreateImm(int64_t Val) {
91
 
    MCOperand Op;
92
 
    Op.Kind = kImmediate;
93
 
    Op.ImmVal = Val;
94
 
    return Op;
95
 
  }
96
 
  static MCOperand CreateExpr(const MCExpr *Val) {
97
 
    MCOperand Op;
98
 
    Op.Kind = kExpr;
99
 
    Op.ExprVal = Val;
100
 
    return Op;
101
 
  }
102
 
 
103
 
  void print(raw_ostream &OS, const MCAsmInfo *MAI) const;
104
 
  void dump() const;
105
 
};
106
 
 
107
 
  
108
 
/// MCInst - Instances of this class represent a single low-level machine
109
 
/// instruction. 
110
 
class MCInst {
111
 
  unsigned Opcode;
112
 
  SmallVector<MCOperand, 8> Operands;
113
 
public:
114
 
  MCInst() : Opcode(0) {}
115
 
  
116
 
  void setOpcode(unsigned Op) { Opcode = Op; }
117
 
  
118
 
  unsigned getOpcode() const { return Opcode; }
119
 
 
120
 
  const MCOperand &getOperand(unsigned i) const { return Operands[i]; }
121
 
  MCOperand &getOperand(unsigned i) { return Operands[i]; }
122
 
  unsigned getNumOperands() const { return Operands.size(); }
123
 
  
124
 
  void addOperand(const MCOperand &Op) {
125
 
    Operands.push_back(Op);
126
 
  }
127
 
 
128
 
  void print(raw_ostream &OS, const MCAsmInfo *MAI) const;
129
 
  void dump() const;
130
 
 
131
 
  /// \brief Dump the MCInst as prettily as possible using the additional MC
132
 
  /// structures, if given. Operators are separated by the \arg Separator
133
 
  /// string.
134
 
  void dump_pretty(raw_ostream &OS, const MCAsmInfo *MAI = 0,
135
 
                   const MCInstPrinter *Printer = 0,
136
 
                   StringRef Separator = " ") const;
137
 
};
138
 
 
139
 
 
140
 
} // end namespace llvm
141
 
 
142
 
#endif