Operator.h revision f2411744214dad8c71044aac2977ca77e9ebf028 
1//===-- llvm/Operator.h - Operator utility subclass -------------*- 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 defines various classes for working with Instructions and
11// ConstantExprs.
12//
13//===----------------------------------------------------------------------===//
14
15#ifndef LLVM_OPERATOR_H
16#define LLVM_OPERATOR_H
17
18#include "llvm/Instruction.h"
19#include "llvm/Constants.h"
20
21namespace llvm {
22
23/// Operator - This is a utility class that provides an abstraction for the
24/// common functionality between Instructions and ConstantExprs.
25///
26class Operator : public User {
27private:
28  // Do not implement any of these. The Operator class is intended to be used
29  // as a utility, and is never itself instantiated.
30  void *operator new(size_t, unsigned);
31  void *operator new(size_t s);
32  Operator();
33  ~Operator();
34
35public:
36  /// getOpcode - Return the opcode for this Instruction or ConstantExpr.
37  ///
38  unsigned getOpcode() const {
39    if (const Instruction *I = dyn_cast<Instruction>(this))
40      return I->getOpcode();
41    return cast<ConstantExpr>(this)->getOpcode();
42  }
43
44  /// getOpcode - If V is an Instruction or ConstantExpr, return its
45  /// opcode. Otherwise return UserOp1.
46  ///
47  static unsigned getOpcode(const Value *V) {
48    if (const Instruction *I = dyn_cast<Instruction>(V))
49      return I->getOpcode();
50    if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(V))
51      return CE->getOpcode();
52    return Instruction::UserOp1;
53  }
54
55  static inline bool classof(const Operator *) { return true; }
56  static inline bool classof(const Instruction *I) { return true; }
57  static inline bool classof(const ConstantExpr *I) { return true; }
58  static inline bool classof(const Value *V) {
59    return isa<Instruction>(V) || isa<ConstantExpr>(V);
60  }
61};
62
63/// OverflowingBinaryOperator - Utility class for integer arithmetic operators
64/// which may exhibit overflow - Add, Sub, and Mul.
65///
66class OverflowingBinaryOperator : public Operator {
67public:
68  /// hasNoSignedOverflow - Test whether this operation is known to never
69  /// undergo signed overflow.
70  bool hasNoSignedOverflow() const {
71    return SubclassOptionalData & (1 << 0);
72  }
73  void setHasNoSignedOverflow(bool B) {
74    SubclassOptionalData = (SubclassOptionalData & ~(1 << 0)) | (B << 0);
75  }
76
77  /// hasNoUnsignedOverflow - Test whether this operation is known to never
78  /// undergo unsigned overflow.
79  bool hasNoUnsignedOverflow() const {
80    return SubclassOptionalData & (1 << 1);
81  }
82  void setHasNoUnsignedOverflow(bool B) {
83    SubclassOptionalData = (SubclassOptionalData & ~(1 << 1)) | (B << 1);
84  }
85
86  static inline bool classof(const OverflowingBinaryOperator *) { return true; }
87  static inline bool classof(const Instruction *I) {
88    return I->getOpcode() == Instruction::Add ||
89           I->getOpcode() == Instruction::Sub ||
90           I->getOpcode() == Instruction::Mul;
91  }
92  static inline bool classof(const ConstantExpr *CE) {
93    return CE->getOpcode() == Instruction::Add ||
94           CE->getOpcode() == Instruction::Sub ||
95           CE->getOpcode() == Instruction::Mul;
96  }
97  static inline bool classof(const Value *V) {
98    return (isa<Instruction>(V) && classof(cast<Instruction>(V))) ||
99           (isa<ConstantExpr>(V) && classof(cast<ConstantExpr>(V)));
100  }
101};
102
103/// UDivOperator - An Operator with opcode Instruction::UDiv.
104///
105class UDivOperator : public Operator {
106public:
107  /// isExact - Test whether this division is known to be exact, with
108  /// zero remainder.
109  bool isExact() const {
110    return SubclassOptionalData & (1 << 0);
111  }
112  void setIsExact(bool B) {
113    SubclassOptionalData = (SubclassOptionalData & ~(1 << 0)) | (B << 0);
114  }
115
116  // Methods for support type inquiry through isa, cast, and dyn_cast:
117  static inline bool classof(const UDivOperator *) { return true; }
118  static inline bool classof(const ConstantExpr *CE) {
119    return CE->getOpcode() == Instruction::UDiv;
120  }
121  static inline bool classof(const Instruction *I) {
122    return I->getOpcode() == Instruction::UDiv;
123  }
124  static inline bool classof(const Value *V) {
125    return (isa<Instruction>(V) && classof(cast<Instruction>(V))) ||
126           (isa<ConstantExpr>(V) && classof(cast<ConstantExpr>(V)));
127  }
128};
129
130class GEPOperator : public Operator {
131public:
132  inline op_iterator       idx_begin()       { return op_begin()+1; }
133  inline const_op_iterator idx_begin() const { return op_begin()+1; }
134  inline op_iterator       idx_end()         { return op_end(); }
135  inline const_op_iterator idx_end()   const { return op_end(); }
136
137  Value *getPointerOperand() {
138    return getOperand(0);
139  }
140  const Value *getPointerOperand() const {
141    return getOperand(0);
142  }
143  static unsigned getPointerOperandIndex() {
144    return 0U;                      // get index for modifying correct operand
145  }
146
147  /// getPointerOperandType - Method to return the pointer operand as a
148  /// PointerType.
149  const PointerType *getPointerOperandType() const {
150    return reinterpret_cast<const PointerType*>(getPointerOperand()->getType());
151  }
152
153  unsigned getNumIndices() const {  // Note: always non-negative
154    return getNumOperands() - 1;
155  }
156
157  bool hasIndices() const {
158    return getNumOperands() > 1;
159  }
160
161  /// hasAllZeroIndices - Return true if all of the indices of this GEP are
162  /// zeros.  If so, the result pointer and the first operand have the same
163  /// value, just potentially different types.
164  bool hasAllZeroIndices() const {
165    for (const_op_iterator I = idx_begin(), E = idx_end(); I != E; ++I) {
166      if (Constant *C = dyn_cast<Constant>(I))
167        if (C->isNullValue())
168          continue;
169      return false;
170    }
171    return true;
172  }
173
174  // Methods for support type inquiry through isa, cast, and dyn_cast:
175  static inline bool classof(const GEPOperator *) { return true; }
176  static inline bool classof(const GetElementPtrInst *) { return true; }
177  static inline bool classof(const ConstantExpr *CE) {
178    return CE->getOpcode() == Instruction::GetElementPtr;
179  }
180  static inline bool classof(const Instruction *I) {
181    return I->getOpcode() == Instruction::GetElementPtr;
182  }
183  static inline bool classof(const Value *V) {
184    return isa<GetElementPtrInst>(V) ||
185           (isa<ConstantExpr>(V) && classof(cast<ConstantExpr>(V)));
186  }
187};
188
189} // End llvm namespace
190
191#endif
192