blob: 4da19219d2f4fbbfa724e377b593d38e47c29abb (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
|
//===-- llvm/Operator.h - Operator utility subclass -------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file defines various classes for working with Instructions and
// ConstantExprs.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_OPERATOR_H
#define LLVM_OPERATOR_H
#include "llvm/Instruction.h"
#include "llvm/Constants.h"
namespace llvm {
/// Operator - This is a utility class that provides an abstraction for the
/// common functionality between Instructions and ConstantExprs.
///
class Operator : public User {
private:
// Do not implement any of these. The Operator class is intended to be used
// as a utility, and is never itself instantiated.
void *operator new(size_t, unsigned);
void *operator new(size_t s);
Operator();
~Operator();
public:
/// getOpcode - Return the opcode for this Instruction or ConstantExpr.
///
unsigned getOpcode() const {
if (const Instruction *I = dyn_cast<Instruction>(this))
return I->getOpcode();
return cast<ConstantExpr>(this)->getOpcode();
}
/// getOpcode - If V is an Instruction or ConstantExpr, return its
/// opcode. Otherwise return UserOp1.
///
static unsigned getOpcode(const Value *V) {
if (const Instruction *I = dyn_cast<Instruction>(V))
return I->getOpcode();
if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(V))
return CE->getOpcode();
return Instruction::UserOp1;
}
static inline bool classof(const Operator *) { return true; }
static inline bool classof(const Instruction *I) { return true; }
static inline bool classof(const ConstantExpr *I) { return true; }
static inline bool classof(const Value *V) {
return isa<Instruction>(V) || isa<ConstantExpr>(V);
}
};
/// OverflowingBinaryOperator - Utility class for integer arithmetic operators
/// which may exhibit overflow - Add, Sub, and Mul.
///
class OverflowingBinaryOperator : public Operator {
public:
/// hasNoSignedOverflow - Test whether this operation is known to never
/// undergo signed overflow.
bool hasNoSignedOverflow() const {
return SubclassOptionalData & (1 << 0);
}
void setHasNoSignedOverflow(bool B) {
SubclassOptionalData = (SubclassOptionalData & ~(1 << 0)) | (B << 0);
}
/// hasNoUnsignedOverflow - Test whether this operation is known to never
/// undergo unsigned overflow.
bool hasNoUnsignedOverflow() const {
return SubclassOptionalData & (1 << 1);
}
void setHasNoUnsignedOverflow(bool B) {
SubclassOptionalData = (SubclassOptionalData & ~(1 << 1)) | (B << 1);
}
static inline bool classof(const OverflowingBinaryOperator *) { return true; }
static inline bool classof(const Instruction *I) {
return I->getOpcode() == Instruction::Add ||
I->getOpcode() == Instruction::Sub ||
I->getOpcode() == Instruction::Mul;
}
static inline bool classof(const ConstantExpr *CE) {
return CE->getOpcode() == Instruction::Add ||
CE->getOpcode() == Instruction::Sub ||
CE->getOpcode() == Instruction::Mul;
}
static inline bool classof(const Value *V) {
return (isa<Instruction>(V) && classof(cast<Instruction>(V))) ||
(isa<ConstantExpr>(V) && classof(cast<ConstantExpr>(V)));
}
};
/// UDivOperator - An Operator with opcode Instruction::UDiv.
///
class UDivOperator : public Operator {
public:
/// isExact - Test whether this division is known to be exact, with
/// zero remainder.
bool isExact() const {
return SubclassOptionalData & (1 << 0);
}
void setIsExact(bool B) {
SubclassOptionalData = (SubclassOptionalData & ~(1 << 0)) | (B << 0);
}
// Methods for support type inquiry through isa, cast, and dyn_cast:
static inline bool classof(const UDivOperator *) { return true; }
static inline bool classof(const ConstantExpr *CE) {
return CE->getOpcode() == Instruction::UDiv;
}
static inline bool classof(const Instruction *I) {
return I->getOpcode() == Instruction::UDiv;
}
static inline bool classof(const Value *V) {
return (isa<Instruction>(V) && classof(cast<Instruction>(V))) ||
(isa<ConstantExpr>(V) && classof(cast<ConstantExpr>(V)));
}
};
} // End llvm namespace
#endif
|
