Index: lib/IR/Verifier.cpp
===================================================================
--- lib/IR/Verifier.cpp
+++ lib/IR/Verifier.cpp
@@ -45,6 +45,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "llvm/IR/Verifier.h"
+#include "LLVMContextImpl.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/SmallPtrSet.h"
@@ -193,6 +194,12 @@
   /// \brief Track unresolved string-based type references.
   SmallDenseMap<const MDString *, const MDNode *, 32> UnresolvedTypeRefs;
 
+  /// \brief Cache the inverse FunctionData map, to avoid having to reconstruct
+  /// it from the forward map every time it's needed.
+  typedef DenseMap<const ReturnInst *, const Function *>
+      InverseFunctionDataMapTy;
+  InverseFunctionDataMapTy InverseFunctionDataMap;
+
   /// \brief The result type for a landingpad.
   Type *LandingPadResultTy;
 
@@ -241,6 +248,7 @@
     // FIXME: We strip const here because the inst visitor strips const.
     visit(const_cast<Function &>(F));
     InstsInThisBlock.clear();
+    InverseFunctionDataMap.clear();
     LandingPadResultTy = nullptr;
     SawFrameEscape = false;
 
@@ -287,6 +295,8 @@
     // Verify type referneces last.
     verifyTypeRefs();
 
+    InverseFunctionDataMap.clear();
+
     return !Broken;
   }
 
@@ -443,6 +453,18 @@
   InstVisitor<Verifier>::visit(I);
 }
 
+template <typename CB>
+static void ForEachInstructionUser(const Use &TheUse,
+                                   SmallPtrSet<const Value *, 32> &Visited,
+                                   CB &&callback) {
+  if (!Visited.insert(TheUse.getUser()).second)
+    return;
+  if (Instruction *I = dyn_cast<Instruction>(TheUse.getUser()))
+    callback(I);
+  else
+    for (const Use &TheNextUse : TheUse.getUser()->uses())
+      ForEachInstructionUser(TheNextUse, Visited, callback);
+}
 
 void Verifier::visitGlobalValue(const GlobalValue &GV) {
   Assert(!GV.isDeclaration() || GV.hasExternalLinkage() ||
@@ -462,6 +484,46 @@
 
   if (GV.isDeclarationForLinker())
     Assert(!GV.hasComdat(), "Declaration may not be in a Comdat!", &GV);
+
+  // Verify that this GlobalValue is only used in this module.
+  // This map is used to avoid visiting uses twice. We can arrive at a user
+  // twice, if they have multiple operands. In particular for very large
+  // constant expressions, we can arrive at a particular user many times.
+  SmallPtrSet<const Value *, 32> Visited;
+  for (const Use &TheUse : GV.uses())
+    ForEachInstructionUser(TheUse, Visited, [&](Instruction *I) {
+      if (isa<ReturnInst>(I) && !I->getParent()) {
+        // This could be one of the ReturnInsts used to track prefix/prologue
+        // data. However, to be able to tell we need to construct the inverse
+        // mapping. Since it is expensive to construct, we cache it in the
+        // Verifier.
+        if (InverseFunctionDataMap.empty()) {
+          for (auto &F : M->functions()) {
+            if (F.hasPrefixData())
+              InverseFunctionDataMap[&*F.getContext()
+                                           .pImpl->PrefixDataMap[&F]] = &F;
+            if (F.hasPrologueData())
+              InverseFunctionDataMap[&*F.getContext()
+                                           .pImpl->PrologueDataMap[&F]] = &F;
+          }
+        }
+        const Function *F = InverseFunctionDataMap[cast<ReturnInst>(I)];
+        if (F) {
+          Assert(F->getParent() == GV.getParent(), "Global is referenced in "
+                                                   "function data of function "
+                                                   "in a different module",
+                 &GV, GV.getParent(), F, F->getParent());
+          return;
+        }
+      }
+      Assert(I->getParent() && I->getParent()->getParent(),
+             "Global is referenced by parentless instruction!", &GV,
+             GV.getParent(), I);
+      Assert(I->getParent()->getParent()->getParent() == GV.getParent(),
+             "Global is referenced in a different module!", &GV, GV.getParent(),
+             I, I->getParent()->getParent(),
+             I->getParent()->getParent()->getParent());
+    });
 }
 
 void Verifier::visitGlobalVariable(const GlobalVariable &GV) {
Index: unittests/IR/VerifierTest.cpp
===================================================================
--- unittests/IR/VerifierTest.cpp
+++ unittests/IR/VerifierTest.cpp
@@ -86,7 +86,11 @@
 
   std::string Error;
   raw_string_ostream ErrorOS(Error);
-  EXPECT_FALSE(verifyModule(M2, &ErrorOS));
+  EXPECT_TRUE(verifyModule(M2, &ErrorOS));
+  EXPECT_TRUE(StringRef(ErrorOS.str())
+                  .startswith("Global is referenced in a different module!\n"));
+
+  Error.clear();
   EXPECT_TRUE(verifyModule(M1, &ErrorOS));
   EXPECT_TRUE(StringRef(ErrorOS.str()).equals(
       "Referencing function in another module!\n"