maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

Verifier: Simplify and fix issue where we were not verifying unmaterialized functions. 

Arrange to call verify(Function &) on each function, followed by
verify(Module &), whether the verifier is being used from the pass or
from verifyModule(). As a side effect, this fixes an issue that caused
us not to call verify(Function &) on unmaterialized functions from
verifyModule().

Differential Revision: http://reviews.llvm.org/D21042

llvm-svn: 271956
This commit is contained in:
Peter Collingbourne 2016-06-06 23:21:27 +00:00
parent 7e4e69abe2
commit bb738170a9
2 changed files with 18 additions and 15 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
llvm/lib/IR/Verifier.cpp
View File

@ -314,17 +314,10 @@ public:
Context = &M.getContext();
Broken = false;
// Scan through, checking all of the external function's linkage now...
for (const Function &F : M) {
visitGlobalValue(F);
// Check to make sure function prototypes are okay.
if (F.isDeclaration()) {
visitFunction(F);
// Collect all declarations of the llvm.experimental.deoptimize intrinsic.
for (const Function &F : M)
if (F.getIntrinsicID() == Intrinsic::experimental_deoptimize)
DeoptimizeDeclarations.push_back(&F);
}
}
// Now that we've visited every function, verify that we never asked to
// recover a frame index that wasn't escaped.
@ -1866,6 +1859,8 @@ void Verifier::verifySiblingFuncletUnwinds() {
// visitFunction - Verify that a function is ok.
//
void Verifier::visitFunction(const Function &F) {
visitGlobalValue(F);
// Check function arguments.
FunctionType *FT = F.getFunctionType();
unsigned NumArgs = F.arg_size();
@ -4427,7 +4422,6 @@ void Verifier::verifyDeoptimizeCallingConvs() {
bool llvm::verifyFunction(const Function &f, raw_ostream *OS) {
Function &F = const_cast<Function &>(f);
assert(!F.isDeclaration() && "Cannot verify external functions");
// Don't use a raw_null_ostream. Printing IR is expensive.
Verifier V(OS, /*ShouldTreatBrokenDebugInfoAsError=*/true);
@ -4444,7 +4438,6 @@ bool llvm::verifyModule(const Module &M, raw_ostream *OS,
bool Broken = false;
for (const Function &F : M)
if (!F.isDeclaration() && !F.isMaterializable())
Broken |= !V.verify(F);
Broken |= !V.verify(M);
@ -4482,7 +4475,12 @@ struct VerifierLegacyPass : public FunctionPass {
}
bool doFinalization(Module &M) override {
bool HasErrors = !V.verify(M);
bool HasErrors = false;
for (Function &F : M)
if (F.isDeclaration())
HasErrors |= !V.verify(F);
HasErrors |= !V.verify(M);
if (FatalErrors) {
if (HasErrors)
report_fatal_error("Broken module found, compilation aborted!");

5
llvm/unittests/IR/MetadataTest.cpp
View File

@ -2253,7 +2253,12 @@ TEST_F(FunctionAttachmentTest, Verifier) {
// be verified directly, so check that the module fails to verify).
EXPECT_TRUE(verifyModule(*F->getParent()));
// Nor can materializable functions.
F->setIsMaterializable(true);
EXPECT_TRUE(verifyModule(*F->getParent()));
// Functions with a body can.
F->setIsMaterializable(false);
(void)new UnreachableInst(Context, BasicBlock::Create(Context, "bb", F));
EXPECT_FALSE(verifyModule(*F->getParent()));
EXPECT_FALSE(verifyFunction(*F));