Index: lib/Transforms/Scalar/SROA.cpp
===================================================================
--- lib/Transforms/Scalar/SROA.cpp
+++ lib/Transforms/Scalar/SROA.cpp
@@ -2387,6 +2387,21 @@
                                               LI.isVolatile(), LI.getName());
       if (LI.isVolatile())
         NewLI->setAtomic(LI.getOrdering(), LI.getSynchScope());
+
+      SmallVector<std::pair<unsigned, MDNode *>, 8> MD;
+      LI.getAllMetadata(MD);
+      // Try to preserve as much metadata as possible
+      for (const auto &MDPair : MD) {
+        unsigned ID = MDPair.first;
+        MDNode *N = MDPair.second;
+        switch (ID) {
+        case LLVMContext::MD_nonnull:
+          if (TargetTy->isPointerTy()) {
+            NewLI->setMetadata(ID, N);
+            break;
+          }
+        }
+      }
       V = NewLI;
 
       // If this is an integer load past the end of the slice (which means the
Index: lib/Transforms/Utils/PromoteMemoryToRegister.cpp
===================================================================
--- lib/Transforms/Utils/PromoteMemoryToRegister.cpp
+++ lib/Transforms/Utils/PromoteMemoryToRegister.cpp
@@ -15,7 +15,6 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "llvm/Transforms/Utils/PromoteMemToReg.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/STLExtras.h"
@@ -23,6 +22,7 @@
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/Analysis/AliasSetTracker.h"
+#include "llvm/Analysis/AssumptionCache.h"
 #include "llvm/Analysis/InstructionSimplify.h"
 #include "llvm/Analysis/IteratedDominanceFrontier.h"
 #include "llvm/Analysis/ValueTracking.h"
@@ -38,6 +38,7 @@
 #include "llvm/IR/Metadata.h"
 #include "llvm/IR/Module.h"
 #include "llvm/Transforms/Utils/Local.h"
+#include "llvm/Transforms/Utils/PromoteMemToReg.h"
 #include <algorithm>
 using namespace llvm;
 
@@ -334,9 +335,9 @@
 /// and thus must be phi-ed with undef. We fall back to the standard alloca
 /// promotion algorithm in that case.
 static bool rewriteSingleStoreAlloca(AllocaInst *AI, AllocaInfo &Info,
-                                     LargeBlockInfo &LBI,
-                                     DominatorTree &DT,
-                                     AliasSetTracker *AST) {
+                                     LargeBlockInfo &LBI, DominatorTree &DT,
+                                     AliasSetTracker *AST,
+                                     AssumptionCache *AC) {
   StoreInst *OnlyStore = Info.OnlyStore;
   bool StoringGlobalVal = !isa<Instruction>(OnlyStore->getOperand(0));
   BasicBlock *StoreBB = OnlyStore->getParent();
@@ -387,6 +388,21 @@
     // code.
     if (ReplVal == LI)
       ReplVal = UndefValue::get(LI->getType());
+
+    // If the load was marked as nonnull we don't want to lose
+    // that information when we erase this Load. So we preserve
+    // it with an assume.
+    if (AC && LI->getMetadata(LLVMContext::MD_nonnull)) {
+      Function *AssumeIntrinsic =
+          Intrinsic::getDeclaration(LI->getModule(), Intrinsic::assume);
+      ICmpInst *LoadNotNull = new ICmpInst(
+          ICmpInst::ICMP_NE, LI, Constant::getNullValue(LI->getType()));
+      LoadNotNull->insertAfter(LI);
+      CallInst *CI = CallInst::Create(AssumeIntrinsic, {LoadNotNull});
+      CI->insertAfter(LoadNotNull);
+      AC->registerAssumption(CI);
+    }
+
     LI->replaceAllUsesWith(ReplVal);
     if (AST && LI->getType()->isPointerTy())
       AST->deleteValue(LI);
@@ -553,7 +569,7 @@
     // If there is only a single store to this value, replace any loads of
     // it that are directly dominated by the definition with the value stored.
     if (Info.DefiningBlocks.size() == 1) {
-      if (rewriteSingleStoreAlloca(AI, Info, LBI, DT, AST)) {
+      if (rewriteSingleStoreAlloca(AI, Info, LBI, DT, AST, AC)) {
         // The alloca has been processed, move on.
         RemoveFromAllocasList(AllocaNum);
         ++NumSingleStore;
@@ -940,6 +956,20 @@
 
       Value *V = IncomingVals[AI->second];
 
+      // If the load was marked as nonnull we don't want to lose
+      // that information when we erase this Load. So we preserve
+      // it with an assume.
+      if (AC && LI->getMetadata(LLVMContext::MD_nonnull)) {
+        Function *AssumeIntrinsic =
+            Intrinsic::getDeclaration(LI->getModule(), Intrinsic::assume);
+        ICmpInst *LoadNotNull = new ICmpInst(
+            ICmpInst::ICMP_NE, LI, Constant::getNullValue(LI->getType()));
+        LoadNotNull->insertAfter(LI);
+        CallInst *CI = CallInst::Create(AssumeIntrinsic, {LoadNotNull});
+        CI->insertAfter(LoadNotNull);
+        AC->registerAssumption(CI);
+      }
+
       // Anything using the load now uses the current value.
       LI->replaceAllUsesWith(V);
       if (AST && LI->getType()->isPointerTy())
Index: test/Transforms/SROA/preserve-nonnull.ll
===================================================================
--- /dev/null
+++ test/Transforms/SROA/preserve-nonnull.ll
@@ -0,0 +1,27 @@
+; RUN: opt < %s -sroa -instcombine -S | FileCheck %s
+;
+; Make sure that SROA doesn't lose nonnull metadata
+; on loads from allocas that get optimized out.
+
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+; CHECK-LABEL: yummy_nonnull
+; CHECK: [[RETURN:%(.*)]] = load float*, float** %0, align 8, !nonnull !0
+; CHECK: ret float* {{.*}}[[RETURN]]
+
+define float* @yummy_nonnull(float**) {
+entry-block:
+	%buf = alloca float*
+
+	%_0_i8 = bitcast float** %0 to i8*
+	%_buf_i8 = bitcast float** %buf to i8*
+	call void @llvm.memcpy.p0i8.p0i8.i64(i8* %_buf_i8, i8* %_0_i8, i64 8, i32 8, i1 false)
+
+	%ret = load float*, float** %buf, align 8, !nonnull !0
+	ret float* %ret
+}
+
+declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture writeonly, i8* nocapture readonly, i64, i32, i1)
+
+!0 = !{}