Apply review feedback

Author: marcauberer

llvm/include/llvm/IR/User.h

@@ -56,22 +56,22 @@ class User : public Value {
   /// Indicates this User has operands "hung off" in another allocation.
   struct HungOffOperandsAllocMarker {
     /// The number of operands for this User.
-    const unsigned NumOps;
+    unsigned NumOps;
   };
 
   /// Indicates this User has operands co-allocated.
   struct IntrusiveOperandsAllocMarker {
     /// The number of operands for this User.
-    const unsigned NumOps;
+    unsigned NumOps;
   };
 
-  /// Indicates this User has operands and a descriptor co-allocated .
+  /// Indicates this User has operands and a descriptor co-allocated.
   struct IntrusiveOperandsAndDescriptorAllocMarker {
     /// The number of operands for this User.
-    const unsigned NumOps;
+    unsigned NumOps;
     /// The number of bytes to allocate for the descriptor. Must be divisible by
     /// `sizeof(void *)`.
-    const unsigned DescBytes;
+    unsigned DescBytes;
   };
 
   /// Information about how a User object was allocated, to be passed into the

llvm/lib/IR/User.cpp

@@ -20,14 +20,13 @@ class BasicBlock;
 
 bool User::replaceUsesOfWith(Value *From, Value *To) {
   bool Changed = false;
-  if (From == To)
-    return Changed; // Duh what?
+  if (From == To) return Changed;   // Duh what?
 
   assert((!isa<Constant>(this) || isa<GlobalValue>(this)) &&
          "Cannot call User::replaceUsesOfWith on a constant!");
 
   for (unsigned i = 0, E = getNumOperands(); i != E; ++i)
-    if (getOperand(i) == From) { // Is This operand is pointing to oldval?
+    if (getOperand(i) == From) {  // Is This operand is pointing to oldval?
       // The side effects of this setOperand call include linking to
       // "To", adding "this" to the uses list of To, and
       // most importantly, removing "this" from the use list of "From".
@@ -58,7 +57,7 @@ void User::allocHungoffUses(unsigned N, bool IsPhi) {
   size_t size = N * sizeof(Use);
   if (IsPhi)
     size += N * sizeof(BasicBlock *);
-  Use *Begin = static_cast<Use *>(::operator new(size));
+  Use *Begin = static_cast<Use*>(::operator new(size));
   Use *End = Begin + N;
   setOperandList(Begin);
   for (; Begin != End; Begin++)
@@ -146,9 +145,6 @@ void *User::allocateFixedOperandUser(size_t Size, unsigned Us,
   Use *Start = reinterpret_cast<Use *>(Storage + DescBytesToAllocate);
   Use *End = Start + Us;
   User *Obj = reinterpret_cast<User *>(End);
-  Obj->NumUserOperands = Us;
-  Obj->HasHungOffUses = false;
-  Obj->HasDescriptor = DescBytes != 0;
   for (; Start != End; Start++)
     new (Start) Use(Obj);
 
@@ -175,9 +171,6 @@ void *User::operator new(size_t Size, HungOffOperandsAllocMarker) {
   void *Storage = ::operator new(Size + sizeof(Use *));
   Use **HungOffOperandList = static_cast<Use **>(Storage);
   User *Obj = reinterpret_cast<User *>(HungOffOperandList + 1);
-  Obj->NumUserOperands = 0;
-  Obj->HasHungOffUses = true;
-  Obj->HasDescriptor = false;
   *HungOffOperandList = nullptr;
   return Obj;
 }
@@ -214,12 +207,7 @@ LLVM_NO_SANITIZE_MEMORY_ATTRIBUTE void User::operator delete(void *Usr) {
 // Repress memory sanitization, due to use-after-destroy by operator
 // delete. Bug report 24578 identifies this issue.
 LLVM_NO_SANITIZE_MEMORY_ATTRIBUTE void
-User::operator delete(void *Usr, const HungOffOperandsAllocMarker Marker) {
-  // Note: If a subclass manipulates the information which is required to
-  // calculate the Usr memory pointer, e.g. NumUserOperands, the operator
-  // delete of that subclass has to restore the changed information to the
-  // original value, since the dtor of that class is not called if the ctor
-  // fails.
+User::operator delete(void *Usr, HungOffOperandsAllocMarker Marker) {
   Use **HungOffOperandList = static_cast<Use **>(Usr) - 1;
   // drop the hung off uses.
   Use::zap(*HungOffOperandList, *HungOffOperandList + Marker.NumOps,
@@ -230,11 +218,7 @@ User::operator delete(void *Usr, const HungOffOperandsAllocMarker Marker) {
 // Repress memory sanitization, due to use-after-destroy by operator
 // delete. Bug report 24578 identifies this issue.
 LLVM_NO_SANITIZE_MEMORY_ATTRIBUTE void
-User::operator delete(void *Usr, const IntrusiveOperandsAllocMarker Marker) {
-  // Note: If a subclass manipulates the information which is required to
-  // calculate the Usr memory pointer, e.g. NumUserOperands, the operator delete
-  // of that subclass has to restore the changed information to the original
-  // value, since the dtor of that class is not called if the ctor fails.
+User::operator delete(void *Usr, IntrusiveOperandsAllocMarker Marker) {
   Use *Storage = static_cast<Use *>(Usr) - Marker.NumOps;
   Use::zap(Storage, Storage + Marker.NumOps, /* Delete */ false);
   ::operator delete(Storage);
@@ -244,11 +228,7 @@ User::operator delete(void *Usr, const IntrusiveOperandsAllocMarker Marker) {
 // delete. Bug report 24578 identifies this issue.
 LLVM_NO_SANITIZE_MEMORY_ATTRIBUTE void
 User::operator delete(void *Usr,
-                      const IntrusiveOperandsAndDescriptorAllocMarker Marker) {
-  // Note: If a subclass manipulates the information which is required to
-  // calculate the Usr memory pointer, e.g. NumUserOperands, the operator delete
-  // of that subclass has to restore the changed information to the original
-  // value, since the dtor of that class is not called if the ctor fails.
+                      IntrusiveOperandsAndDescriptorAllocMarker Marker) {
   Use *UseBegin = static_cast<Use *>(Usr) - Marker.NumOps;
   Use::zap(UseBegin, UseBegin + Marker.NumOps, /* Delete */ false);