[llvm] d58c7a9 - [IR] Added operator delete to subclasses of User to avoid UB
Moritz Sichert via llvm-commits
llvm-commits at lists.llvm.org
Thu Jul 8 02:59:55 PDT 2021
Author: Moritz Sichert
Date: 2021-07-08T11:59:22+02:00
New Revision: d58c7a92380e030af6e6f82ce55bc14a919f39ea
URL: https://github.com/llvm/llvm-project/commit/d58c7a92380e030af6e6f82ce55bc14a919f39ea
DIFF: https://github.com/llvm/llvm-project/commit/d58c7a92380e030af6e6f82ce55bc14a919f39ea.diff
LOG: [IR] Added operator delete to subclasses of User to avoid UB
Several subclasses of User override operator new without also overriding
operator delete. This means that delete expressions fall back to using
operator delete of the base class, which would be User. However, this is
only allowed if the base class has a virtual destructor which is not the
case for User, so this is UB.
See also [expr.delete] (3) for the exact wording.
This is actually detected in some cases by GCC 11's
-Wmismatched-new-delete now which is how I found this error.
Differential Revision: https://reviews.llvm.org/D103143
Added:
Modified:
llvm/include/llvm/Analysis/MemorySSA.h
llvm/include/llvm/IR/Constants.h
llvm/include/llvm/IR/GlobalIndirectSymbol.h
llvm/include/llvm/IR/InstrTypes.h
llvm/include/llvm/IR/Instructions.h
llvm/lib/IR/ConstantsContext.h
Removed:
################################################################################
diff --git a/llvm/include/llvm/Analysis/MemorySSA.h b/llvm/include/llvm/Analysis/MemorySSA.h
index a26115aa82f11..f40b99968fd3a 100644
--- a/llvm/include/llvm/Analysis/MemorySSA.h
+++ b/llvm/include/llvm/Analysis/MemorySSA.h
@@ -329,7 +329,8 @@ class MemoryUse final : public MemoryUseOrDef {
/*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;
@@ -389,7 +390,8 @@ class MemoryDef final : public MemoryUseOrDef {
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;
@@ -484,9 +486,11 @@ DEFINE_TRANSPARENT_OPERAND_ACCESSORS(MemoryUseOrDef, MemoryAccess)
/// 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);
diff --git a/llvm/include/llvm/IR/Constants.h b/llvm/include/llvm/IR/Constants.h
index 07d8e9ab5bb62..142dc21874508 100644
--- a/llvm/include/llvm/IR/Constants.h
+++ b/llvm/include/llvm/IR/Constants.h
@@ -58,9 +58,11 @@ class ConstantData : public Constant {
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.
@@ -849,12 +851,14 @@ class BlockAddress final : public Constant {
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);
@@ -893,12 +897,14 @@ class DSOLocalEquivalent final : public Constant {
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);
diff --git a/llvm/include/llvm/IR/GlobalIndirectSymbol.h b/llvm/include/llvm/IR/GlobalIndirectSymbol.h
index d996237aa3efb..e45c7529885d5 100644
--- a/llvm/include/llvm/IR/GlobalIndirectSymbol.h
+++ b/llvm/include/llvm/IR/GlobalIndirectSymbol.h
@@ -35,9 +35,8 @@ class GlobalIndirectSymbol : public GlobalValue {
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);
diff --git a/llvm/include/llvm/IR/InstrTypes.h b/llvm/include/llvm/IR/InstrTypes.h
index 0e372d1cc8793..2f31db0fa4d7e 100644
--- a/llvm/include/llvm/IR/InstrTypes.h
+++ b/llvm/include/llvm/IR/InstrTypes.h
@@ -68,9 +68,8 @@ class UnaryInstruction : public Instruction {
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);
@@ -203,9 +202,8 @@ class BinaryOperator : public 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); }
/// Transparently provide more efficient getOperand methods.
DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
@@ -769,9 +767,8 @@ class CmpInst : public 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); }
/// Construct a compare instruction, given the opcode, the predicate and
/// the two operands. Optionally (if InstBefore is specified) insert the
diff --git a/llvm/include/llvm/IR/Instructions.h b/llvm/include/llvm/IR/Instructions.h
index 5de72de77f839..e48a14f4b5b4b 100644
--- a/llvm/include/llvm/IR/Instructions.h
+++ b/llvm/include/llvm/IR/Instructions.h
@@ -333,9 +333,8 @@ class StoreInst : public Instruction {
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>(); }
@@ -463,9 +462,8 @@ class FenceInst : public Instruction {
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 {
@@ -547,9 +545,8 @@ class AtomicCmpXchgInst : public Instruction {
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>;
@@ -792,9 +789,8 @@ class AtomicRMWInst : public Instruction {
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 =
@@ -2040,7 +2036,8 @@ class ShuffleVectorInst : public Instruction {
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.
@@ -2497,9 +2494,8 @@ class InsertValueInst : public 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,
@@ -2875,9 +2871,7 @@ class LandingPadInst : public Instruction {
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);
@@ -2889,6 +2883,8 @@ class LandingPadInst : public Instruction {
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,
@@ -3207,9 +3203,7 @@ class SwitchInst : public Instruction {
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();
@@ -3221,6 +3215,8 @@ class SwitchInst : public Instruction {
SwitchInst *cloneImpl() const;
public:
+ void operator delete(void *Ptr) { User::operator delete(Ptr); }
+
// -2
static const unsigned DefaultPseudoIndex = static_cast<unsigned>(~0L-1);
@@ -3605,9 +3601,7 @@ class IndirectBrInst : public Instruction {
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();
@@ -3619,6 +3613,8 @@ class IndirectBrInst : public Instruction {
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
@@ -4256,7 +4252,7 @@ class CatchSwitchInst : public Instruction {
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);
@@ -4268,6 +4264,8 @@ class CatchSwitchInst : public Instruction {
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 = "",
@@ -4696,9 +4694,8 @@ class UnreachableInst : public Instruction {
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; }
diff --git a/llvm/lib/IR/ConstantsContext.h b/llvm/lib/IR/ConstantsContext.h
index 7fc25a8944e6b..4056c57480816 100644
--- a/llvm/lib/IR/ConstantsContext.h
+++ b/llvm/lib/IR/ConstantsContext.h
@@ -51,9 +51,8 @@ class UnaryConstantExpr final : public ConstantExpr {
}
// 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);
@@ -79,9 +78,8 @@ class BinaryConstantExpr final : public ConstantExpr {
}
// 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);
@@ -106,9 +104,8 @@ class SelectConstantExpr final : public ConstantExpr {
}
// 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);
@@ -134,9 +131,8 @@ class ExtractElementConstantExpr final : public ConstantExpr {
}
// 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);
@@ -163,9 +159,8 @@ class InsertElementConstantExpr final : public ConstantExpr {
}
// 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);
@@ -200,7 +195,8 @@ class ShuffleVectorConstantExpr final : public ConstantExpr {
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);
@@ -226,9 +222,8 @@ class ExtractValueConstantExpr final : public ConstantExpr {
}
// 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;
@@ -258,9 +253,8 @@ class InsertValueConstantExpr final : public ConstantExpr {
}
// 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;
@@ -323,9 +317,8 @@ class CompareConstantExpr final : public ConstantExpr {
}
// 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);
More information about the llvm-commits
mailing list