/// AllocaInst - an instruction to allocate memory on the stack
///
class AllocaInst : public UnaryInstruction {
+protected:
+ virtual AllocaInst *clone_impl() const;
public:
explicit AllocaInst(const Type *Ty, Value *ArraySize = 0,
const Twine &Name = "", Instruction *InsertBefore = 0);
/// into the prolog/epilog code, so it is basically free.
bool isStaticAlloca() const;
- virtual AllocaInst *clone() const;
-
// Methods for support type inquiry through isa, cast, and dyn_cast:
static inline bool classof(const AllocaInst *) { return true; }
static inline bool classof(const Instruction *I) {
///
class LoadInst : public UnaryInstruction {
void AssertOK();
+protected:
+ virtual LoadInst *clone_impl() const;
public:
LoadInst(Value *Ptr, const Twine &NameStr, Instruction *InsertBefore);
LoadInst(Value *Ptr, const Twine &NameStr, BasicBlock *InsertAtEnd);
SubclassData = (SubclassData & ~1) | (V ? 1 : 0);
}
- virtual LoadInst *clone() const;
-
/// getAlignment - Return the alignment of the access that is being performed
///
unsigned getAlignment() const {
class StoreInst : public Instruction {
void *operator new(size_t, unsigned); // DO NOT IMPLEMENT
void AssertOK();
+protected:
+ virtual StoreInst *clone_impl() const;
public:
// allocate space for exactly two operands
void *operator new(size_t s) {
void setAlignment(unsigned Align);
- virtual StoreInst *clone() const;
-
Value *getPointerOperand() { return getOperand(1); }
const Value *getPointerOperand() const { return getOperand(1); }
static unsigned getPointerOperandIndex() { return 1U; }
Instruction *InsertBefore = 0);
GetElementPtrInst(Value *Ptr, Value *Idx,
const Twine &NameStr, BasicBlock *InsertAtEnd);
+protected:
+ virtual GetElementPtrInst *clone_impl() const;
public:
template<typename InputIterator>
static GetElementPtrInst *Create(Value *Ptr, InputIterator IdxBegin,
return GEP;
}
- virtual GetElementPtrInst *clone() const;
-
/// Transparently provide more efficient getOperand methods.
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
/// must be identical types.
/// @brief Represent an integer comparison operator.
class ICmpInst: public CmpInst {
+protected:
+ /// @brief Clone an indentical ICmpInst
+ virtual ICmpInst *clone_impl() const;
public:
/// @brief Constructor with insert-before-instruction semantics.
ICmpInst(
Op<0>().swap(Op<1>());
}
- virtual ICmpInst *clone() const;
-
// Methods for support type inquiry through isa, cast, and dyn_cast:
static inline bool classof(const ICmpInst *) { return true; }
static inline bool classof(const Instruction *I) {
/// vectors of floating point values. The operands must be identical types.
/// @brief Represents a floating point comparison operator.
class FCmpInst: public CmpInst {
+protected:
+ /// @brief Clone an indentical FCmpInst
+ virtual FCmpInst *clone_impl() const;
public:
/// @brief Constructor with insert-before-instruction semantics.
FCmpInst(
Op<0>().swap(Op<1>());
}
- virtual FCmpInst *clone() const;
-
/// @brief Methods for support type inquiry through isa, cast, and dyn_cast:
static inline bool classof(const FCmpInst *) { return true; }
static inline bool classof(const Instruction *I) {
explicit CallInst(Value *F, const Twine &NameStr,
Instruction *InsertBefore);
CallInst(Value *F, const Twine &NameStr, BasicBlock *InsertAtEnd);
+protected:
+ virtual CallInst *clone_impl() const;
public:
template<typename InputIterator>
static CallInst *Create(Value *Func,
/// 3. Bitcast the result of the malloc call to the specified type.
static Instruction *CreateMalloc(Instruction *InsertBefore,
const Type *IntPtrTy, const Type *AllocTy,
- Value *ArraySize = 0,
+ Value *AllocSize, Value *ArraySize = 0,
const Twine &Name = "");
static Instruction *CreateMalloc(BasicBlock *InsertAtEnd,
const Type *IntPtrTy, const Type *AllocTy,
- Value *ArraySize = 0, Function* MallocF = 0,
+ Value *AllocSize, Value *ArraySize = 0,
+ Function* MallocF = 0,
const Twine &Name = "");
/// CreateFree - Generate the IR for a call to the builtin free function.
static void CreateFree(Value* Source, Instruction *InsertBefore);
SubclassData = (SubclassData & ~1) | unsigned(isTC);
}
- virtual CallInst *clone() const;
-
/// Provide fast operand accessors
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
init(C, S1, S2);
setName(NameStr);
}
+protected:
+ virtual SelectInst *clone_impl() const;
public:
static SelectInst *Create(Value *C, Value *S1, Value *S2,
const Twine &NameStr = "",
return static_cast<OtherOps>(Instruction::getOpcode());
}
- virtual SelectInst *clone() const;
-
// Methods for support type inquiry through isa, cast, and dyn_cast:
static inline bool classof(const SelectInst *) { return true; }
static inline bool classof(const Instruction *I) {
/// an argument of the specified type given a va_list and increments that list
///
class VAArgInst : public UnaryInstruction {
+protected:
+ virtual VAArgInst *clone_impl() const;
+
public:
VAArgInst(Value *List, const Type *Ty, const Twine &NameStr = "",
Instruction *InsertBefore = 0)
setName(NameStr);
}
- virtual VAArgInst *clone() const;
-
// Methods for support type inquiry through isa, cast, and dyn_cast:
static inline bool classof(const VAArgInst *) { return true; }
static inline bool classof(const Instruction *I) {
Instruction *InsertBefore = 0);
ExtractElementInst(Value *Vec, Value *Idx, const Twine &NameStr,
BasicBlock *InsertAtEnd);
+protected:
+ virtual ExtractElementInst *clone_impl() const;
+
public:
static ExtractElementInst *Create(Value *Vec, Value *Idx,
const Twine &NameStr = "",
/// formed with the specified operands.
static bool isValidOperands(const Value *Vec, const Value *Idx);
- virtual ExtractElementInst *clone() const;
-
Value *getVectorOperand() { return Op<0>(); }
Value *getIndexOperand() { return Op<1>(); }
const Value *getVectorOperand() const { return Op<0>(); }
Instruction *InsertBefore = 0);
InsertElementInst(Value *Vec, Value *NewElt, Value *Idx,
const Twine &NameStr, BasicBlock *InsertAtEnd);
+protected:
+ virtual InsertElementInst *clone_impl() const;
+
public:
static InsertElementInst *Create(Value *Vec, Value *NewElt, Value *Idx,
const Twine &NameStr = "",
static bool isValidOperands(const Value *Vec, const Value *NewElt,
const Value *Idx);
- virtual InsertElementInst *clone() const;
-
/// getType - Overload to return most specific vector type.
///
const VectorType *getType() const {
/// input vectors.
///
class ShuffleVectorInst : public Instruction {
+protected:
+ virtual ShuffleVectorInst *clone_impl() const;
+
public:
// allocate space for exactly three operands
void *operator new(size_t s) {
static bool isValidOperands(const Value *V1, const Value *V2,
const Value *Mask);
- virtual ShuffleVectorInst *clone() const;
-
/// getType - Overload to return most specific vector type.
///
const VectorType *getType() const {
void *operator new(size_t s) {
return User::operator new(s, 1);
}
+protected:
+ virtual ExtractValueInst *clone_impl() const;
public:
template<typename InputIterator>
return new ExtractValueInst(Agg, Idxs, Idxs + 1, NameStr, InsertAtEnd);
}
- virtual ExtractValueInst *clone() const;
-
/// getIndexedType - Returns the type of the element that would be extracted
/// with an extractvalue instruction with the specified parameters.
///
Instruction *InsertBefore = 0);
InsertValueInst(Value *Agg, Value *Val, unsigned Idx,
const Twine &NameStr, BasicBlock *InsertAtEnd);
+protected:
+ virtual InsertValueInst *clone_impl() const;
public:
// allocate space for exactly two operands
void *operator new(size_t s) {
return new InsertValueInst(Agg, Val, Idx, NameStr, InsertAtEnd);
}
- virtual InsertValueInst *clone() const;
-
/// Transparently provide more efficient getOperand methods.
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
ReservedSpace(0) {
setName(NameStr);
}
+protected:
+ virtual PHINode *clone_impl() const;
public:
static PHINode *Create(const Type *Ty, const Twine &NameStr = "",
Instruction *InsertBefore = 0) {
resizeOperands(NumValues*2);
}
- virtual PHINode *clone() const;
-
/// Provide fast operand accessors
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
Instruction *InsertBefore = 0);
ReturnInst(LLVMContext &C, Value *retVal, BasicBlock *InsertAtEnd);
explicit ReturnInst(LLVMContext &C, BasicBlock *InsertAtEnd);
+protected:
+ virtual ReturnInst *clone_impl() const;
public:
static ReturnInst* Create(LLVMContext &C, Value *retVal = 0,
Instruction *InsertBefore = 0) {
}
virtual ~ReturnInst();
- virtual ReturnInst *clone() const;
-
/// Provide fast operand accessors
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
BranchInst(BasicBlock *IfTrue, BasicBlock *InsertAtEnd);
BranchInst(BasicBlock *IfTrue, BasicBlock *IfFalse, Value *Cond,
BasicBlock *InsertAtEnd);
+protected:
+ virtual BranchInst *clone_impl() const;
public:
static BranchInst *Create(BasicBlock *IfTrue, Instruction *InsertBefore = 0) {
return new(1, true) BranchInst(IfTrue, InsertBefore);
/// Transparently provide more efficient getOperand methods.
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
- virtual BranchInst *clone() const;
-
bool isUnconditional() const { return getNumOperands() == 1; }
bool isConditional() const { return getNumOperands() == 3; }
/// constructor also autoinserts at the end of the specified BasicBlock.
SwitchInst(Value *Value, BasicBlock *Default, unsigned NumCases,
BasicBlock *InsertAtEnd);
+protected:
+ virtual SwitchInst *clone_impl() const;
public:
static SwitchInst *Create(Value *Value, BasicBlock *Default,
unsigned NumCases, Instruction *InsertBefore = 0) {
///
void removeCase(unsigned idx);
- virtual SwitchInst *clone() const;
-
unsigned getNumSuccessors() const { return getNumOperands()/2; }
BasicBlock *getSuccessor(unsigned idx) const {
assert(idx < getNumSuccessors() &&"Successor idx out of range for switch!");
//===----------------------------------------------------------------------===//
-// IndBrInst Class
+// IndirectBrInst Class
//===----------------------------------------------------------------------===//
//===---------------------------------------------------------------------------
-/// IndBrInst - Indirect Branch Instruction.
+/// IndirectBrInst - Indirect Branch Instruction.
///
-class IndBrInst : public TerminatorInst {
+class IndirectBrInst : public TerminatorInst {
void *operator new(size_t, unsigned); // DO NOT IMPLEMENT
unsigned ReservedSpace;
// Operand[0] = Value to switch on
// Operand[1] = Default basic block destination
// Operand[2n ] = Value to match
// Operand[2n+1] = BasicBlock to go to on match
- IndBrInst(const IndBrInst &IBI);
+ IndirectBrInst(const IndirectBrInst &IBI);
void init(Value *Address, unsigned NumDests);
void resizeOperands(unsigned No);
// allocate space for exactly zero operands
void *operator new(size_t s) {
return User::operator new(s, 0);
}
- /// IndBrInst ctor - Create a new indbr instruction, specifying an Address to
- /// jump to. The number of expected destinations can be specified here to
- /// make memory allocation more efficient. This constructor can also
+ /// IndirectBrInst ctor - Create a new indirectbr instruction, specifying an
+ /// Address to jump to. The number of expected destinations can be specified
+ /// here to make memory allocation more efficient. This constructor can also
/// autoinsert before another instruction.
- IndBrInst(Value *Address, unsigned NumDests, Instruction *InsertBefore);
+ IndirectBrInst(Value *Address, unsigned NumDests, Instruction *InsertBefore);
- /// IndBrInst ctor - Create a new indbr instruction, specifying an Address to
- /// jump to. The number of expected destinations can be specified here to
- /// make memory allocation more efficient. This constructor also autoinserts
- /// at the end of the specified BasicBlock.
- IndBrInst(Value *Address, unsigned NumDests, BasicBlock *InsertAtEnd);
+ /// IndirectBrInst ctor - Create a new indirectbr instruction, specifying an
+ /// Address to jump to. The number of expected destinations can be specified
+ /// here to make memory allocation more efficient. This constructor also
+ /// autoinserts at the end of the specified BasicBlock.
+ IndirectBrInst(Value *Address, unsigned NumDests, BasicBlock *InsertAtEnd);
+protected:
+ virtual IndirectBrInst *clone_impl() const;
public:
- static IndBrInst *Create(Value *Address, unsigned NumDests,
- Instruction *InsertBefore = 0) {
- return new IndBrInst(Address, NumDests, InsertBefore);
+ static IndirectBrInst *Create(Value *Address, unsigned NumDests,
+ Instruction *InsertBefore = 0) {
+ return new IndirectBrInst(Address, NumDests, InsertBefore);
}
- static IndBrInst *Create(Value *Address, unsigned NumDests,
- BasicBlock *InsertAtEnd) {
- return new IndBrInst(Address, NumDests, InsertAtEnd);
+ static IndirectBrInst *Create(Value *Address, unsigned NumDests,
+ BasicBlock *InsertAtEnd) {
+ return new IndirectBrInst(Address, NumDests, InsertAtEnd);
}
- ~IndBrInst();
+ ~IndirectBrInst();
/// Provide fast operand accessors.
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
- // Accessor Methods for IndBr instruction.
+ // Accessor Methods for IndirectBrInst instruction.
Value *getAddress() { return getOperand(0); }
const Value *getAddress() const { return getOperand(0); }
void setAddress(Value *V) { setOperand(0, V); }
/// getNumDestinations - return the number of possible destinations in this
- /// indbr instruction.
+ /// indirectbr instruction.
unsigned getNumDestinations() const { return getNumOperands()-1; }
/// getDestination - Return the specified destination.
void addDestination(BasicBlock *Dest);
/// removeDestination - This method removes the specified successor from the
- /// indbr instruction.
+ /// indirectbr instruction.
void removeDestination(unsigned i);
- virtual IndBrInst *clone() const;
-
unsigned getNumSuccessors() const { return getNumOperands()-1; }
BasicBlock *getSuccessor(unsigned i) const {
return cast<BasicBlock>(getOperand(i+1));
}
// Methods for support type inquiry through isa, cast, and dyn_cast:
- static inline bool classof(const IndBrInst *) { return true; }
+ static inline bool classof(const IndirectBrInst *) { return true; }
static inline bool classof(const Instruction *I) {
- return I->getOpcode() == Instruction::IndBr;
+ return I->getOpcode() == Instruction::IndirectBr;
}
static inline bool classof(const Value *V) {
return isa<Instruction>(V) && classof(cast<Instruction>(V));
};
template <>
-struct OperandTraits<IndBrInst> : public HungoffOperandTraits<1> {
+struct OperandTraits<IndirectBrInst> : public HungoffOperandTraits<1> {
};
-DEFINE_TRANSPARENT_OPERAND_ACCESSORS(IndBrInst, Value)
+DEFINE_TRANSPARENT_OPERAND_ACCESSORS(IndirectBrInst, Value)
//===----------------------------------------------------------------------===//
InputIterator ArgBegin, InputIterator ArgEnd,
unsigned Values,
const Twine &NameStr, BasicBlock *InsertAtEnd);
+protected:
+ virtual InvokeInst *clone_impl() const;
public:
template<typename InputIterator>
static InvokeInst *Create(Value *Func,
Values, NameStr, InsertAtEnd);
}
- virtual InvokeInst *clone() const;
-
/// Provide fast operand accessors
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
///
class UnwindInst : public TerminatorInst {
void *operator new(size_t, unsigned); // DO NOT IMPLEMENT
+protected:
+ virtual UnwindInst *clone_impl() const;
public:
// allocate space for exactly zero operands
void *operator new(size_t s) {
explicit UnwindInst(LLVMContext &C, Instruction *InsertBefore = 0);
explicit UnwindInst(LLVMContext &C, BasicBlock *InsertAtEnd);
- virtual UnwindInst *clone() const;
-
unsigned getNumSuccessors() const { return 0; }
// Methods for support type inquiry through isa, cast, and dyn_cast:
///
class UnreachableInst : public TerminatorInst {
void *operator new(size_t, unsigned); // DO NOT IMPLEMENT
+protected:
+ virtual UnreachableInst *clone_impl() const;
+
public:
// allocate space for exactly zero operands
void *operator new(size_t s) {
explicit UnreachableInst(LLVMContext &C, Instruction *InsertBefore = 0);
explicit UnreachableInst(LLVMContext &C, BasicBlock *InsertAtEnd);
- virtual UnreachableInst *clone() const;
-
unsigned getNumSuccessors() const { return 0; }
// Methods for support type inquiry through isa, cast, and dyn_cast:
/// @brief This class represents a truncation of integer types.
class TruncInst : public CastInst {
+protected:
+ /// @brief Clone an identical TruncInst
+ virtual TruncInst *clone_impl() const;
+
public:
/// @brief Constructor with insert-before-instruction semantics
TruncInst(
BasicBlock *InsertAtEnd ///< The block to insert the instruction into
);
- /// @brief Clone an identical TruncInst
- virtual TruncInst *clone() const;
-
/// @brief Methods for support type inquiry through isa, cast, and dyn_cast:
static inline bool classof(const TruncInst *) { return true; }
static inline bool classof(const Instruction *I) {
/// @brief This class represents zero extension of integer types.
class ZExtInst : public CastInst {
+protected:
+ /// @brief Clone an identical ZExtInst
+ virtual ZExtInst *clone_impl() const;
+
public:
/// @brief Constructor with insert-before-instruction semantics
ZExtInst(
BasicBlock *InsertAtEnd ///< The block to insert the instruction into
);
- /// @brief Clone an identical ZExtInst
- virtual ZExtInst *clone() const;
-
/// @brief Methods for support type inquiry through isa, cast, and dyn_cast:
static inline bool classof(const ZExtInst *) { return true; }
static inline bool classof(const Instruction *I) {
/// @brief This class represents a sign extension of integer types.
class SExtInst : public CastInst {
+protected:
+ /// @brief Clone an identical SExtInst
+ virtual SExtInst *clone_impl() const;
+
public:
/// @brief Constructor with insert-before-instruction semantics
SExtInst(
BasicBlock *InsertAtEnd ///< The block to insert the instruction into
);
- /// @brief Clone an identical SExtInst
- virtual SExtInst *clone() const;
-
/// @brief Methods for support type inquiry through isa, cast, and dyn_cast:
static inline bool classof(const SExtInst *) { return true; }
static inline bool classof(const Instruction *I) {
/// @brief This class represents a truncation of floating point types.
class FPTruncInst : public CastInst {
+protected:
+ /// @brief Clone an identical FPTruncInst
+ virtual FPTruncInst *clone_impl() const;
+
public:
/// @brief Constructor with insert-before-instruction semantics
FPTruncInst(
BasicBlock *InsertAtEnd ///< The block to insert the instruction into
);
- /// @brief Clone an identical FPTruncInst
- virtual FPTruncInst *clone() const;
-
/// @brief Methods for support type inquiry through isa, cast, and dyn_cast:
static inline bool classof(const FPTruncInst *) { return true; }
static inline bool classof(const Instruction *I) {
/// @brief This class represents an extension of floating point types.
class FPExtInst : public CastInst {
+protected:
+ /// @brief Clone an identical FPExtInst
+ virtual FPExtInst *clone_impl() const;
+
public:
/// @brief Constructor with insert-before-instruction semantics
FPExtInst(
BasicBlock *InsertAtEnd ///< The block to insert the instruction into
);
- /// @brief Clone an identical FPExtInst
- virtual FPExtInst *clone() const;
-
/// @brief Methods for support type inquiry through isa, cast, and dyn_cast:
static inline bool classof(const FPExtInst *) { return true; }
static inline bool classof(const Instruction *I) {
/// @brief This class represents a cast unsigned integer to floating point.
class UIToFPInst : public CastInst {
+protected:
+ /// @brief Clone an identical UIToFPInst
+ virtual UIToFPInst *clone_impl() const;
+
public:
/// @brief Constructor with insert-before-instruction semantics
UIToFPInst(
BasicBlock *InsertAtEnd ///< The block to insert the instruction into
);
- /// @brief Clone an identical UIToFPInst
- virtual UIToFPInst *clone() const;
-
/// @brief Methods for support type inquiry through isa, cast, and dyn_cast:
static inline bool classof(const UIToFPInst *) { return true; }
static inline bool classof(const Instruction *I) {
/// @brief This class represents a cast from signed integer to floating point.
class SIToFPInst : public CastInst {
+protected:
+ /// @brief Clone an identical SIToFPInst
+ virtual SIToFPInst *clone_impl() const;
+
public:
/// @brief Constructor with insert-before-instruction semantics
SIToFPInst(
BasicBlock *InsertAtEnd ///< The block to insert the instruction into
);
- /// @brief Clone an identical SIToFPInst
- virtual SIToFPInst *clone() const;
-
/// @brief Methods for support type inquiry through isa, cast, and dyn_cast:
static inline bool classof(const SIToFPInst *) { return true; }
static inline bool classof(const Instruction *I) {
/// @brief This class represents a cast from floating point to unsigned integer
class FPToUIInst : public CastInst {
+protected:
+ /// @brief Clone an identical FPToUIInst
+ virtual FPToUIInst *clone_impl() const;
+
public:
/// @brief Constructor with insert-before-instruction semantics
FPToUIInst(
BasicBlock *InsertAtEnd ///< Where to insert the new instruction
);
- /// @brief Clone an identical FPToUIInst
- virtual FPToUIInst *clone() const;
-
/// @brief Methods for support type inquiry through isa, cast, and dyn_cast:
static inline bool classof(const FPToUIInst *) { return true; }
static inline bool classof(const Instruction *I) {
/// @brief This class represents a cast from floating point to signed integer.
class FPToSIInst : public CastInst {
+protected:
+ /// @brief Clone an identical FPToSIInst
+ virtual FPToSIInst *clone_impl() const;
+
public:
/// @brief Constructor with insert-before-instruction semantics
FPToSIInst(
BasicBlock *InsertAtEnd ///< The block to insert the instruction into
);
- /// @brief Clone an identical FPToSIInst
- virtual FPToSIInst *clone() const;
-
/// @brief Methods for support type inquiry through isa, cast, and dyn_cast:
static inline bool classof(const FPToSIInst *) { return true; }
static inline bool classof(const Instruction *I) {
);
/// @brief Clone an identical IntToPtrInst
- virtual IntToPtrInst *clone() const;
+ virtual IntToPtrInst *clone_impl() const;
// Methods for support type inquiry through isa, cast, and dyn_cast:
static inline bool classof(const IntToPtrInst *) { return true; }
/// @brief This class represents a cast from a pointer to an integer
class PtrToIntInst : public CastInst {
+protected:
+ /// @brief Clone an identical PtrToIntInst
+ virtual PtrToIntInst *clone_impl() const;
+
public:
/// @brief Constructor with insert-before-instruction semantics
PtrToIntInst(
BasicBlock *InsertAtEnd ///< The block to insert the instruction into
);
- /// @brief Clone an identical PtrToIntInst
- virtual PtrToIntInst *clone() const;
-
// Methods for support type inquiry through isa, cast, and dyn_cast:
static inline bool classof(const PtrToIntInst *) { return true; }
static inline bool classof(const Instruction *I) {
/// @brief This class represents a no-op cast from one type to another.
class BitCastInst : public CastInst {
+protected:
+ /// @brief Clone an identical BitCastInst
+ virtual BitCastInst *clone_impl() const;
+
public:
/// @brief Constructor with insert-before-instruction semantics
BitCastInst(
BasicBlock *InsertAtEnd ///< The block to insert the instruction into
);
- /// @brief Clone an identical BitCastInst
- virtual BitCastInst *clone() const;
-
// Methods for support type inquiry through isa, cast, and dyn_cast:
static inline bool classof(const BitCastInst *) { return true; }
static inline bool classof(const Instruction *I) {
projects / oota-llvm.git / blobdiff