Update aosp/master LLVM for rebase to r222494.

Change-Id: Ic787f5e0124df789bd26f3f24680f45e678eef2d

11 files changed, 316 insertions, 35 deletions

diff --git a/unittests/IR/CMakeLists.txt b/unittests/IR/CMakeLists.txt
index b439d59..a046209 100644
--- a/unittests/IR/CMakeLists.txt
+++ b/unittests/IR/CMakeLists.txt
@@ -10,6 +10,7 @@ set(IRSources
   AttributesTest.cpp
   ConstantRangeTest.cpp
   ConstantsTest.cpp
+  DebugInfoTest.cpp
   DominatorTreeTest.cpp
   IRBuilderTest.cpp
   InstructionsTest.cpp
@@ -21,6 +22,7 @@ set(IRSources
   PatternMatch.cpp
   TypeBuilderTest.cpp
   TypesTest.cpp
+  UseTest.cpp
   UserTest.cpp
   ValueHandleTest.cpp
   ValueMapTest.cpp
diff --git a/unittests/IR/ConstantsTest.cpp b/unittests/IR/ConstantsTest.cpp
index 0cd8549..5414b25 100644
--- a/unittests/IR/ConstantsTest.cpp
+++ b/unittests/IR/ConstantsTest.cpp
@@ -274,5 +274,78 @@ TEST(ConstantsTest, ReplaceWithConstantTest) {
 
 #undef CHECK
 
+TEST(ConstantsTest, ConstantArrayReplaceWithConstant) {
+  LLVMContext Context;
+  std::unique_ptr<Module> M(new Module("MyModule", Context));
+
+  Type *IntTy = Type::getInt8Ty(Context);
+  ArrayType *ArrayTy = ArrayType::get(IntTy, 2);
+  Constant *A01Vals[2] = {ConstantInt::get(IntTy, 0),
+                          ConstantInt::get(IntTy, 1)};
+  Constant *A01 = ConstantArray::get(ArrayTy, A01Vals);
+
+  Constant *Global = new GlobalVariable(*M, IntTy, false,
+                                        GlobalValue::ExternalLinkage, nullptr);
+  Constant *GlobalInt = ConstantExpr::getPtrToInt(Global, IntTy);
+  Constant *A0GVals[2] = {ConstantInt::get(IntTy, 0), GlobalInt};
+  Constant *A0G = ConstantArray::get(ArrayTy, A0GVals);
+  ASSERT_NE(A01, A0G);
+
+  GlobalVariable *RefArray =
+      new GlobalVariable(*M, ArrayTy, false, GlobalValue::ExternalLinkage, A0G);
+  ASSERT_EQ(A0G, RefArray->getInitializer());
+
+  GlobalInt->replaceAllUsesWith(ConstantInt::get(IntTy, 1));
+  ASSERT_EQ(A01, RefArray->getInitializer());
+}
+
+TEST(ConstantsTest, ConstantExprReplaceWithConstant) {
+  LLVMContext Context;
+  std::unique_ptr<Module> M(new Module("MyModule", Context));
+
+  Type *IntTy = Type::getInt8Ty(Context);
+  Constant *G1 = new GlobalVariable(*M, IntTy, false,
+                                    GlobalValue::ExternalLinkage, nullptr);
+  Constant *G2 = new GlobalVariable(*M, IntTy, false,
+                                    GlobalValue::ExternalLinkage, nullptr);
+  ASSERT_NE(G1, G2);
+
+  Constant *Int1 = ConstantExpr::getPtrToInt(G1, IntTy);
+  Constant *Int2 = ConstantExpr::getPtrToInt(G2, IntTy);
+  ASSERT_NE(Int1, Int2);
+
+  GlobalVariable *Ref =
+      new GlobalVariable(*M, IntTy, false, GlobalValue::ExternalLinkage, Int1);
+  ASSERT_EQ(Int1, Ref->getInitializer());
+
+  G1->replaceAllUsesWith(G2);
+  ASSERT_EQ(Int2, Ref->getInitializer());
+}
+
+TEST(ConstantsTest, GEPReplaceWithConstant) {
+  LLVMContext Context;
+  std::unique_ptr<Module> M(new Module("MyModule", Context));
+
+  Type *IntTy = Type::getInt32Ty(Context);
+  Type *PtrTy = PointerType::get(IntTy, 0);
+  auto *C1 = ConstantInt::get(IntTy, 1);
+  auto *Placeholder = new GlobalVariable(
+      *M, IntTy, false, GlobalValue::ExternalWeakLinkage, nullptr);
+  auto *GEP = ConstantExpr::getGetElementPtr(Placeholder, C1);
+  ASSERT_EQ(GEP->getOperand(0), Placeholder);
+
+  auto *Ref =
+      new GlobalVariable(*M, PtrTy, false, GlobalValue::ExternalLinkage, GEP);
+  ASSERT_EQ(GEP, Ref->getInitializer());
+
+  auto *Global = new GlobalVariable(*M, PtrTy, false,
+                                    GlobalValue::ExternalLinkage, nullptr);
+  auto *Alias = GlobalAlias::create(IntTy, 0, GlobalValue::ExternalLinkage,
+                                    "alias", Global, M.get());
+  Placeholder->replaceAllUsesWith(Alias);
+  ASSERT_EQ(GEP, Ref->getInitializer());
+  ASSERT_EQ(GEP->getOperand(0), Alias);
+}
+
 }  // end anonymous namespace
 }  // end namespace llvm
diff --git a/unittests/IR/DebugInfoTest.cpp b/unittests/IR/DebugInfoTest.cpp
new file mode 100644
index 0000000..1fa851e
--- /dev/null
+++ b/unittests/IR/DebugInfoTest.cpp
@@ -0,0 +1,68 @@
+//===- llvm/unittest/IR/DebugInfo.cpp - DebugInfo tests -------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/IR/DebugInfo.h"
+#include "gtest/gtest.h"
+
+using namespace llvm;
+
+namespace llvm {
+
+static void PrintTo(const StringRef &S, ::std::ostream *os) {
+  *os << "(" << (const void *)S.data() << "," << S.size() << ") = '";
+  for (auto C : S)
+    if (C)
+      *os << C;
+    else
+      *os << "\\00";
+  *os << "'";
+}
+static void PrintTo(const DIHeaderFieldIterator &I, ::std::ostream *os) {
+  PrintTo(I.getCurrent(), os);
+  *os << " in ";
+  PrintTo(I.getHeader(), os);
+}
+
+} // end namespace llvm
+
+namespace {
+
+#define MAKE_FIELD_ITERATOR(S)                                                 \
+  DIHeaderFieldIterator(StringRef(S, sizeof(S) - 1))
+TEST(DebugInfoTest, DIHeaderFieldIterator) {
+  ASSERT_EQ(DIHeaderFieldIterator(), DIHeaderFieldIterator());
+
+  ASSERT_NE(DIHeaderFieldIterator(), MAKE_FIELD_ITERATOR(""));
+  ASSERT_EQ(DIHeaderFieldIterator(), ++MAKE_FIELD_ITERATOR(""));
+  ASSERT_EQ("", *DIHeaderFieldIterator(""));
+
+  ASSERT_NE(DIHeaderFieldIterator(), MAKE_FIELD_ITERATOR("stuff"));
+  ASSERT_EQ(DIHeaderFieldIterator(), ++MAKE_FIELD_ITERATOR("stuff"));
+  ASSERT_EQ("stuff", *DIHeaderFieldIterator("stuff"));
+
+  ASSERT_NE(DIHeaderFieldIterator(), MAKE_FIELD_ITERATOR("st\0uff"));
+  ASSERT_NE(DIHeaderFieldIterator(), ++MAKE_FIELD_ITERATOR("st\0uff"));
+  ASSERT_EQ(DIHeaderFieldIterator(), ++++MAKE_FIELD_ITERATOR("st\0uff"));
+  ASSERT_EQ("st", *MAKE_FIELD_ITERATOR("st\0uff"));
+  ASSERT_EQ("uff", *++MAKE_FIELD_ITERATOR("st\0uff"));
+
+  ASSERT_NE(DIHeaderFieldIterator(), MAKE_FIELD_ITERATOR("stuff\0"));
+  ASSERT_NE(DIHeaderFieldIterator(), ++MAKE_FIELD_ITERATOR("stuff\0"));
+  ASSERT_EQ(DIHeaderFieldIterator(), ++++MAKE_FIELD_ITERATOR("stuff\0"));
+  ASSERT_EQ("stuff", *MAKE_FIELD_ITERATOR("stuff\0"));
+  ASSERT_EQ("", *++MAKE_FIELD_ITERATOR("stuff\0"));
+
+  ASSERT_NE(DIHeaderFieldIterator(), MAKE_FIELD_ITERATOR("\0stuff"));
+  ASSERT_NE(DIHeaderFieldIterator(), ++MAKE_FIELD_ITERATOR("\0stuff"));
+  ASSERT_EQ(DIHeaderFieldIterator(), ++++MAKE_FIELD_ITERATOR("\0stuff"));
+  ASSERT_EQ("", *MAKE_FIELD_ITERATOR("\0stuff"));
+  ASSERT_EQ("stuff", *++MAKE_FIELD_ITERATOR("\0stuff"));
+}
+
+} // end namespace
diff --git a/unittests/IR/DominatorTreeTest.cpp b/unittests/IR/DominatorTreeTest.cpp
index ab43d1c..6c43d6f 100644
--- a/unittests/IR/DominatorTreeTest.cpp
+++ b/unittests/IR/DominatorTreeTest.cpp
@@ -186,8 +186,7 @@ namespace llvm {
     };
     char DPass::ID = 0;
 
-
-    Module* makeLLVMModule(DPass *P) {
+    std::unique_ptr<Module> makeLLVMModule(DPass *P) {
       const char *ModuleStrig =
         "declare i32 @g()\n" \
         "define void @f(i32 %x) {\n" \
@@ -213,12 +212,12 @@ namespace llvm {
         "}\n";
       LLVMContext &C = getGlobalContext();
       SMDiagnostic Err;
-      return ParseAssemblyString(ModuleStrig, nullptr, Err, C);
+      return parseAssemblyString(ModuleStrig, Err, C);
     }
 
     TEST(DominatorTree, Unreachable) {
       DPass *P = new DPass();
-      std::unique_ptr<Module> M(makeLLVMModule(P));
+      std::unique_ptr<Module> M = makeLLVMModule(P);
       PassManager Passes;
       Passes.add(P);
       Passes.run(*M);
diff --git a/unittests/IR/IRBuilderTest.cpp b/unittests/IR/IRBuilderTest.cpp
index 2108575..df5c840 100644
--- a/unittests/IR/IRBuilderTest.cpp
+++ b/unittests/IR/IRBuilderTest.cpp
@@ -189,12 +189,16 @@ TEST_F(IRBuilderTest, FastMathFlags) {
 
   Builder.clearFastMathFlags();
 
+  // To test a copy, make sure that a '0' and a '1' change state. 
   F = Builder.CreateFDiv(F, F);
   ASSERT_TRUE(isa<Instruction>(F));
   FDiv = cast<Instruction>(F);
   EXPECT_FALSE(FDiv->getFastMathFlags().any());
+  FDiv->setHasAllowReciprocal(true);
+  FAdd->setHasAllowReciprocal(false);
   FDiv->copyFastMathFlags(FAdd);
   EXPECT_TRUE(FDiv->hasNoNaNs());
+  EXPECT_FALSE(FDiv->hasAllowReciprocal());
 
 }
 
diff --git a/unittests/IR/LegacyPassManagerTest.cpp b/unittests/IR/LegacyPassManagerTest.cpp
index 9c2a835..4efc2f5 100644
--- a/unittests/IR/LegacyPassManagerTest.cpp
+++ b/unittests/IR/LegacyPassManagerTest.cpp
@@ -54,11 +54,11 @@ namespace llvm {
       static char run;
       static char ID;
       ModuleNDNM() : ModulePass(ID) { }
-      virtual bool runOnModule(Module &M) {
+      bool runOnModule(Module &M) override {
         run++;
         return false;
       }
-      virtual void getAnalysisUsage(AnalysisUsage &AU) const {
+      void getAnalysisUsage(AnalysisUsage &AU) const override {
         AU.setPreservesAll();
       }
     };
@@ -70,7 +70,7 @@ namespace llvm {
       static char run;
       static char ID;
       ModuleNDM() : ModulePass(ID) {}
-      virtual bool runOnModule(Module &M) {
+      bool runOnModule(Module &M) override {
         run++;
         return true;
       }
@@ -83,7 +83,7 @@ namespace llvm {
       static char run;
       static char ID;
       ModuleNDM2() : ModulePass(ID) {}
-      virtual bool runOnModule(Module &M) {
+      bool runOnModule(Module &M) override {
         run++;
         return true;
       }
@@ -98,12 +98,12 @@ namespace llvm {
       ModuleDNM() : ModulePass(ID) {
         initializeModuleNDMPass(*PassRegistry::getPassRegistry());
       }
-      virtual bool runOnModule(Module &M) {
+      bool runOnModule(Module &M) override {
         EXPECT_TRUE(getAnalysisIfAvailable<DataLayoutPass>());
         run++;
         return false;
       }
-      virtual void getAnalysisUsage(AnalysisUsage &AU) const {
+      void getAnalysisUsage(AnalysisUsage &AU) const override {
         AU.addRequired<ModuleNDM>();
         AU.setPreservesAll();
       }
@@ -139,7 +139,7 @@ namespace llvm {
         runc = 0;
       }
 
-      virtual void releaseMemory() {
+      void releaseMemory() override {
         EXPECT_GT(runc, 0);
         EXPECT_GT(allocated, 0);
         allocated--;
@@ -157,12 +157,12 @@ namespace llvm {
       using llvm::Pass::doInitialization;
       using llvm::Pass::doFinalization;
 #endif
-      virtual bool doInitialization(T &t) {
+      bool doInitialization(T &t) override {
         EXPECT_FALSE(PassTestBase<P>::initialized);
         PassTestBase<P>::initialized = true;
         return false;
       }
-      virtual bool doFinalization(T &t) {
+      bool doFinalization(T &t) override {
         EXPECT_FALSE(PassTestBase<P>::finalized);
         PassTestBase<P>::finalized = true;
         EXPECT_EQ(0, PassTestBase<P>::allocated);
@@ -175,7 +175,7 @@ namespace llvm {
       CGPass() {
         initializeCGPassPass(*PassRegistry::getPassRegistry());
       }
-      virtual bool runOnSCC(CallGraphSCC &SCMM) {
+      bool runOnSCC(CallGraphSCC &SCMM) override {
         EXPECT_TRUE(getAnalysisIfAvailable<DataLayoutPass>());
         run();
         return false;
@@ -184,7 +184,7 @@ namespace llvm {
 
     struct FPass : public PassTest<Module, FunctionPass> {
     public:
-      virtual bool runOnFunction(Function &F) {
+      bool runOnFunction(Function &F) override {
         // FIXME: PR4112
         // EXPECT_TRUE(getAnalysisIfAvailable<DataLayout>());
         run();
@@ -209,17 +209,17 @@ namespace llvm {
       }
       using llvm::Pass::doInitialization;
       using llvm::Pass::doFinalization;
-      virtual bool doInitialization(Loop* L, LPPassManager &LPM) {
+      bool doInitialization(Loop* L, LPPassManager &LPM) override {
         initialized = true;
         initcount++;
         return false;
       }
-      virtual bool runOnLoop(Loop *L, LPPassManager &LPM) {
+      bool runOnLoop(Loop *L, LPPassManager &LPM) override {
         EXPECT_TRUE(getAnalysisIfAvailable<DataLayoutPass>());
         run();
         return false;
       }
-      virtual bool doFinalization() {
+      bool doFinalization() override {
         fincount++;
         finalized = true;
         return false;
@@ -242,25 +242,25 @@ namespace llvm {
         inited = 0;
         fin = 0;
       }
-      virtual bool doInitialization(Module &M) {
+      bool doInitialization(Module &M) override {
         EXPECT_FALSE(initialized);
         initialized = true;
         return false;
       }
-      virtual bool doInitialization(Function &F) {
+      bool doInitialization(Function &F) override {
         inited++;
         return false;
       }
-      virtual bool runOnBasicBlock(BasicBlock &BB) {
+      bool runOnBasicBlock(BasicBlock &BB) override {
         EXPECT_TRUE(getAnalysisIfAvailable<DataLayoutPass>());
         run();
         return false;
       }
-      virtual bool doFinalization(Function &F) {
+      bool doFinalization(Function &F) override {
         fin++;
         return false;
       }
-      virtual bool doFinalization(Module &M) {
+      bool doFinalization(Module &M) override {
         EXPECT_FALSE(finalized);
         finalized = true;
         EXPECT_EQ(0, allocated);
@@ -276,7 +276,7 @@ namespace llvm {
       OnTheFlyTest() : ModulePass(ID) {
         initializeFPassPass(*PassRegistry::getPassRegistry());
       }
-      virtual bool runOnModule(Module &M) {
+      bool runOnModule(Module &M) override {
         EXPECT_TRUE(getAnalysisIfAvailable<DataLayoutPass>());
         for (Module::iterator I=M.begin(),E=M.end(); I != E; ++I) {
           Function &F = *I;
@@ -287,7 +287,7 @@ namespace llvm {
         }
         return false;
       }
-      virtual void getAnalysisUsage(AnalysisUsage &AU) const {
+      void getAnalysisUsage(AnalysisUsage &AU) const override {
         AU.addRequired<FPass>();
       }
     };
@@ -303,7 +303,7 @@ namespace llvm {
       mNDM->run = mNDNM->run = mDNM->run = mNDM2->run = 0;
 
       PassManager Passes;
-      Passes.add(new DataLayoutPass(&M));
+      Passes.add(new DataLayoutPass());
       Passes.add(mNDM2);
       Passes.add(mNDM);
       Passes.add(mNDNM);
@@ -327,7 +327,7 @@ namespace llvm {
       mNDM->run = mNDNM->run = mDNM->run = mNDM2->run = 0;
 
       PassManager Passes;
-      Passes.add(new DataLayoutPass(&M));
+      Passes.add(new DataLayoutPass());
       Passes.add(mNDM);
       Passes.add(mNDNM);
       Passes.add(mNDM2);// invalidates mNDM needed by mDNM
@@ -349,7 +349,7 @@ namespace llvm {
       std::unique_ptr<Module> M(makeLLVMModule());
       T *P = new T();
       PassManager Passes;
-      Passes.add(new DataLayoutPass(M.get()));
+      Passes.add(new DataLayoutPass());
       Passes.add(P);
       Passes.run(*M);
       T::finishedOK(run);
@@ -360,7 +360,7 @@ namespace llvm {
       Module *M = makeLLVMModule();
       T *P = new T();
       PassManager Passes;
-      Passes.add(new DataLayoutPass(M));
+      Passes.add(new DataLayoutPass());
       Passes.add(P);
       Passes.run(*M);
       T::finishedOK(run, N);
@@ -398,7 +398,7 @@ namespace llvm {
         SCOPED_TRACE("Running OnTheFlyTest");
         struct OnTheFlyTest *O = new OnTheFlyTest();
         PassManager Passes;
-        Passes.add(new DataLayoutPass(M));
+        Passes.add(new DataLayoutPass());
         Passes.add(O);
         Passes.run(*M);
 
diff --git a/unittests/IR/PassManagerTest.cpp b/unittests/IR/PassManagerTest.cpp
index 25037a7..d493156 100644
--- a/unittests/IR/PassManagerTest.cpp
+++ b/unittests/IR/PassManagerTest.cpp
@@ -168,7 +168,7 @@ struct TestInvalidationFunctionPass {
 Module *parseIR(const char *IR) {
   LLVMContext &C = getGlobalContext();
   SMDiagnostic Err;
-  return ParseAssemblyString(IR, nullptr, Err, C);
+  return parseAssemblyString(IR, Err, C).release();
 }
 
 class PassManagerTest : public ::testing::Test {
diff --git a/unittests/IR/UseTest.cpp b/unittests/IR/UseTest.cpp
new file mode 100644
index 0000000..3f33ca6
--- /dev/null
+++ b/unittests/IR/UseTest.cpp
@@ -0,0 +1,112 @@
+//===- llvm/unittest/IR/UseTest.cpp - Use unit tests ----------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/AsmParser/Parser.h"
+#include "llvm/IR/Function.h"
+#include "llvm/IR/LLVMContext.h"
+#include "llvm/IR/Module.h"
+#include "llvm/IR/User.h"
+#include "llvm/IR/Instructions.h"
+#include "llvm/Support/Format.h"
+#include "llvm/Support/SourceMgr.h"
+#include "gtest/gtest.h"
+
+using namespace llvm;
+
+namespace {
+
+TEST(UseTest, sort) {
+  LLVMContext C;
+
+  const char *ModuleString = "define void @f(i32 %x) {\n"
+                             "entry:\n"
+                             "  %v0 = add i32 %x, 0\n"
+                             "  %v2 = add i32 %x, 2\n"
+                             "  %v5 = add i32 %x, 5\n"
+                             "  %v1 = add i32 %x, 1\n"
+                             "  %v3 = add i32 %x, 3\n"
+                             "  %v7 = add i32 %x, 7\n"
+                             "  %v6 = add i32 %x, 6\n"
+                             "  %v4 = add i32 %x, 4\n"
+                             "  ret void\n"
+                             "}\n";
+  SMDiagnostic Err;
+  char vnbuf[8];
+  std::unique_ptr<Module> M = parseAssemblyString(ModuleString, Err, C);
+  Function *F = M->getFunction("f");
+  ASSERT_TRUE(F);
+  ASSERT_TRUE(F->arg_begin() != F->arg_end());
+  Argument &X = *F->arg_begin();
+  ASSERT_EQ("x", X.getName());
+
+  X.sortUseList([](const Use &L, const Use &R) {
+    return L.getUser()->getName() < R.getUser()->getName();
+  });
+  unsigned I = 0;
+  for (User *U : X.users()) {
+    snprintf(vnbuf, sizeof(vnbuf), "v%u", I++);
+    EXPECT_EQ(vnbuf, U->getName());
+  }
+  ASSERT_EQ(8u, I);
+
+  X.sortUseList([](const Use &L, const Use &R) {
+    return L.getUser()->getName() > R.getUser()->getName();
+  });
+  I = 0;
+  for (User *U : X.users()) {
+    snprintf(vnbuf, sizeof(vnbuf), "v%u", (7 - I++));
+    EXPECT_EQ(vnbuf, U->getName());
+  }
+  ASSERT_EQ(8u, I);
+}
+
+TEST(UseTest, reverse) {
+  LLVMContext C;
+
+  const char *ModuleString = "define void @f(i32 %x) {\n"
+                             "entry:\n"
+                             "  %v0 = add i32 %x, 0\n"
+                             "  %v2 = add i32 %x, 2\n"
+                             "  %v5 = add i32 %x, 5\n"
+                             "  %v1 = add i32 %x, 1\n"
+                             "  %v3 = add i32 %x, 3\n"
+                             "  %v7 = add i32 %x, 7\n"
+                             "  %v6 = add i32 %x, 6\n"
+                             "  %v4 = add i32 %x, 4\n"
+                             "  ret void\n"
+                             "}\n";
+  SMDiagnostic Err;
+  char vnbuf[8];
+  std::unique_ptr<Module> M = parseAssemblyString(ModuleString, Err, C);
+  Function *F = M->getFunction("f");
+  ASSERT_TRUE(F);
+  ASSERT_TRUE(F->arg_begin() != F->arg_end());
+  Argument &X = *F->arg_begin();
+  ASSERT_EQ("x", X.getName());
+
+  X.sortUseList([](const Use &L, const Use &R) {
+    return L.getUser()->getName() < R.getUser()->getName();
+  });
+  unsigned I = 0;
+  for (User *U : X.users()) {
+    snprintf(vnbuf, sizeof(vnbuf), "v%u", I++);
+    EXPECT_EQ(vnbuf, U->getName());
+  }
+  ASSERT_EQ(8u, I);
+
+  X.reverseUseList();
+  I = 0;
+  for (User *U : X.users()) {
+    snprintf(vnbuf, sizeof(vnbuf), "v%u", (7 - I++));
+    EXPECT_EQ(vnbuf, U->getName());
+  }
+  ASSERT_EQ(8u, I);
+}
+
+} // end anonymous namespace
diff --git a/unittests/IR/UserTest.cpp b/unittests/IR/UserTest.cpp
index eb07e82..5572424 100644
--- a/unittests/IR/UserTest.cpp
+++ b/unittests/IR/UserTest.cpp
@@ -65,7 +65,7 @@ TEST(UserTest, ValueOpIteration) {
                              "  ret void\n"
                              "}\n";
   SMDiagnostic Err;
-  Module *M = ParseAssemblyString(ModuleString, nullptr, Err, C);
+  std::unique_ptr<Module> M = parseAssemblyString(ModuleString, Err, C);
 
   Function *F = M->getFunction("f");
   BasicBlock &ExitBB = F->back();
diff --git a/unittests/IR/ValueMapTest.cpp b/unittests/IR/ValueMapTest.cpp
index 0b7198f..a6bad71 100644
--- a/unittests/IR/ValueMapTest.cpp
+++ b/unittests/IR/ValueMapTest.cpp
@@ -186,11 +186,11 @@ struct LockMutex : ValueMapConfig<KeyT, MutexT> {
   };
   static void onRAUW(const ExtraData &Data, KeyT Old, KeyT New) {
     *Data.CalledRAUW = true;
-    EXPECT_FALSE(Data.M->tryacquire()) << "Mutex should already be locked.";
+    EXPECT_FALSE(Data.M->try_lock()) << "Mutex should already be locked.";
   }
   static void onDelete(const ExtraData &Data, KeyT Old) {
     *Data.CalledDeleted = true;
-    EXPECT_FALSE(Data.M->tryacquire()) << "Mutex should already be locked.";
+    EXPECT_FALSE(Data.M->try_lock()) << "Mutex should already be locked.";
   }
   static MutexT *getMutex(const ExtraData &Data) { return Data.M; }
 };
diff --git a/unittests/IR/ValueTest.cpp b/unittests/IR/ValueTest.cpp
index 61e44a9..4dd0c2c 100644
--- a/unittests/IR/ValueTest.cpp
+++ b/unittests/IR/ValueTest.cpp
@@ -34,7 +34,7 @@ TEST(ValueTest, UsedInBasicBlock) {
                              "  ret void\n"
                              "}\n";
   SMDiagnostic Err;
-  Module *M = ParseAssemblyString(ModuleString, nullptr, Err, C);
+  std::unique_ptr<Module> M = parseAssemblyString(ModuleString, Err, C);
 
   Function *F = M->getFunction("f");
 
@@ -60,6 +60,10 @@ TEST(GlobalTest, CreateAddressSpace) {
                          GlobalVariable::NotThreadLocal,
                          1);
 
+  EXPECT_TRUE(Value::MaximumAlignment == 536870912U);
+  Dummy0->setAlignment(536870912U);
+  EXPECT_EQ(Dummy0->getAlignment(), 536870912U);
+
   // Make sure the address space isn't dropped when returning this.
   Constant *Dummy1 = M->getOrInsertGlobal("dummy", Int32Ty);
   EXPECT_EQ(Dummy0, Dummy1);
@@ -83,4 +87,23 @@ TEST(GlobalTest, CreateAddressSpace) {
   EXPECT_EQ(1u, DummyCast1->getType()->getPointerAddressSpace());
   EXPECT_NE(DummyCast0, DummyCast1) << *DummyCast1;
 }
+
+#ifdef GTEST_HAS_DEATH_TEST
+#ifndef NDEBUG
+TEST(GlobalTest, AlignDeath) {
+  LLVMContext &Ctx = getGlobalContext();
+  std::unique_ptr<Module> M(new Module("TestModule", Ctx));
+  Type *Int32Ty = Type::getInt32Ty(Ctx);
+  GlobalVariable *Var =
+      new GlobalVariable(*M, Int32Ty, true, GlobalValue::ExternalLinkage,
+                         Constant::getAllOnesValue(Int32Ty), "var", nullptr,
+                         GlobalVariable::NotThreadLocal, 1);
+
+  EXPECT_DEATH(Var->setAlignment(536870913U), "Alignment is not a power of 2");
+  EXPECT_DEATH(Var->setAlignment(1073741824U),
+               "Alignment is greater than MaximumAlignment");
+}
+#endif
+#endif
+
 } // end anonymous namespace