/*NumOperands=*/1) {}
// allocate space for exactly one operand
- void *operator new(size_t s) { return User::operator new(s, 1); }
+ void *operator new(size_t S) { return User::operator new(S, 1); }
+ void operator delete(void *Ptr) { User::operator delete(Ptr); }
static bool classof(const Value *MA) {
return MA->getValueID() == MemoryUseVal;
ID(Ver) {}
// allocate space for exactly two operands
- void *operator new(size_t s) { return User::operator new(s, 2); }
+ void *operator new(size_t S) { return User::operator new(S, 2); }
+ void operator delete(void *Ptr) { User::operator delete(Ptr); }
static bool classof(const Value *MA) {
return MA->getValueID() == MemoryDefVal;
/// issue.
class MemoryPhi final : public MemoryAccess {
// allocate space for exactly zero operands
- void *operator new(size_t s) { return User::operator new(s); }
+ void *operator new(size_t S) { return User::operator new(S); }
public:
+ void operator delete(void *Ptr) { User::operator delete(Ptr); }
+
/// Provide fast operand accessors
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(MemoryAccess);
protected:
explicit ConstantData(Type *Ty, ValueTy VT) : Constant(Ty, VT, nullptr, 0) {}
- void *operator new(size_t s) { return User::operator new(s, 0); }
+ void *operator new(size_t S) { return User::operator new(S, 0); }
public:
+ void operator delete(void *Ptr) { User::operator delete(Ptr); }
+
ConstantData(const ConstantData &) = delete;
/// Methods to support type inquiry through isa, cast, and dyn_cast.
BlockAddress(Function *F, BasicBlock *BB);
- void *operator new(size_t s) { return User::operator new(s, 2); }
+ void *operator new(size_t S) { return User::operator new(S, 2); }
void destroyConstantImpl();
Value *handleOperandChangeImpl(Value *From, Value *To);
public:
+ void operator delete(void *Ptr) { User::operator delete(Ptr); }
+
/// Return a BlockAddress for the specified function and basic block.
static BlockAddress *get(Function *F, BasicBlock *BB);
DSOLocalEquivalent(GlobalValue *GV);
- void *operator new(size_t s) { return User::operator new(s, 1); }
+ void *operator new(size_t S) { return User::operator new(S, 1); }
void destroyConstantImpl();
Value *handleOperandChangeImpl(Value *From, Value *To);
public:
+ void operator delete(void *Ptr) { User::operator delete(Ptr); }
+
/// Return a DSOLocalEquivalent for the specified global value.
static DSOLocalEquivalent *get(GlobalValue *GV);
GlobalIndirectSymbol &operator=(const GlobalIndirectSymbol &) = delete;
// allocate space for exactly one operand
- void *operator new(size_t s) {
- return User::operator new(s, 1);
- }
+ void *operator new(size_t S) { return User::operator new(S, 1); }
+ void operator delete(void *Ptr) { User::operator delete(Ptr); }
/// Provide fast operand accessors
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Constant);
public:
// allocate space for exactly one operand
- void *operator new(size_t s) {
- return User::operator new(s, 1);
- }
+ void *operator new(size_t S) { return User::operator new(S, 1); }
+ void operator delete(void *Ptr) { User::operator delete(Ptr); }
/// Transparently provide more efficient getOperand methods.
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
public:
// allocate space for exactly two operands
- void *operator new(size_t s) {
- return User::operator new(s, 2);
- }
+ void *operator new(size_t S) { return User::operator new(S, 2); }
+ void operator delete(void *Ptr) { User::operator delete(Ptr); }
/// Transparently provide more efficient getOperand methods.
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
public:
// allocate space for exactly two operands
- void *operator new(size_t s) {
- return User::operator new(s, 2);
- }
+ void *operator new(size_t S) { return User::operator new(S, 2); }
+ void operator delete(void *Ptr) { User::operator delete(Ptr); }
/// Construct a compare instruction, given the opcode, the predicate and
/// the two operands. Optionally (if InstBefore is specified) insert the
AtomicOrdering Order, SyncScope::ID SSID, BasicBlock *InsertAtEnd);
// allocate space for exactly two operands
- void *operator new(size_t s) {
- return User::operator new(s, 2);
- }
+ void *operator new(size_t S) { return User::operator new(S, 2); }
+ void operator delete(void *Ptr) { User::operator delete(Ptr); }
/// Return true if this is a store to a volatile memory location.
bool isVolatile() const { return getSubclassData<VolatileField>(); }
BasicBlock *InsertAtEnd);
// allocate space for exactly zero operands
- void *operator new(size_t s) {
- return User::operator new(s, 0);
- }
+ void *operator new(size_t S) { return User::operator new(S, 0); }
+ void operator delete(void *Ptr) { User::operator delete(Ptr); }
/// Returns the ordering constraint of this fence instruction.
AtomicOrdering getOrdering() const {
BasicBlock *InsertAtEnd);
// allocate space for exactly three operands
- void *operator new(size_t s) {
- return User::operator new(s, 3);
- }
+ void *operator new(size_t S) { return User::operator new(S, 3); }
+ void operator delete(void *Ptr) { User::operator delete(Ptr); }
using VolatileField = BoolBitfieldElementT<0>;
using WeakField = BoolBitfieldElementT<VolatileField::NextBit>;
BasicBlock *InsertAtEnd);
// allocate space for exactly two operands
- void *operator new(size_t s) {
- return User::operator new(s, 2);
- }
+ void *operator new(size_t S) { return User::operator new(S, 2); }
+ void operator delete(void *Ptr) { User::operator delete(Ptr); }
using VolatileField = BoolBitfieldElementT<0>;
using AtomicOrderingField =
ShuffleVectorInst(Value *V1, Value *V2, ArrayRef<int> Mask,
const Twine &NameStr, BasicBlock *InsertAtEnd);
- void *operator new(size_t s) { return User::operator new(s, 2); }
+ void *operator new(size_t S) { return User::operator new(S, 2); }
+ void operator delete(void *Ptr) { return User::operator delete(Ptr); }
/// Swap the operands and adjust the mask to preserve the semantics
/// of the instruction.
public:
// allocate space for exactly two operands
- void *operator new(size_t s) {
- return User::operator new(s, 2);
- }
+ void *operator new(size_t S) { return User::operator new(S, 2); }
+ void operator delete(void *Ptr) { User::operator delete(Ptr); }
static InsertValueInst *Create(Value *Agg, Value *Val,
ArrayRef<unsigned> Idxs,
const Twine &NameStr, BasicBlock *InsertAtEnd);
// Allocate space for exactly zero operands.
- void *operator new(size_t s) {
- return User::operator new(s);
- }
+ void *operator new(size_t S) { return User::operator new(S); }
void growOperands(unsigned Size);
void init(unsigned NumReservedValues, const Twine &NameStr);
LandingPadInst *cloneImpl() const;
public:
+ void operator delete(void *Ptr) { User::operator delete(Ptr); }
+
/// Constructors - NumReservedClauses is a hint for the number of incoming
/// clauses that this landingpad will have (use 0 if you really have no idea).
static LandingPadInst *Create(Type *RetTy, unsigned NumReservedClauses,
BasicBlock *InsertAtEnd);
// allocate space for exactly zero operands
- void *operator new(size_t s) {
- return User::operator new(s);
- }
+ void *operator new(size_t S) { return User::operator new(S); }
void init(Value *Value, BasicBlock *Default, unsigned NumReserved);
void growOperands();
SwitchInst *cloneImpl() const;
public:
+ void operator delete(void *Ptr) { User::operator delete(Ptr); }
+
// -2
static const unsigned DefaultPseudoIndex = static_cast<unsigned>(~0L-1);
IndirectBrInst(Value *Address, unsigned NumDests, BasicBlock *InsertAtEnd);
// allocate space for exactly zero operands
- void *operator new(size_t s) {
- return User::operator new(s);
- }
+ void *operator new(size_t S) { return User::operator new(S); }
void init(Value *Address, unsigned NumDests);
void growOperands();
IndirectBrInst *cloneImpl() const;
public:
+ void operator delete(void *Ptr) { User::operator delete(Ptr); }
+
/// Iterator type that casts an operand to a basic block.
///
/// This only makes sense because the successors are stored as adjacent
BasicBlock *InsertAtEnd);
// allocate space for exactly zero operands
- void *operator new(size_t s) { return User::operator new(s); }
+ void *operator new(size_t S) { return User::operator new(S); }
void init(Value *ParentPad, BasicBlock *UnwindDest, unsigned NumReserved);
void growOperands(unsigned Size);
CatchSwitchInst *cloneImpl() const;
public:
+ void operator delete(void *Ptr) { return User::operator delete(Ptr); }
+
static CatchSwitchInst *Create(Value *ParentPad, BasicBlock *UnwindDest,
unsigned NumHandlers,
const Twine &NameStr = "",
explicit UnreachableInst(LLVMContext &C, BasicBlock *InsertAtEnd);
// allocate space for exactly zero operands
- void *operator new(size_t s) {
- return User::operator new(s, 0);
- }
+ void *operator new(size_t S) { return User::operator new(S, 0); }
+ void operator delete(void *Ptr) { User::operator delete(Ptr); }
unsigned getNumSuccessors() const { return 0; }
}
// allocate space for exactly one operand
- void *operator new(size_t s) {
- return User::operator new(s, 1);
- }
+ void *operator new(size_t S) { return User::operator new(S, 1); }
+ void operator delete(void *Ptr) { User::operator delete(Ptr); }
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
}
// allocate space for exactly two operands
- void *operator new(size_t s) {
- return User::operator new(s, 2);
- }
+ void *operator new(size_t S) { return User::operator new(S, 2); }
+ void operator delete(void *Ptr) { User::operator delete(Ptr); }
/// Transparently provide more efficient getOperand methods.
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
}
// allocate space for exactly three operands
- void *operator new(size_t s) {
- return User::operator new(s, 3);
- }
+ void *operator new(size_t S) { return User::operator new(S, 3); }
+ void operator delete(void *Ptr) { User::operator delete(Ptr); }
/// Transparently provide more efficient getOperand methods.
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
}
// allocate space for exactly two operands
- void *operator new(size_t s) {
- return User::operator new(s, 2);
- }
+ void *operator new(size_t S) { return User::operator new(S, 2); }
+ void operator delete(void *Ptr) { User::operator delete(Ptr); }
/// Transparently provide more efficient getOperand methods.
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
}
// allocate space for exactly three operands
- void *operator new(size_t s) {
- return User::operator new(s, 3);
- }
+ void *operator new(size_t S) { return User::operator new(S, 3); }
+ void operator delete(void *Ptr) { User::operator delete(Ptr); }
/// Transparently provide more efficient getOperand methods.
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
SmallVector<int, 4> ShuffleMask;
Constant *ShuffleMaskForBitcode;
- void *operator new(size_t s) { return User::operator new(s, 2); }
+ void *operator new(size_t S) { return User::operator new(S, 2); }
+ void operator delete(void *Ptr) { return User::operator delete(Ptr); }
/// Transparently provide more efficient getOperand methods.
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
}
// allocate space for exactly one operand
- void *operator new(size_t s) {
- return User::operator new(s, 1);
- }
+ void *operator new(size_t S) { return User::operator new(S, 1); }
+ void operator delete(void *Ptr) { User::operator delete(Ptr); }
/// Indices - These identify which value to extract.
const SmallVector<unsigned, 4> Indices;
}
// allocate space for exactly one operand
- void *operator new(size_t s) {
- return User::operator new(s, 2);
- }
+ void *operator new(size_t S) { return User::operator new(S, 2); }
+ void operator delete(void *Ptr) { User::operator delete(Ptr); }
/// Indices - These identify the position for the insertion.
const SmallVector<unsigned, 4> Indices;
}
// allocate space for exactly two operands
- void *operator new(size_t s) {
- return User::operator new(s, 2);
- }
+ void *operator new(size_t S) { return User::operator new(S, 2); }
+ void operator delete(void *Ptr) { return User::operator delete(Ptr); }
/// Transparently provide more efficient getOperand methods.
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);