//
// The LLVM Compiler Infrastructure
//
-// This file was developed by the LLVM research group and is distributed under
-// the University of Illinois Open Source License. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
Use *Ops, unsigned NumOps, BasicBlock *InsertAtEnd)
: Instruction(Ty, iType, Ops, NumOps, InsertAtEnd) {}
+ // Out of line virtual method, so the vtable, etc has a home.
+ ~TerminatorInst();
+
/// Virtual methods - Terminators should overload these and provide inline
/// overrides of non-V methods.
virtual BasicBlock *getSuccessorV(unsigned idx) const = 0;
virtual unsigned getNumSuccessorsV() const = 0;
virtual void setSuccessorV(unsigned idx, BasicBlock *B) = 0;
-
- static void destroyThis(TerminatorInst* v) {
- Instruction::destroyThis(v);
- }
- friend class Value;
public:
virtual Instruction *clone() const = 0;
//===----------------------------------------------------------------------===//
class UnaryInstruction : public Instruction {
+ void *operator new(size_t, unsigned); // Do not implement
Use Op;
// avoiding warning: 'this' : used in base member initializer list
UnaryInstruction(const Type *Ty, unsigned iType, Value *V, BasicBlock *IAE)
: Instruction(Ty, iType, &Op, 1, IAE), Op(V, this_()) {
}
-
- static void destroyThis(UnaryInstruction* v) {
- Instruction::destroyThis(v);
- }
- friend class Value;
public:
+ // allocate space for exactly one operand
+ void *operator new(size_t s) {
+ return User::operator new(s, 1);
+ }
+
+ // Out of line virtual method, so the vtable, etc has a home.
+ ~UnaryInstruction();
+
// Transparently provide more efficient getOperand methods.
Value *getOperand(unsigned i) const {
assert(i == 0 && "getOperand() out of range!");
//===----------------------------------------------------------------------===//
class BinaryOperator : public Instruction {
+ void *operator new(size_t, unsigned); // Do not implement
Use Ops[2];
protected:
void init(BinaryOps iType);
const std::string &Name, Instruction *InsertBefore);
BinaryOperator(BinaryOps iType, Value *S1, Value *S2, const Type *Ty,
const std::string &Name, BasicBlock *InsertAtEnd);
-
- static void destroyThis(BinaryOperator* v) {
- Instruction::destroyThis(v);
- }
- friend class Value;
public:
+ // allocate space for exactly two operands
+ void *operator new(size_t s) {
+ return User::operator new(s, 2);
+ }
/// Transparently provide more efficient getOperand methods.
Value *getOperand(unsigned i) const {
: UnaryInstruction(Ty, iType, S, InsertAtEnd) {
setName(Name);
}
-
-protected:
- static void destroyThis(CastInst* v) {
- UnaryInstruction::destroyThis(v);
- }
- friend class Value;
public:
/// Provides a way to construct any of the CastInst subclasses using an
/// opcode instead of the subclass's constructor. The opcode must be in the
BasicBlock *InsertAtEnd ///< The block to insert the instruction into
);
+ /// @brief Check whether it is valid to call getCastOpcode for these types.
+ static bool isCastable(
+ const Type *SrcTy, ///< The Type from which the value should be cast.
+ const Type *DestTy ///< The Type to which the value should be cast.
+ );
+
/// Returns the opcode necessary to cast Val into Ty using usual casting
- /// rules.
+ /// rules.
/// @brief Infer the opcode for cast operand and type
static Instruction::CastOps getCastOpcode(
const Value *Val, ///< The value to cast
/// This class is the base class for the comparison instructions.
/// @brief Abstract base class of comparison instructions.
class CmpInst: public Instruction {
+ void *operator new(size_t, unsigned); // DO NOT IMPLEMENT
CmpInst(); // do not implement
protected:
CmpInst(Instruction::OtherOps op, unsigned short pred, Value *LHS, Value *RHS,
Use Ops[2]; // CmpInst instructions always have 2 operands, optimize
- static void destroyThis(CmpInst* v) {
- Instruction::destroyThis(v);
- }
- friend class Value;
public:
+ // allocate space for exactly two operands
+ void *operator new(size_t s) {
+ return User::operator new(s, 2);
+ }
/// Construct a compare instruction, given the opcode, the predicate and
/// the two operands. Optionally (if InstBefore is specified) insert the
/// instruction into a BasicBlock right before the specified instruction.