Move the stripping of malformed debug info from the Verifier to AutoUpgrade.

[aprantl]

Summary

This came out of a recent discussion on llvm-dev
(https://reviews.llvm.org/D38042). Currently the Verifier will strip
the debug info metadata from a module if it finds the dbeug info to be
malformed. This feature is very valuable since it allows us to improve
the Verifier by making it stricter without breaking backwards compatibility,
but arguable the Verifier pass should not be modifying the IR.

This patch moves the stripping of broken debug info into AutoUpgrade
(UpgradeDebugInfo to be precise), which is a much better location for
this since the stripping of malformed (i.e., produced by older, buggy
versions of Clang) is a (harsh) form of AutoUpgrade.

This change is mostly NFCish in nature, the one big difference is the
behavior when LLVM module passes are introducing malformed debug
info. Prior to this patch, a NoAsserts build would have printed a
warning and stripped the debug info and an Asserts build would have
asserted, after this patch the Verifier will report a fatal error.
I believe that the new behavior is actually more desirable anyway.

[rnk]

include/llvm/AsmParser/Parser.h

39–40 ↗

(On Diff #116376)

Maybe make the parameter UpgradeDebugInfo = true and indicate that debug info upgrading requires verified IR?

[aprantl]

Address review feedback from @rnk, thanks!

[rnk]

lgtm!

llvm/trunk/include/llvm/AsmParser/Parser.h

 /// that this does not verify that the generated Module is valid, so you should
 /// run the verifier after parsing the file to check that it is okay.
 /// \brief Parse LLVM Assembly from a file
 /// \param Filename The name of the file to parse
 /// \param Error Error result info.
 /// \param Context Context in which to allocate globals info.
 /// \param Slots The optional slot mapping that will be initialized during
 ///              parsing.
-std::unique_ptr<Module> parseAssemblyFile(StringRef Filename,
-                                          SMDiagnostic &Error,
-                                          LLVMContext &Context,
-                                          SlotMapping *Slots = nullptr);
+/// \param UpgradeDebugInfo Run UpgradeDebugInfo, which runs the Verifier.
+///                         This option should only be set to false by llvm-as
+///                         for use inside the LLVM testuite!
+std::unique_ptr<Module>
+parseAssemblyFile(StringRef Filename, SMDiagnostic &Error, LLVMContext &Context,
+                  SlotMapping *Slots = nullptr, bool UpgradeDebugInfo = true);
 
 /// The function is a secondary interface to the LLVM Assembly Parser. It parses
 /// an ASCII string that (presumably) contains LLVM Assembly code. It returns a
 /// Module (intermediate representation) with the corresponding features. Note
 /// that this does not verify that the generated Module is valid, so you should
 /// run the verifier after parsing the file to check that it is okay.
 /// \brief Parse LLVM Assembly from a string
 /// \param AsmString The string containing assembly
 /// \param Error Error result info.
 /// \param Context Context in which to allocate globals info.
 /// \param Slots The optional slot mapping that will be initialized during
 ///              parsing.
+/// \param UpgradeDebugInfo Run UpgradeDebugInfo, which runs the Verifier.
+///                         This option should only be set to false by llvm-as
+///                         for use inside the LLVM testuite!
 std::unique_ptr<Module> parseAssemblyString(StringRef AsmString,
                                             SMDiagnostic &Error,
                                             LLVMContext &Context,
-                                            SlotMapping *Slots = nullptr);
+                                            SlotMapping *Slots = nullptr,
+                                            bool UpgradeDebugInfo = true);
 
 /// parseAssemblyFile and parseAssemblyString are wrappers around this function.
 /// \brief Parse LLVM Assembly from a MemoryBuffer.
 /// \param F The MemoryBuffer containing assembly
 /// \param Err Error result info.
 /// \param Slots The optional slot mapping that will be initialized during
 ///              parsing.
+/// \param UpgradeDebugInfo Run UpgradeDebugInfo, which runs the Verifier.
+///                         This option should only be set to false by llvm-as
+///                         for use inside the LLVM testuite!
 std::unique_ptr<Module> parseAssembly(MemoryBufferRef F, SMDiagnostic &Err,
                                       LLVMContext &Context,
-                                      SlotMapping *Slots = nullptr);
+                                      SlotMapping *Slots = nullptr,
+                                      bool UpgradeDebugInfo = true);
 
 /// This function is the low-level interface to the LLVM Assembly Parser.
 /// This is kept as an independent function instead of being inlined into
 /// parseAssembly for the convenience of interactive users that want to add
 /// recently parsed bits to an existing module.
 ///
 /// \param F The MemoryBuffer containing assembly
 /// \param M The module to add data to.
 /// \param Err Error result info.
 /// \param Slots The optional slot mapping that will be initialized during
 ///              parsing.
 /// \return true on error.
+/// \param UpgradeDebugInfo Run UpgradeDebugInfo, which runs the Verifier.
+///                         This option should only be set to false by llvm-as
+///                         for use inside the LLVM testuite!
 bool parseAssemblyInto(MemoryBufferRef F, Module &M, SMDiagnostic &Err,
-                       SlotMapping *Slots = nullptr);
+                       SlotMapping *Slots = nullptr,
+                       bool UpgradeDebugInfo = true);
 
 /// Parse a type and a constant value in the given string.
 ///
 /// The constant value can be any LLVM constant, including a constant
 /// expression.
 ///
 /// \param Slots The optional slot mapping that will restore the parsing state
 /// of the module.

llvm/trunk/include/llvm/IRReader/IRReader.h

 /// reader to optionally enable lazy metadata loading.
 std::unique_ptr<Module>
 getLazyIRFileModule(StringRef Filename, SMDiagnostic &Err, LLVMContext &Context,
                     bool ShouldLazyLoadMetadata = false);
 
 /// If the given MemoryBuffer holds a bitcode image, return a Module
 /// for it.  Otherwise, attempt to parse it as LLVM Assembly and return
 /// a Module for it.
+/// \param UpgradeDebugInfo Run UpgradeDebugInfo, which runs the Verifier.
+///                         This option should only be set to false by llvm-as
+///                         for use inside the LLVM testuite!
 std::unique_ptr<Module> parseIR(MemoryBufferRef Buffer, SMDiagnostic &Err,
-                                LLVMContext &Context);
+                                LLVMContext &Context,
+                                bool UpgradeDebugInfo = true);
 
 /// If the given file holds a bitcode image, return a Module for it.
 /// Otherwise, attempt to parse it as LLVM Assembly and return a Module
 /// for it.
+/// \param UpgradeDebugInfo Run UpgradeDebugInfo, which runs the Verifier.
+///                         This option should only be set to false by llvm-as
+///                         for use inside the LLVM testuite!
 std::unique_ptr<Module> parseIRFile(StringRef Filename, SMDiagnostic &Err,
-                                    LLVMContext &Context);
+                                    LLVMContext &Context,
+                                    bool UpgradeDebugInfo = true);
 }
 
 #endif

llvm/trunk/lib/AsmParser/LLParser.h

private:
     /// forward-referenced by blockaddress instructions within the same
     /// function.
     PerFunctionState *BlockAddressPFS;
 
     // Attribute builder reference information.
     std::map<Value*, std::vector<unsigned> > ForwardRefAttrGroups;
     std::map<unsigned, AttrBuilder> NumberedAttrBuilders;
 
+    /// Only the llvm-as tool may set this to false to bypass
+    /// UpgradeDebuginfo so it can generate broken bitcode.
+    bool UpgradeDebugInfo;
+
   public:
     LLParser(StringRef F, SourceMgr &SM, SMDiagnostic &Err, Module *M,
-             SlotMapping *Slots = nullptr)
+             SlotMapping *Slots = nullptr, bool UpgradeDebugInfo = true)
         : Context(M->getContext()), Lex(F, SM, Err, M->getContext()), M(M),
-          Slots(Slots), BlockAddressPFS(nullptr) {}
+          Slots(Slots), BlockAddressPFS(nullptr),
+          UpgradeDebugInfo(UpgradeDebugInfo) {}
     bool Run();
 
     bool parseStandaloneConstantValue(Constant *&C, const SlotMapping *Slots);
 
     bool parseTypeAtBeginning(Type *&Ty, unsigned &Read,
                               const SlotMapping *Slots);
 
     LLVMContext &getContext() { return Context; }

llvm/trunk/lib/AsmParser/LLParser.cpp

bool LLParser::ValidateEndOfModule() {
   for (Module::iterator FI = M->begin(), FE = M->end(); FI != FE; ) {
     Function *F = &*FI++;
     if (auto Remangled = Intrinsic::remangleIntrinsicFunction(F)) {
       F->replaceAllUsesWith(Remangled.getValue());
       F->eraseFromParent();
     }
   }
 
-  UpgradeDebugInfo(*M);
+  if (UpgradeDebugInfo)
+    llvm::UpgradeDebugInfo(*M);
 
   UpgradeModuleFlags(*M);
 
   if (!Slots)
     return false;
   // Initialize the slot mapping.
   // Because by this point we've parsed and validated everything, we can "steal"
   // the mapping from LLParser as it doesn't need it anymore.

llvm/trunk/lib/AsmParser/Parser.cpp

 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cstring>
 #include <system_error>
 using namespace llvm;
 
 bool llvm::parseAssemblyInto(MemoryBufferRef F, Module &M, SMDiagnostic &Err,
-                             SlotMapping *Slots) {
+                             SlotMapping *Slots, bool UpgradeDebugInfo) {
   SourceMgr SM;
   std::unique_ptr<MemoryBuffer> Buf = MemoryBuffer::getMemBuffer(F);
   SM.AddNewSourceBuffer(std::move(Buf), SMLoc());
 
-  return LLParser(F.getBuffer(), SM, Err, &M, Slots).Run();
+  return LLParser(F.getBuffer(), SM, Err, &M, Slots, UpgradeDebugInfo).Run();
 }
 
-std::unique_ptr<Module> llvm::parseAssembly(MemoryBufferRef F,
-                                            SMDiagnostic &Err,
-                                            LLVMContext &Context,
-                                            SlotMapping *Slots) {
+std::unique_ptr<Module>
+llvm::parseAssembly(MemoryBufferRef F, SMDiagnostic &Err, LLVMContext &Context,
+                    SlotMapping *Slots, bool UpgradeDebugInfo) {
   std::unique_ptr<Module> M =
       make_unique<Module>(F.getBufferIdentifier(), Context);
 
-  if (parseAssemblyInto(F, *M, Err, Slots))
+  if (parseAssemblyInto(F, *M, Err, Slots, UpgradeDebugInfo))
     return nullptr;
 
   return M;
 }
 
 std::unique_ptr<Module> llvm::parseAssemblyFile(StringRef Filename,
                                                 SMDiagnostic &Err,
                                                 LLVMContext &Context,
-                                                SlotMapping *Slots) {
+                                                SlotMapping *Slots,
+                                                bool UpgradeDebugInfo) {
   ErrorOr<std::unique_ptr<MemoryBuffer>> FileOrErr =
       MemoryBuffer::getFileOrSTDIN(Filename);
   if (std::error_code EC = FileOrErr.getError()) {
     Err = SMDiagnostic(Filename, SourceMgr::DK_Error,
                        "Could not open input file: " + EC.message());
     return nullptr;
   }
 
-  return parseAssembly(FileOrErr.get()->getMemBufferRef(), Err, Context, Slots);
+  return parseAssembly(FileOrErr.get()->getMemBufferRef(), Err, Context, Slots,
+                       UpgradeDebugInfo);
 }
 
 std::unique_ptr<Module> llvm::parseAssemblyString(StringRef AsmString,
                                                   SMDiagnostic &Err,
                                                   LLVMContext &Context,
-                                                  SlotMapping *Slots) {
+                                                  SlotMapping *Slots,
+                                                  bool UpgradeDebugInfo) {
   MemoryBufferRef F(AsmString, "<string>");
-  return parseAssembly(F, Err, Context, Slots);
+  return parseAssembly(F, Err, Context, Slots, UpgradeDebugInfo);
 }
 
 Constant *llvm::parseConstantValue(StringRef Asm, SMDiagnostic &Err,
                                    const Module &M, const SlotMapping *Slots) {
   SourceMgr SM;
   std::unique_ptr<MemoryBuffer> Buf = MemoryBuffer::getMemBuffer(Asm);
   SM.AddNewSourceBuffer(std::move(Buf), SMLoc());
   Constant *C;

llvm/trunk/lib/IR/AutoUpgrade.cpp

 #include "llvm/IR/DebugInfo.h"
 #include "llvm/IR/DiagnosticInfo.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/Instruction.h"
 #include "llvm/IR/IntrinsicInst.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Module.h"
+#include "llvm/IR/Verifier.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/Regex.h"
 #include <cstring>
 using namespace llvm;
 
 static void rename(GlobalValue *GV) { GV->setName(GV->getName() + ".old"); }
 
 // Upgrade the declarations of the SSE4.1 ptest intrinsics whose arguments have
Value *llvm::UpgradeBitCastExpr(unsigned Opc, Constant *C, Type *DestTy) {
 
   return nullptr;
 }
 
 /// Check the debug info version number, if it is out-dated, drop the debug
 /// info. Return true if module is modified.
 bool llvm::UpgradeDebugInfo(Module &M) {
   unsigned Version = getDebugMetadataVersionFromModule(M);
-  if (Version == DEBUG_METADATA_VERSION)
+  if (Version == DEBUG_METADATA_VERSION) {
+    bool BrokenDebugInfo = false;
+    if (verifyModule(M, &llvm::errs(), &BrokenDebugInfo))
+      report_fatal_error("Broken module found, compilation aborted!");
+    if (!BrokenDebugInfo)
+      // Everything is ok.
       return false;
-
-  bool RetCode = StripDebugInfo(M);
-  if (RetCode) {
+    else {
+      // Diagnose malformed debug info.
+      DiagnosticInfoIgnoringInvalidDebugMetadata Diag(M);
+      M.getContext().diagnose(Diag);
+    }
+  }
+  bool Modified = StripDebugInfo(M);
+  if (Modified && Version != DEBUG_METADATA_VERSION) {
+    // Diagnose a version mismatch.
     DiagnosticInfoDebugMetadataVersion DiagVersion(M, Version);
     M.getContext().diagnose(DiagVersion);
   }
-  return RetCode;
+  return Modified;
 }
 
 bool llvm::UpgradeModuleFlags(Module &M) {
   NamedMDNode *ModFlags = M.getModuleFlagsMetadata();
   if (!ModFlags)
     return false;
 
   bool HasObjCFlag = false, HasClassProperties = false, Changed = false;

llvm/trunk/lib/IR/DebugInfo.cpp

static MDNode *stripDebugLocFromLoopID(MDNode *N) {
   // Set the first operand to itself.
   MDNode *LoopID = MDNode::get(N->getContext(), Args);
   LoopID->replaceOperandWith(0, LoopID);
   return LoopID;
 }
 
 bool llvm::stripDebugInfo(Function &F) {
   bool Changed = false;
-  if (F.getSubprogram()) {
+  if (F.getMetadata(LLVMContext::MD_dbg)) {
     Changed = true;
     F.setSubprogram(nullptr);
   }
 
   DenseMap<MDNode*, MDNode*> LoopIDsMap;
   for (BasicBlock &BB : F) {
     for (auto II = BB.begin(), End = BB.end(); II != End;) {
       Instruction &I = *II++; // We may delete the instruction, increment now.

llvm/trunk/lib/IR/Metadata.cpp

 
 void GlobalObject::setMetadata(StringRef Kind, MDNode *N) {
   setMetadata(getContext().getMDKindID(Kind), N);
 }
 
 MDNode *GlobalObject::getMetadata(unsigned KindID) const {
   SmallVector<MDNode *, 1> MDs;
   getMetadata(KindID, MDs);
-  assert(MDs.size() <= 1 && "Expected at most one metadata attachment");
   if (MDs.empty())
     return nullptr;
   return MDs[0];
 }
 
 MDNode *GlobalObject::getMetadata(StringRef Kind) const {
   return getMetadata(getContext().getMDKindID(Kind));
 }

llvm/trunk/lib/IR/Verifier.cpp

struct VerifierLegacyPass : public FunctionPass {
 
   bool doFinalization(Module &M) override {
     bool HasErrors = false;
     for (Function &F : M)
       if (F.isDeclaration())
         HasErrors |= !V->verify(F);
 
     HasErrors |= !V->verify();
-    if (FatalErrors) {
-      if (HasErrors)
-        report_fatal_error("Broken module found, compilation aborted!");
-      assert(!V->hasBrokenDebugInfo() && "Module contains invalid debug info");
-    }
-
-    // Strip broken debug info.
-    if (V->hasBrokenDebugInfo()) {
-      DiagnosticInfoIgnoringInvalidDebugMetadata DiagInvalid(M);
-      M.getContext().diagnose(DiagInvalid);
-      if (!StripDebugInfo(M))
-        report_fatal_error("Failed to strip malformed debug info");
-    }
+    if (FatalErrors && (HasErrors || V->hasBrokenDebugInfo()))
     return false;
   }
 
   void getAnalysisUsage(AnalysisUsage &AU) const override {
     AU.setPreservesAll();
   }
 };
 

 
 VerifierAnalysis::Result VerifierAnalysis::run(Function &F,
                                                FunctionAnalysisManager &) {
   return { llvm::verifyFunction(F, &dbgs()), false };
 }
 
 PreservedAnalyses VerifierPass::run(Module &M, ModuleAnalysisManager &AM) {
   auto Res = AM.getResult<VerifierAnalysis>(M);
-  if (FatalErrors) {
-    if (Res.IRBroken)
-      report_fatal_error("Broken module found, compilation aborted!");
-    assert(!Res.DebugInfoBroken && "Module contains invalid debug info");
-  }
+  if (FatalErrors && (Res.IRBroken || Res.DebugInfoBroken))
 
-  // Strip broken debug info.
-  if (Res.DebugInfoBroken) {
-    DiagnosticInfoIgnoringInvalidDebugMetadata DiagInvalid(M);
-    M.getContext().diagnose(DiagInvalid);
-    if (!StripDebugInfo(M))
-      report_fatal_error("Failed to strip malformed debug info");
-  }
   return PreservedAnalyses::all();
 }
 
 PreservedAnalyses VerifierPass::run(Function &F, FunctionAnalysisManager &AM) {
   auto res = AM.getResult<VerifierAnalysis>(F);
   if (res.IRBroken && FatalErrors)
     report_fatal_error("Broken function found, compilation aborted!");
 
   return PreservedAnalyses::all();
 }

llvm/trunk/lib/IRReader/IRReader.cpp

if (std::error_code EC = FileOrErr.getError()) {
     return nullptr;
   }
 
   return getLazyIRModule(std::move(FileOrErr.get()), Err, Context,
                          ShouldLazyLoadMetadata);
 }
 
 std::unique_ptr<Module> llvm::parseIR(MemoryBufferRef Buffer, SMDiagnostic &Err,
-                                      LLVMContext &Context) {
+                                      LLVMContext &Context,
+                                      bool UpgradeDebugInfo) {
   NamedRegionTimer T(TimeIRParsingName, TimeIRParsingDescription,
                      TimeIRParsingGroupName, TimeIRParsingGroupDescription,
                      TimePassesIsEnabled);
   if (isBitcode((const unsigned char *)Buffer.getBufferStart(),
                 (const unsigned char *)Buffer.getBufferEnd())) {
     Expected<std::unique_ptr<Module>> ModuleOrErr =
         parseBitcodeFile(Buffer, Context);
     if (Error E = ModuleOrErr.takeError()) {
       handleAllErrors(std::move(E), [&](ErrorInfoBase &EIB) {
         Err = SMDiagnostic(Buffer.getBufferIdentifier(), SourceMgr::DK_Error,
                            EIB.message());
       });
       return nullptr;
     }
     return std::move(ModuleOrErr.get());
   }
 
-  return parseAssembly(Buffer, Err, Context);
+  return parseAssembly(Buffer, Err, Context, nullptr, UpgradeDebugInfo);
 }
 
 std::unique_ptr<Module> llvm::parseIRFile(StringRef Filename, SMDiagnostic &Err,
-                                          LLVMContext &Context) {
+                                          LLVMContext &Context,
+                                          bool UpgradeDebugInfo) {
   ErrorOr<std::unique_ptr<MemoryBuffer>> FileOrErr =
       MemoryBuffer::getFileOrSTDIN(Filename);
   if (std::error_code EC = FileOrErr.getError()) {
     Err = SMDiagnostic(Filename, SourceMgr::DK_Error,
                        "Could not open input file: " + EC.message());
     return nullptr;
   }
 
-  return parseIR(FileOrErr.get()->getMemBufferRef(), Err, Context);
+  return parseIR(FileOrErr.get()->getMemBufferRef(), Err, Context,
+                 UpgradeDebugInfo);
 }
 
 //===----------------------------------------------------------------------===//
 // C API.
 //===----------------------------------------------------------------------===//
 
 LLVMBool LLVMParseIRInContext(LLVMContextRef ContextRef,
                               LLVMMemoryBufferRef MemBuf, LLVMModuleRef *OutM,

llvm/trunk/lib/LTO/LTOCodeGenerator.cpp

cl::opt<bool> LTODiscardValueNames(
     cl::desc("Strip names from Value during LTO (other than GlobalValue)."),
 #ifdef NDEBUG
     cl::init(true),
 #else
     cl::init(false),
 #endif
     cl::Hidden);
 
-cl::opt<bool> LTOStripInvalidDebugInfo(
-    "lto-strip-invalid-debug-info",
-    cl::desc("Strip invalid debug info metadata during LTO instead of aborting."),
-#ifdef NDEBUG
-    cl::init(true),
-#else
-    cl::init(false),
-#endif
-    cl::Hidden);
-
 cl::opt<std::string>
     LTORemarksFilename("lto-pass-remarks-output",
                        cl::desc("Output filename for pass remarks"),
                        cl::value_desc("filename"));
 
 cl::opt<bool> LTOPassRemarksWithHotness(
     "lto-pass-remarks-with-hotness",
     cl::desc("With PGO, include profile count in optimization remarks"),

 
 void LTOCodeGenerator::verifyMergedModuleOnce() {
   // Only run on the first call.
   if (HasVerifiedInput)
     return;
   HasVerifiedInput = true;
 
   bool BrokenDebugInfo = false;
-  if (verifyModule(*MergedModule, &dbgs(),
-                   LTOStripInvalidDebugInfo ? &BrokenDebugInfo : nullptr))
+  if (verifyModule(*MergedModule, &dbgs(), &BrokenDebugInfo))
     report_fatal_error("Broken module found, compilation aborted!");
   if (BrokenDebugInfo) {
     emitWarning("Invalid debug info found, debug info will be stripped");
     StripDebugInfo(*MergedModule);
   }
 }
 
 void LTOCodeGenerator::finishOptimizationRemarks() {

llvm/trunk/lib/LTO/ThinLTOCodeGenerator.cpp

 
 #define DEBUG_TYPE "thinlto"
 
 namespace llvm {
 // Flags -discard-value-names, defined in LTOCodeGenerator.cpp
 extern cl::opt<bool> LTODiscardValueNames;
 extern cl::opt<std::string> LTORemarksFilename;
 extern cl::opt<bool> LTOPassRemarksWithHotness;
-extern cl::opt<bool> LTOStripInvalidDebugInfo;
 }
 
 namespace {
 
 static cl::opt<int>
     ThreadCount("threads", cl::init(llvm::heavyweight_hardware_concurrency()));
 
 // Simple helper to save temporary files for debug.
ThinLTODiagnosticInfo(const Twine &DiagMsg,
       : DiagnosticInfo(DK_Linker, Severity), Msg(DiagMsg) {}
   void print(DiagnosticPrinter &DP) const override { DP << Msg; }
 };
 }
 
 /// Verify the module and strip broken debug info.
 static void verifyLoadedModule(Module &TheModule) {
   bool BrokenDebugInfo = false;
-  if (verifyModule(TheModule, &dbgs(),
-                   LTOStripInvalidDebugInfo ? &BrokenDebugInfo : nullptr))
+  if (verifyModule(TheModule, &dbgs(), &BrokenDebugInfo))
     report_fatal_error("Broken module found, compilation aborted!");
   if (BrokenDebugInfo) {
     TheModule.getContext().diagnose(ThinLTODiagnosticInfo(
         "Invalid debug info found, debug info will be stripped", DS_Warning));
     StripDebugInfo(TheModule);
   }
 }
 

llvm/trunk/test/Analysis/GlobalsModRef/pr12351.ll

-; RUN: opt < %s -basicaa -globals-aa -gvn -S | FileCheck %s
+; RUN: opt < %s -basicaa -globals-aa -gvn -S -disable-verify | FileCheck %s
 
 declare void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i32, i1)
 define void @foo(i8* %x, i8* %y) {
   call void @llvm.memcpy.p0i8.p0i8.i32(i8* %x, i8* %y, i32 1, i32 1, i1 false);
   ret void
 }
 
 define void @bar(i8* %y, i8* %z) {

llvm/trunk/test/DebugInfo/Generic/invalid.ll

-; RUN: not opt -verify %s 2>&1 | FileCheck %s
+; RUN: llvm-as -disable-output %s 2>&1 | FileCheck %s
 
 ; Make sure we emit this diagnostic only once (which means we don't visit the
 ; same DISubprogram twice.
 ; CHECK: subprogram definitions must have a compile unit
 ; CHECK-NEXT: !3 = distinct !DISubprogram(name: "patatino", scope: null, isLocal: false, isDefinition: true, isOptimized: false)
 ; CHECK-NOT: subprogram definitions must have a compile unit
 ; CHECK-NOT: !3 = distinct !DISubprogram(name: "patatino", scope: null, isLocal: false, isDefinition: true, isOptimized: false)
+; CHECK: warning: ignoring invalid debug info
 
 define void @tinkywinky() !dbg !3 { ret void }
 
 !llvm.module.flags = !{!4}
 !llvm.dbg.cu = !{!0}
 !0 = distinct !DICompileUnit(language: 12, file: !1)
 !1 = !DIFile(filename: "/home/davide", directory: "/home/davide")
 !3 = distinct !DISubprogram(name: "patatino", isDefinition: true)
 !4 = !{i32 2, !"Debug Info Version", i32 3}

llvm/trunk/test/DebugInfo/Generic/location-verifier.ll

-; RUN: not llvm-as -disable-output -verify-debug-info < %s 2>&1 | FileCheck %s
+; RUN: llvm-as -disable-output -verify-debug-info -o - < %s 2>&1 | FileCheck %s
 ; ModuleID = 'test.c'
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.10.0"
 
 ; Function Attrs: nounwind ssp uwtable
 define i32 @foo() #0 !dbg !4 {
 entry:
   ret i32 42, !dbg !13

 !8 = !DIBasicType(tag: DW_TAG_base_type, name: "int", size: 32, align: 32, encoding: DW_ATE_signed)
 !9 = !{i32 2, !"Dwarf Version", i32 2}
 !10 = !{i32 2, !"Debug Info Version", i32 3}
 !11 = !{i32 1, !"PIC Level", i32 2}
 !12 = !{!"clang version 3.7.0 "}
 ; An old-style DILocation should not pass verify.
 ; CHECK: invalid !dbg metadata attachment
 !13 = !{i32 2, i32 2, !4, null}
+; CHECK: warning: ignoring invalid debug info

llvm/trunk/test/DebugInfo/Generic/piece-verifier.ll

-; RUN: not llvm-as -disable-output < %s 2>&1 | FileCheck %s
+; RUN: llvm-as -disable-output < %s 2>&1 | FileCheck %s
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.9.0"
 
 ; Function Attrs: nounwind ssp uwtable
 define i32 @foo(i64 %s.coerce0, i32 %s.coerce1) #0 !dbg !4 {
 entry:
   call void @llvm.dbg.value(metadata i64 %s.coerce0, metadata !20, metadata !24), !dbg !21
   call void @llvm.dbg.value(metadata i32 %s.coerce1, metadata !22, metadata !27), !dbg !21

 !23 = !DILocation(line: 4, scope: !4)
 !24 = !DIExpression(DW_OP_deref, DW_OP_LLVM_fragment, 0, 64)
 !25 = !{}
 ; This expression has elements after DW_OP_LLVM_fragment.
 ; CHECK: invalid expression
 ; CHECK-NEXT: !DIExpression({{[0-9]+}}, 64, 32, {{[0-9]+}})
 ; CHECK-NOT: invalid expression
 !27 = !DIExpression(DW_OP_LLVM_fragment, 64, 32, DW_OP_deref)
+; CHECK: warning: ignoring invalid debug info

llvm/trunk/test/DebugInfo/pr34186.ll

 ; Make sure we reject GVs without a type.
 ; Currently the verifier when traversing the graph induced by the debug info
 ; metadata can reach the GV both from a DICompileUnit and a DIGlobalVariable
 ; expression, so we emit a diagnostic twice. This is, not ideal, but the
 ; alternative is that of keeping a map of visited GVs, which has non trivial
 ; memory usage consequences on large testcases, or when LTO is the mode of
 ; operation.
-; RUN: not llc %s 2>&1 | FileCheck %s
+; RUN: llvm-as -disable-output %s -o - 2>&1 | FileCheck %s
 ; CHECK: missing global variable type
 ; CHECK: missing global variable type
+; CHECK-NOT: missing global variable type
+; CHECK: warning: ignoring invalid debug info
 
 !llvm.dbg.cu = !{!2}
 !llvm.module.flags = !{!63, !64}
 !1 = distinct !DIGlobalVariable(name: "pat", scope: !2, file: !3, line: 27, isLocal: true, isDefinition: true)
 !2 = distinct !DICompileUnit(language: DW_LANG_C99, file: !3, producer: "", emissionKind: FullDebug, globals: !5)
 !3 = !DIFile(filename: "patatino.c", directory: "/")
 !5 = !{!6}
 !6 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
 !63 = !{i32 2, !"Dwarf Version", i32 4}
 !64 = !{i32 2, !"Debug Info Version", i32 3}

llvm/trunk/test/DebugInfo/pr34672.ll

-; RUN: not opt -verify %s 2>&1 | FileCheck %s
+; RUN: opt -verify %s 2>&1 | FileCheck %s
 ; CHECK: invalid type ref
 ; CHECK-NOT: invalid type ref
 
 @global = common global i32 0, align 4, !dbg !2
 
 !llvm.dbg.cu = !{!0}
 !llvm.module.flags = !{!5, !6}
 
 !0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "adrian", emissionKind: FullDebug)
 !1 = !DIFile(filename: "broken.c", directory: "/")
 !2 = !DIGlobalVariableExpression(var: !3, expr: !DIExpression())
 !3 = !DIGlobalVariable(name: "g", scope: !0, file: !1, line: 1, type: !1, isLocal: false, isDefinition: true)
 !5 = !{i32 2, !"Dwarf Version", i32 4}
 !6 = !{i32 1, !"Debug Info Version", i32 3}
 

llvm/trunk/test/LTO/X86/strip-debug-info-no-call-loc.ll

 ; RUN: llvm-as %s -disable-verify -o %t.bc
-; RUN: llvm-lto -lto-strip-invalid-debug-info=true \
-; RUN:     -exported-symbol f -exported-symbol _f \
+; RUN: llvm-lto -exported-symbol f -exported-symbol _f \
 ; RUN:     -o %t.o %t.bc 2>&1 | \
 ; RUN:     FileCheck %s -allow-empty -check-prefix=CHECK-WARN
 ; RUN: llvm-nm %t.o | FileCheck %s 
 
 ; Check that missing debug locations on inlinable calls are a
 ; recoverable error.
 
-; CHECK-WARN: Invalid debug info found, debug info will be stripped
+; CHECK-WARN: warning{{.*}} ignoring invalid debug info
 ; CHECK: {{f$}}
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx"
 
 define void @h() #0 !dbg !7 {
 entry:
   call void (...) @i(), !dbg !9
   ret void, !dbg !10

llvm/trunk/test/LTO/X86/strip-debug-info.ll

 ; RUN: llvm-as -disable-verify %s -o %t.bc
 ; ---- Full LTO ---------------------------------------------
-; RUN: not llvm-lto -lto-strip-invalid-debug-info=false \
-; RUN:     -o %t.o %t.bc 2>&1 | \
-; RUN:     FileCheck %s -allow-empty -check-prefix=CHECK-ERR
-; RUN: llvm-lto -lto-strip-invalid-debug-info=true \
+; RUN: llvm-lto \
 ; RUN:     -exported-symbol foo -exported-symbol _foo \
 ; RUN:     -o %t.o %t.bc 2>&1 | \
 ; RUN:     FileCheck %s -allow-empty -check-prefix=CHECK-WARN
 ; RUN: llvm-nm %t.o | FileCheck %s 
 ; ---- Thin LTO (codegen only) ------------------------------
-; RUN: not llvm-lto -thinlto -thinlto-action=codegen \
-; RUN:     -lto-strip-invalid-debug-info=false \
-; RUN:     %t.bc -disable-verify 2>&1 | \
-; RUN:     FileCheck %s -allow-empty -check-prefix=CHECK-ERR
 ; RUN: llvm-lto -thinlto -thinlto-action=codegen \
-; RUN:     -lto-strip-invalid-debug-info=true \
 ; RUN:     %t.bc -disable-verify 2>&1 | \
 ; RUN:     FileCheck %s -allow-empty -check-prefix=CHECK-WARN
 ; ---- Thin LTO (optimize, strip main file) -----------------
 ; RUN: opt -disable-verify -module-summary %s -o %t.bc
 ; RUN: opt -disable-verify -module-summary %S/Inputs/strip-debug-info-bar.ll \
 ; RUN:     -o %t2.bc
-; RUN: not llvm-lto -thinlto -thinlto-action=run \
-; RUN:     -lto-strip-invalid-debug-info=false \
-; RUN:     %t.bc -disable-verify 2>&1 | \
-; RUN:     FileCheck %s -allow-empty -check-prefix=CHECK-ERR
 ; RUN: llvm-lto -thinlto -thinlto-action=run \
-; RUN:     -lto-strip-invalid-debug-info=true \
 ; RUN:     %t.bc -disable-verify 2>&1 | \
 ; RUN:     FileCheck %s -allow-empty -check-prefix=CHECK-WARN
 ; ---- Thin LTO (optimize, strip imported file) -------------
 ; RUN: opt -disable-verify -strip-debug -module-summary %t.bc -o %t-stripped.bc
 ; RUN: llvm-lto -thinlto-action=thinlink -o %t.index.bc %t-stripped.bc %t2.bc
-; RUN: not llvm-lto -thinlto -thinlto-action=import \
-; RUN:     -thinlto-index=%t.index.bc \
-; RUN:     -lto-strip-invalid-debug-info=false \
-; RUN:     -exported-symbol foo -exported-symbol _foo \
-; RUN:     %t-stripped.bc -disable-verify 2>&1 | \
-; RUN:     FileCheck %s -allow-empty -check-prefix=CHECK-ERR
 ; RUN: llvm-lto -thinlto -thinlto-action=import \
-; RUN:     -lto-strip-invalid-debug-info=true \
 ; RUN:     -thinlto-index=%t.index.bc \
 ; RUN:     -exported-symbol foo -exported-symbol _foo \
 ; RUN:     %t-stripped.bc -disable-verify 2>&1 | \
 ; RUN:     FileCheck %s -allow-empty -check-prefix=CHECK-WARN
 
 ; CHECK-ERR: Broken module found, compilation aborted
-; CHECK-WARN: Invalid debug info found, debug info will be stripped
+; CHECK-WARN: warning{{.*}} ignoring invalid debug info
 ; CHECK-WARN-NOT: Broken module found
 ; CHECK: foo
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.12"
 
 declare void @bar()
 
 define void @foo() {

llvm/trunk/test/Verifier/DILocation-parents.ll

-; RUN: not llvm-as %s -o - 2>&1 | FileCheck %s
+; RUN: llvm-as -disable-output %s -o - 2>&1 | FileCheck %s
 source_filename = "t.c"
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.12.0"
 
 define void @f() !dbg !4 {
 entry:
 ; CHECK: scope points into the type hierarchy
 ; CHECK: DILocation
   ret void, !dbg !7
 }
 
 define void @g() !dbg !8 {
 entry:
 ; CHECK: scope points into the type hierarchy
 ; CHECK: DILexicalBlockFile
   ret void, !dbg !9
 }
 
+; CHECK: warning: ignoring invalid debug info
+
 !llvm.dbg.cu = !{!0}
 !llvm.module.flags = !{!2, !3}
 
 !0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, emissionKind: FullDebug)
 !1 = !DIFile(filename: "t.c", directory: "/tmp")
 !2 = !{i32 2, !"Dwarf Version", i32 4}
 !3 = !{i32 2, !"Debug Info Version", i32 3}
 !4 = distinct !DISubprogram(name: "f", scope: !1, file: !1, line: 2, type: !5, isDefinition: true, scopeLine: 2, flags: DIFlagPrototyped, unit: !0)
 !5 = !DISubroutineType(types: !{})
 !6 = distinct !DISubprogram(name: "f", scope: !1, file: !1, line: 2, type: !5, isDefinition: false, scopeLine: 2)
 !7 = !DILocation(line: 2, scope: !6)
 !8 = distinct !DISubprogram(name: "g", scope: !1, file: !1, line: 2, type: !5, isDefinition: true, scopeLine: 2, flags: DIFlagPrototyped, unit: !0)
 !9 = !DILocation(line: 2, scope: !10, inlinedAt: !11)
 !10 = !DILexicalBlockFile(scope: !6, file: !2, discriminator: 0)
 !11 = !DILocation(line: 2, scope: !8)

llvm/trunk/test/Verifier/DISubprogram.ll

-; RUN: not opt -S <%s 2>&1| FileCheck %s
+; RUN: llvm-as -disable-output <%s 2>&1| FileCheck %s
 
 define void @f() !dbg !14 {
   ret void
 }
 
 !0 = !{null}
 !1 = distinct !DICompositeType(tag: DW_TAG_structure_type)
 !2 = !DIFile(filename: "path/to/file", directory: "/path/to/dir")
 !3 = !DISubroutineType(types: !0)
 !4 = distinct !DICompositeType(tag: DW_TAG_structure_type)
 !8 = distinct !DICompileUnit(language: DW_LANG_Swift, producer: "clang",
                              file: !2, emissionKind: 2)
 ; CHECK: invalid thrown type
+; CHECK: warning: ignoring invalid debug info
 !13 = !{!14}
 !14 = distinct !DISubprogram(name: "f", scope: !1,
                             file: !2, line: 1, type: !3, isLocal: true,
                             isDefinition: true, scopeLine: 2,
                             unit: !8, thrownTypes: !13)
 !15 = !{i32 1, !"Debug Info Version", i32 3}
 !llvm.module.flags = !{!15}
 !llvm.dbg.cu = !{!8}

llvm/trunk/test/Verifier/callsite-dbgloc.ll

-; RUN: not llvm-as %s -o %t 2>&1 | FileCheck %s
+; RUN: llvm-as %s -o %t 2>&1 | FileCheck %s
 ; Created and then edited from
 ;   extern void i();
 ;   void h() { i(); }
 ;   void g() { h(); }
 ;   void f() { g(); }
 ;
 ; Compiling this with inlining runs into the
 ; "!dbg attachment points at wrong subprogram for function"

 define void @f() #0 !dbg !14 {
 entry:
   call void @g(), !dbg !15
   ret void, !dbg !16
 }
 
 attributes #0 = { nounwind ssp uwtable }
 
+; CHECK: warning: ignoring invalid debug info
+
 !llvm.dbg.cu = !{!0}
 !llvm.module.flags = !{!3, !4, !5}
 !llvm.ident = !{!6}
 
 !0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 3.9.0 (trunk 267186)", isOptimized: false, runtimeVersion: 0, emissionKind: LineTablesOnly, enums: !2)
 !1 = !DIFile(filename: "test.c", directory: "/Volumes/Data/llvm")
 !2 = !{}
 !3 = !{i32 2, !"Dwarf Version", i32 2}

llvm/trunk/test/Verifier/dbg-difile-crash.ll

-; RUN: not llvm-as -disable-output <%s 2>&1 | FileCheck %s
-; CHECK:      assembly parsed, but does not verify
-; CHECK-NEXT: invalid file
+; RUN: llvm-as -disable-output <%s 2>&1 | FileCheck %s
+; CHECK: invalid file
+; CHECK: warning: ignoring invalid debug info
 
 define void @blah() !dbg !3 {
   ret void
 }
 
 !llvm.module.flags = !{!0}
 !0 = !{i32 2, !"Debug Info Version", i32 3}
 !llvm.dbg.cu = !{!1}
 !1 = distinct !DICompileUnit(file: !2, language: DW_LANG_C99)
 !2 = !DIFile(filename: "file.c", directory: "/path/to/dir")
 !3 = distinct !DISubprogram(name: "blah", file: !1, unit: !1)

llvm/trunk/test/Verifier/dbg-invalid-compileunit.ll

-; RUN: not llvm-as -disable-output <%s 2>&1 | FileCheck %s
-; CHECK:      assembly parsed, but does not verify
+; RUN: llvm-as -disable-output <%s 2>&1 | FileCheck %s
+; CHECK: warning: ignoring invalid debug info
 
 !llvm.module.flags = !{!0}
 !llvm.dbg.cu = !{!1}
 
 !0 = !{i32 2, !"Debug Info Version", i32 3}
 !1 = !DIFile(filename: "davide.f", directory: "")

llvm/trunk/test/Verifier/dbg-invalid-named-metadata.ll

-; RUN: not llvm-as -disable-output <%s 2>&1 | FileCheck %s
-; CHECK:      assembly parsed, but does not verify
+; RUN: llvm-as -disable-output <%s 2>&1 | FileCheck %s
+; CHECK: warning: ignoring invalid debug info
 
 !llvm.module.flags = !{!0}
 !llvm.dbg.the_dbg_namespace_is_reserved = !{}
 
 !0 = !{i32 2, !"Debug Info Version", i32 3}

llvm/trunk/test/Verifier/dbg-invalid-retaintypes.ll

-; RUN: not llvm-as -disable-output <%s 2>&1 | FileCheck %s
-; CHECK:      assembly parsed, but does not verify
+; RUN: llvm-as -disable-output <%s 2>&1 | FileCheck %s
+; CHECK: warning: ignoring invalid debug info
 
 !llvm.dbg.cu = !{!0}
 !llvm.module.flags = !{!3}
 
 !0 = distinct !DICompileUnit(language: DW_LANG_C99, producer: "clang version 3.0 (trunk 131941)", isOptimized: true, emissionKind: FullDebug, file: !2, retainedTypes: !1)
 !1 = distinct !DISubprogram(name: "main", line: 1, isLocal: false, isDefinition: true, virtualIndex: 6, flags: DIFlagPrototyped, isOptimized: false, unit: !0, scopeLine: 1, scope: !2)
 !2 = !DIFile(filename: "/davide/test", directory: "/")
 !3 = !{i32 1, !"Debug Info Version", i32 3}

llvm/trunk/test/Verifier/dbg-line-without-file.ll

-; RUN: not llvm-as -disable-output <%s 2>&1 | FileCheck %s
-; CHECK: assembly parsed, but does not verify
+; RUN: llvm-as -disable-output <%s 2>&1 | FileCheck %s
 ; CHECK: line specified with no file
+; CHECK: warning: ignoring invalid debug info
 
 define void @foo() !dbg !3 {
   ret void
 }
 
 !llvm.module.flags = !{!0}
 !llvm.dbg.cu = !{!1}
 
 !0 = !{i32 2, !"Debug Info Version", i32 3}
 !1 = distinct !DICompileUnit(language: DW_LANG_C, file: !2)
 !2 = !DIFile(filename: "foo.c", directory: "")
 !3 = distinct !DISubprogram(name: "foo", scope: !1, line: 1, unit: !1)

llvm/trunk/test/Verifier/dbg-null-retained-type.ll

-; RUN: not llvm-as -disable-output <%s 2>&1 | FileCheck %s
-; CHECK:      assembly parsed, but does not verify
-; CHECK-NEXT: invalid retained type
+; RUN: llvm-as -disable-output <%s 2>&1 | FileCheck %s
+; CHECK: invalid retained type
+; CHECK: warning: ignoring invalid debug info
 
 !llvm.module.flags = !{!0}
 !0 = !{i32 2, !"Debug Info Version", i32 3}
 !llvm.dbg.cu = !{!1}
 !1 = distinct !DICompileUnit(file: !2, language: DW_LANG_C99, retainedTypes: !3)
 !2 = !DIFile(filename: "file.c", directory: "/path/to/dir")
 !3 = !{null}

llvm/trunk/test/Verifier/dbg.ll

-; RUN: not llvm-as -disable-output <%s 2>&1 | FileCheck %s
+; RUN: llvm-as -disable-output <%s 2>&1 | FileCheck %s
 
 define void @foo() {
 entry:
   br label %exit, !dbg !DILocation(scope: !1, inlinedAt: !{})
 ; CHECK: inlined-at should be a location
 ; CHECK-NEXT: !{{[0-9]+}} = !DILocation(line: 0, scope: !{{[0-9]+}}, inlinedAt: ![[IA:[0-9]+]])
 ; CHECK-NEXT: ![[IA]] = !{}
 
 exit:
   ret void, !dbg !{}
 ; CHECK: invalid !dbg metadata attachment
 ; CHECK-NEXT: ret void, !dbg ![[LOC:[0-9]+]]
 ; CHECK-NEXT: ![[LOC]] = !{}
 }
 
+; CHECK: warning: ignoring invalid debug info
 !llvm.module.flags = !{!0}
 !0 = !{i32 2, !"Debug Info Version", i32 3}
 !1 = distinct !DISubprogram()

llvm/trunk/test/Verifier/diglobalvariable.ll

-; RUN: not opt -S <%s 2>&1| FileCheck %s
+; RUN: llvm-as -disable-output <%s 2>&1| FileCheck %s
 
 ; CHECK: !dbg attachment of global variable must be a DIGlobalVariableExpression
 @g = common global i32 0, align 4, !dbg !0
 
 !llvm.dbg.cu = !{!1}
 !llvm.module.flags = !{!6, !7}
 
 !0 = distinct !DIGlobalVariable(name: "g", scope: !1, file: !2, line: 1, type: !5, isLocal: false, isDefinition: true)
 !1 = distinct !DICompileUnit(language: DW_LANG_C99, file: !2, emissionKind: FullDebug)
 !2 = !DIFile(filename: "a.c", directory: "/")
 !5 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
 !6 = !{i32 2, !"Dwarf Version", i32 4}
 !7 = !{i32 2, !"Debug Info Version", i32 3}
+; CHECK: warning: ignoring invalid debug info

llvm/trunk/test/Verifier/fnarg-debuginfo.ll

-; RUN: not llvm-as < %s -o /dev/null 2>&1 | FileCheck %s
+; RUN: llvm-as -disable-output < %s -o /dev/null 2>&1 | FileCheck %s
 
 declare void @llvm.dbg.declare(metadata, metadata, metadata) 
 declare void @llvm.dbg.value(metadata, i64, metadata, metadata)
 
 define void @foo() !dbg !2 {
 entry:
   %a = alloca i32
   ; CHECK: conflicting debug info for argument
   call void @llvm.dbg.value(metadata i32 0, i64 0, metadata !3, metadata !DIExpression()), !dbg !6
   call void @llvm.dbg.declare(metadata i32* %a, metadata !4, metadata !DIExpression()), !dbg !6
   ret void, !dbg !6
 }
 
+; CHECK: warning: ignoring invalid debug info
+
 !llvm.dbg.cu = !{!0}
 !llvm.module.flags = !{!7, !8}
 
 !0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang", emissionKind: FullDebug)
 !1 = !DIFile(filename: "x.c", directory: "/")
 !2 = distinct !DISubprogram(name: "foo", scope: !0, isDefinition: true, unit: !0)
 !3 = !DILocalVariable(name: "a", arg: 1, scope: !2, file: !1, line: 1, type: !5)
 !4 = !DILocalVariable(name: "b", arg: 1, scope: !2, file: !1, line: 1, type: !5)
 !5 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
 !6 = !DILocation(line: 1, scope: !2)
 !7 = !{i32 2, !"Dwarf Version", i32 4}
 !8 = !{i32 1, !"Debug Info Version", i32 3}

llvm/trunk/test/Verifier/fragment.ll

-; RUN: not opt -S <%s 2>&1| FileCheck %s
+; RUN: llvm-as -disable-output <%s 2>&1| FileCheck %s
 
 ; CHECK: fragment is larger than or outside of variable
 ; CHECK: !DIGlobalVariableExpression(var: ![[VAR:[0-9]+]],
 ; CHECK-SAME:                        expr: !DIExpression(DW_OP_LLVM_fragment, 0, 64))
 ; CHECK: ![[VAR]] = !DIGlobalVariable(name: "g"
+; CHECK: warning: ignoring invalid debug info
 
 @g = common global i32 0, align 4, !dbg !0
 
 !llvm.dbg.cu = !{!1}
 !llvm.module.flags = !{!6, !7}
 
 !0 = !DIGlobalVariableExpression(var: !3, expr: !DIExpression(DW_OP_LLVM_fragment, 0, 64))
 !1 = distinct !DICompileUnit(language: DW_LANG_C99, file: !2, emissionKind: FullDebug)
 !2 = !DIFile(filename: "a.c", directory: "/")
 !3 = !DIGlobalVariable(name: "g", scope: !1, file: !2, line: 1, type: !5, isLocal: false, isDefinition: true)
 !5 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
 !6 = !{i32 2, !"Dwarf Version", i32 4}
 !7 = !{i32 2, !"Debug Info Version", i32 3}

llvm/trunk/test/Verifier/func-dbg.ll

-; RUN: not llvm-as < %s -o /dev/null 2>&1 | FileCheck %s
+; RUN: llvm-as -disable-output < %s -o /dev/null 2>&1 | FileCheck %s
 
 define i32 @foo() !dbg !4 {
 entry:
   ret i32 0, !dbg !6
 }
 
 define i32 @bar() !dbg !5 {
 entry:
 ; CHECK: !dbg attachment points at wrong subprogram for function
   ret i32 0, !dbg !6
 }
 
+; CHECK: warning: ignoring invalid debug info
 !llvm.dbg.cu = !{!0}
 !llvm.module.flags = !{!7, !8}
 
 !0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, retainedTypes: !2, globals: !2, imports: !2)
 !1 = !DIFile(filename: "dwarf-test.c", directory: "test")
 !2 = !{}
 !4 = distinct !DISubprogram(name: "foo", scope: !0, isDefinition: true, unit: !0)
 !5 = distinct !DISubprogram(name: "bar", scope: !0, isDefinition: true, unit: !0)
 !6 = !DILocation(line: 7, scope: !4)
 !7 = !{i32 2, !"Dwarf Version", i32 3}
 !8 = !{i32 1, !"Debug Info Version", i32 3}

llvm/trunk/test/Verifier/llvm.dbg.declare-address.ll

-; RUN: not llvm-as -disable-output <%s 2>&1 | FileCheck %s
+; RUN: llvm-as -disable-output <%s 2>&1 | FileCheck %s
 ; CHECK: invalid llvm.dbg.declare intrinsic address/value
 ; CHECK-NEXT: call void @llvm.dbg.declare({{.*}})
 ; CHECK-NEXT: !""
+; CHECK: warning: ignoring invalid debug info
 
 define void @foo(i32 %a) {
 entry:
   %s = alloca i32
   call void @llvm.dbg.declare(metadata !"", metadata !DILocalVariable(scope: !1), metadata !DIExpression()), !dbg !DILocation(scope: !1)
   ret void
 }
 
 declare void @llvm.dbg.declare(metadata, metadata, metadata)
 
 !llvm.module.flags = !{!0}
 !0 = !{i32 2, !"Debug Info Version", i32 3}
 !1 = distinct !DISubprogram()

llvm/trunk/test/Verifier/llvm.dbg.declare-expression.ll

-; RUN: not llvm-as -disable-output <%s 2>&1 | FileCheck %s
+; RUN: llvm-as -disable-output <%s 2>&1 | FileCheck %s
 ; CHECK: invalid llvm.dbg.declare intrinsic expression
 ; CHECK-NEXT: call void @llvm.dbg.declare({{.*}})
 ; CHECK-NEXT: !""
+; CHECK: warning: ignoring invalid debug info
 
 define void @foo(i32 %a) {
 entry:
   %s = alloca i32
   call void @llvm.dbg.declare(metadata i32* %s, metadata !DILocalVariable(scope: !1), metadata !"")
   ret void
 }
 
 declare void @llvm.dbg.declare(metadata, metadata, metadata)
 
 !llvm.module.flags = !{!0}
 !0 = !{i32 2, !"Debug Info Version", i32 3}
 !1 = distinct !DISubprogram()

llvm/trunk/test/Verifier/llvm.dbg.declare-variable.ll

-; RUN: not llvm-as -disable-output <%s 2>&1 | FileCheck %s
+; RUN: llvm-as -disable-output <%s 2>&1 | FileCheck %s
 ; CHECK: invalid llvm.dbg.declare intrinsic variable
 ; CHECK-NEXT: call void @llvm.dbg.declare({{.*}})
 ; CHECK-NEXT: !""
+; CHECK: warning: ignoring invalid debug info
 
 define void @foo(i32 %a) {
 entry:
   %s = alloca i32
   call void @llvm.dbg.declare(metadata i32* %s, metadata !"", metadata !DIExpression()), !dbg !DILocation(scope: !1)
   ret void
 }
 
 declare void @llvm.dbg.declare(metadata, metadata, metadata)
 
 !llvm.module.flags = !{!0}
 !0 = !{i32 2, !"Debug Info Version", i32 3}
 !1 = distinct !DISubprogram()

llvm/trunk/test/Verifier/llvm.dbg.value-expression.ll

-; RUN: not llvm-as -disable-output <%s 2>&1 | FileCheck %s
+; RUN: llvm-as -disable-output <%s 2>&1 | FileCheck %s
 ; CHECK: invalid llvm.dbg.value intrinsic expression
 ; CHECK-NEXT: call void @llvm.dbg.value({{.*}})
 ; CHECK-NEXT: !""
+; CHECK: warning: ignoring invalid debug info
 
 define void @foo(i32 %a) {
 entry:
   %s = alloca i32
   call void @llvm.dbg.value(metadata i32* %s, i64 0, metadata !DILocalVariable(scope: !1), metadata !""), !dbg !DILocation(scope: !1)
   ret void
 }
 
 declare void @llvm.dbg.value(metadata, i64, metadata, metadata)
 
 !llvm.module.flags = !{!0}
 !0 = !{i32 2, !"Debug Info Version", i32 3}
 !1 = distinct !DISubprogram()

llvm/trunk/test/Verifier/llvm.dbg.value-value.ll

-; RUN: not llvm-as -disable-output <%s 2>&1 | FileCheck %s
+; RUN: llvm-as -disable-output <%s 2>&1 | FileCheck %s
 ; CHECK: invalid llvm.dbg.value intrinsic address/value
 ; CHECK-NEXT: call void @llvm.dbg.value({{.*}})
 ; CHECK-NEXT: !""
+; CHECK: warning: ignoring invalid debug info
 
 define void @foo(i32 %a) {
 entry:
   %s = alloca i32
   call void @llvm.dbg.value(metadata !"", i64 0, metadata !DILocalVariable(scope: !1), metadata !DIExpression()), !dbg !DILocation(scope: !1)
   ret void
 }
 
 declare void @llvm.dbg.value(metadata, i64, metadata, metadata)
 
 !llvm.module.flags = !{!0}
 !0 = !{i32 2, !"Debug Info Version", i32 3}
 !1 = distinct !DISubprogram()

llvm/trunk/test/Verifier/llvm.dbg.value-variable.ll

-; RUN: not llvm-as -disable-output <%s 2>&1 | FileCheck %s
+; RUN: llvm-as -disable-output <%s 2>&1 | FileCheck %s
 ; CHECK: invalid llvm.dbg.value intrinsic variable
 ; CHECK-NEXT: call void @llvm.dbg.value({{.*}})
 ; CHECK-NEXT: !""
+; CHECK: warning: ignoring invalid debug info
 
 define void @foo(i32 %a) {
 entry:
   %s = alloca i32
   call void @llvm.dbg.value(metadata i32* %s, i64 0, metadata !"", metadata !DIExpression()), !dbg !DILocation(scope: !1)
   ret void
 }
 
 declare void @llvm.dbg.value(metadata, i64, metadata, metadata)
 
 !llvm.module.flags = !{!0}
 !0 = !{i32 2, !"Debug Info Version", i32 3}
 !1 = distinct !DISubprogram()

llvm/trunk/test/Verifier/metadata-function-dbg.ll

-; RUN: not llvm-as %s -disable-output 2>&1 | FileCheck %s
+; RUN: llvm-as %s -disable-output 2>&1 | FileCheck %s
 
 ; CHECK:      function declaration may not have a !dbg attachment
 declare !dbg !4 void @f1()
 
 ; CHECK:      function must have a single !dbg attachment
 define void @f2() !dbg !4 !dbg !4 {
   unreachable
 }

 ; CHECK-NOT:  !dbg
 ; CHECK:      function !dbg attachment must be a subprogram
 ; CHECK-NEXT: void ()* @bar
 ; CHECK-NEXT: !{{[0-9]+}} = !{}
 define void @bar() !dbg !3 {
   unreachable
 }
 
+; CHECK: warning: ignoring invalid debug info
 !llvm.module.flags = !{!0}
 !0 = !{i32 2, !"Debug Info Version", i32 3}
 
 !llvm.dbg.cu = !{!1}
 !1 = distinct !DICompileUnit(language: DW_LANG_C99, file: !2)
 !2 = !DIFile(filename: "t.c", directory: "/path/to/dir")
 !3 = !{}
 !4 = distinct !DISubprogram(name: "foo", scope: !1, file: !2, unit: !1)

llvm/trunk/test/Verifier/pr34325.ll

-; RUN: not opt -verify %s 2>&1 | FileCheck %s
+; RUN: llvm-as -disable-output %s 2>&1 | FileCheck %s
 
 ; CHECK: invalid type ref
+; CHECK: warning: ignoring invalid debug info
 
 @bar = global i64 0, align 8, !dbg !0
 
 !llvm.dbg.cu = !{!2}
 !llvm.module.flags = !{!8}
 
 !0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
 !1 = !DIGlobalVariable(name: "c", scope: null, isLocal: false, isDefinition: true, type: !6)
 !2 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !3, isOptimized: false, runtimeVersion: 0, emissionKind: NoDebug, retainedTypes: !4, globals: !7)
 !3 = !DIFile(filename: "a", directory: "")
 !4 = !{!5}
 !5 = distinct !DICompositeType(tag: DW_TAG_class_type, scope: !6, file: !3, identifier: "patatino")
 !6 = distinct !DISubprogram(name: "b", scope: null, isLocal: false, isDefinition: true, isOptimized: false, unit: !2)
 !7 = !{!0}
 !8 = !{i32 2, !"Debug Info Version", i32 3}

llvm/trunk/test/Verifier/tbaa.ll

 ; RUN: not llvm-as < %s 2>&1 | FileCheck %s
-; RUN: llvm-as -disable-verify < %s 2>&1 | opt -verify -S | FileCheck %s  --check-prefix=STRIP
+; RUN: llvm-as -disable-verify < %s | opt -verify -S | FileCheck %s  --check-prefix=STRIP
 
 ; STRIP-NOT: tbaa
 ; STRIP: @f_0
 ; STRIP: Do no strip this
 define void @f_0(i32* %ptr) {
 ; This part checks for the easy syntactic verifier rules.
 
 ; CHECK: Struct tag metadata must have either 3 or 4 operands

llvm/trunk/tools/llvm-as/llvm-as.cpp

int main(int argc, char **argv) {
   sys::PrintStackTraceOnErrorSignal(argv[0]);
   PrettyStackTraceProgram X(argc, argv);
   LLVMContext Context;
   llvm_shutdown_obj Y; // Call llvm_shutdown() on exit.
   cl::ParseCommandLineOptions(argc, argv, "llvm .ll -> .bc assembler\n");
 
   // Parse the file now...
   SMDiagnostic Err;
-  std::unique_ptr<Module> M = parseAssemblyFile(InputFilename, Err, Context);
+  std::unique_ptr<Module> M =
+      parseAssemblyFile(InputFilename, Err, Context, nullptr, !DisableVerify);
   if (!M.get()) {
     Err.print(argv[0], errs());
     return 1;
   }
 
   if (!DisableVerify) {
     std::string ErrorStr;
     raw_string_ostream OS(ErrorStr);

llvm/trunk/tools/opt/opt.cpp

if (EC) {
       errs() << EC.message() << '\n';
       return 1;
     }
     Context.setDiagnosticsOutputFile(
         llvm::make_unique<yaml::Output>(OptRemarkFile->os()));
   }
 
   // Load the input module...
-  std::unique_ptr<Module> M = parseIRFile(InputFilename, Err, Context);
+  std::unique_ptr<Module> M =
+      parseIRFile(InputFilename, Err, Context, !NoVerify);
 
   if (!M) {
     Err.print(argv[0], errs());
     return 1;
   }
 
   // Strip debug info before running the verifier.
   if (StripDebug)

llvm/trunk/unittests/IR/VerifierTest.cpp

 #include "llvm/IR/DIBuilder.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/GlobalAlias.h"
 #include "llvm/IR/GlobalVariable.h"
 #include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/LLVMContext.h"
-#include "llvm/IR/LegacyPassManager.h"
 #include "llvm/IR/Module.h"
 #include "gtest/gtest.h"
 
 namespace llvm {
 namespace {
 
 TEST(VerifierTest, Branch_i1) {
   LLVMContext C;
TEST(VerifierTest, InvalidFunctionLinkage) {
   std::string Error;
   raw_string_ostream ErrorOS(Error);
   EXPECT_TRUE(verifyModule(M, &ErrorOS));
   EXPECT_TRUE(
       StringRef(ErrorOS.str()).startswith("Global is external, but doesn't "
                                           "have external or weak linkage!"));
 }
 
-TEST(VerifierTest, StripInvalidDebugInfo) {
+TEST(VerifierTest, DetectInvalidDebugInfo) {
   {
     LLVMContext C;
     Module M("M", C);
     DIBuilder DIB(M);
     DIB.createCompileUnit(dwarf::DW_LANG_C89, DIB.createFile("broken.c", "/"),
                           "unittest", false, "", 0);
     DIB.finalize();
     EXPECT_FALSE(verifyModule(M));
 
     // Now break it by inserting non-CU node to the list of CUs.
     auto *File = DIB.createFile("not-a-CU.f", ".");
     NamedMDNode *NMD = M.getOrInsertNamedMetadata("llvm.dbg.cu");
     NMD->addOperand(File);
     EXPECT_TRUE(verifyModule(M));
-
-    ModulePassManager MPM(true);
-    MPM.addPass(VerifierPass(false));
-    ModuleAnalysisManager MAM(true);
-    MAM.registerPass([&] { return VerifierAnalysis(); });
-    MPM.run(M, MAM);
-    EXPECT_FALSE(verifyModule(M));
   }
   {
     LLVMContext C;
     Module M("M", C);
     DIBuilder DIB(M);
     auto *CU = DIB.createCompileUnit(dwarf::DW_LANG_C89,
                                      DIB.createFile("broken.c", "/"),
                                      "unittest", false, "", 0);
     new GlobalVariable(M, Type::getInt8Ty(C), false,
                        GlobalValue::ExternalLinkage, nullptr, "g");
 
     auto *F = cast<Function>(M.getOrInsertFunction(
         "f", FunctionType::get(Type::getVoidTy(C), false)));
     IRBuilder<> Builder(BasicBlock::Create(C, "", F));
     Builder.CreateUnreachable();
     F->setSubprogram(DIB.createFunction(CU, "f", "f",
                                         DIB.createFile("broken.c", "/"), 1,
                                         nullptr, true, true, 1));
     DIB.finalize();
     EXPECT_FALSE(verifyModule(M));
 
     // Now break it by not listing the CU at all.
     M.eraseNamedMetadata(M.getOrInsertNamedMetadata("llvm.dbg.cu"));
     EXPECT_TRUE(verifyModule(M));
-
-    ModulePassManager MPM(true);
-    MPM.addPass(VerifierPass(false));
-    ModuleAnalysisManager MAM(true);
-    MAM.registerPass([&] { return VerifierAnalysis(); });
-    MPM.run(M, MAM);
-    EXPECT_FALSE(verifyModule(M));
-  }
   }
-
-TEST(VerifierTest, StripInvalidDebugInfoLegacy) {
-  LLVMContext C;
-  Module M("M", C);
-  DIBuilder DIB(M);
-  DIB.createCompileUnit(dwarf::DW_LANG_C89, DIB.createFile("broken.c", "/"),
-                        "unittest", false, "", 0);
-  DIB.finalize();
-  EXPECT_FALSE(verifyModule(M));
-
-  // Now break it.
-  auto *File = DIB.createFile("not-a-CU.f", ".");
-  NamedMDNode *NMD = M.getOrInsertNamedMetadata("llvm.dbg.cu");
-  NMD->addOperand(File);
-  EXPECT_TRUE(verifyModule(M));
-
-  legacy::PassManager Passes;
-  Passes.add(createVerifierPass(false));
-  Passes.run(M);
-  EXPECT_FALSE(verifyModule(M));
 }
 
 } // end anonymous namespace
 } // end namespace llvm