Check that memory allocation succeeds before use.

[trixirt]

Summary

Check that memory allocation succeeds before use.
Rename variable DescInfo to DI for consistency.

[labath]

Isn't this just dead code? a non-nothrow new will never return null http://en.cppreference.com/w/cpp/memory/new/operator_new

[trixirt]

I will change this to try-catch

[sanjoy]

In D47327#1111214, @trixirt wrote:

I will change this to try-catch

We don't use exceptions in LLVM.

Can you elaborate on what the bigger picture is? LLVM is *not* robust against allocation failures, and fixing just this bit won't change anything.

[trixirt]

use nothrow version of new

[trixirt]

As llvm is mostly an api, i assumed that it would be robust and this was a one-off.
Anything big should be done automagically, so i am going to look at sic-ing clang-tidy and/or the static analyzer at this problem.

The lack of exception handling i can understand for performance reasons but it does put normal use of the std library in a bind if like this case the default uses exceptions.

It would be nice if there was project wide design on how to handle exceptions/errors.
If there is please point me at it.

[sanjoy]

In D47327#1111520, @trixirt wrote:

As llvm is mostly an api, i assumed that it would be robust and this was a one-off.
Anything big should be done automagically, so i am going to look at sic-ing clang-tidy and/or the static analyzer at this problem.

Before spending time on this, I'd suggest asking on llvm-dev@ about whether we _should_ make LLVM robust against allocation failures. I believe (but you should still ask) the consensus will be that it isn't worth the engineering complexity to make LLVM as a library robust against allocation failures, and that if you do want this, the right fix is to fork out to LLVM as a separate process.

The lack of exception handling i can understand for performance reasons but it does put normal use of the std library in a bind if like this case the default uses exceptions.

It would be nice if there was project wide design on how to handle exceptions/errors.
If there is please point me at it.

https://llvm.org/docs/CodingStandards.html#do-not-use-rtti-or-exceptions

[trixirt]

I agree on the consensus building.

However I can see the problem of default new not returning nullptr being a general problem.
So something automagic needs to be created if it doesn't exist already.

lib/IR/User.cpp

void *User::allocateFixedOperandUser(size_t Size, unsigned Us,
 
   static_assert(sizeof(DescriptorInfo) % sizeof(void *) == 0, "Required below");
 
   unsigned DescBytesToAllocate =
       DescBytes == 0 ? 0 : (DescBytes + sizeof(DescriptorInfo));
   assert(DescBytesToAllocate % sizeof(void *) == 0 &&
          "We need this to satisfy alignment constraints for Uses");
 
+  User *Obj = nullptr;
   uint8_t *Storage = static_cast<uint8_t *>(
-      ::operator new(Size + sizeof(Use) * Us + DescBytesToAllocate));
+    ::operator new(Size + sizeof(Use) * Us + DescBytesToAllocate, std::nothrow));
+  if (Storage != nullptr) {
     Use *Start = reinterpret_cast<Use *>(Storage + DescBytesToAllocate);
     Use *End = Start + Us;
-  User *Obj = reinterpret_cast<User*>(End);
+    Obj = reinterpret_cast<User*>(End);
     Obj->NumUserOperands = Us;
     Obj->HasHungOffUses = false;
     Obj->HasDescriptor = DescBytes != 0;
     Use::initTags(Start, End);
 
     if (DescBytes != 0) {
-    auto *DescInfo = reinterpret_cast<DescriptorInfo *>(Storage + DescBytes);
-    DescInfo->SizeInBytes = DescBytes;
+      auto *DI = reinterpret_cast<DescriptorInfo *>(Storage + DescBytes);
+      DI->SizeInBytes = DescBytes;
+    }
   }
-
   return Obj;
 }
 
 void *User::operator new(size_t Size, unsigned Us) {
   return allocateFixedOperandUser(Size, Us, 0);
 }
 
 void *User::operator new(size_t Size, unsigned Us, unsigned DescBytes) {
   return allocateFixedOperandUser(Size, Us, DescBytes);
 }
 
 void *User::operator new(size_t Size) {
   // Allocate space for a single Use*
-  void *Storage = ::operator new(Size + sizeof(Use *));
+  User *Obj = nullptr;
+  void *Storage = ::operator new(Size + sizeof(Use *), std::nothrow);
+  if (Storage != nullptr) {
     Use **HungOffOperandList = static_cast<Use **>(Storage);
-  User *Obj = reinterpret_cast<User *>(HungOffOperandList + 1);
+    Obj = reinterpret_cast<User *>(HungOffOperandList + 1);
     Obj->NumUserOperands = 0;
     Obj->HasHungOffUses = true;
     Obj->HasDescriptor = false;
     *HungOffOperandList = nullptr;
+  }
   return Obj;
 }
 
 //===----------------------------------------------------------------------===//
 //                         User operator delete Implementation
 //===----------------------------------------------------------------------===//
 
 void User::operator delete(void *Usr) {