llvm-diff: Fix crash on anonymous functions

[arsenm]

Summary

Not sure what the correct behavior is for this.
Skip them and report how many there were.

[rjmccall]

LGTM. And yeah, I don't have a better recommendation in the short term. Long-term, maybe we can try to match them up by uses or types.

[arsenm]

r342857

test/tools/llvm-diff/anon-func.ll

+; RUN: llvm-diff %s %s 2>&1 | FileCheck %s
+
+; CHECK: not comparing 1 anonymous functions in the left module and 1 in the right module
+
+define void @0() {
+  ret void
+}
+

tools/llvm-diff/DifferenceEngine.cpp

void DifferenceEngine::diff(Function *L, Function *R) {
   else
     FunctionDifferenceEngine(*this).diff(L, R);
 }
 
 void DifferenceEngine::diff(Module *L, Module *R) {
   StringSet<> LNames;
   SmallVector<std::pair<Function*,Function*>, 20> Queue;
 
+  unsigned LeftAnonCount = 0;
+  unsigned RightAnonCount = 0;
+
   for (Module::iterator I = L->begin(), E = L->end(); I != E; ++I) {
     Function *LFn = &*I;
-    LNames.insert(LFn->getName());
+    StringRef Name = LFn->getName();
+    if (Name.empty()) {
+      ++LeftAnonCount;
+      continue;
+    }
+
+    LNames.insert(Name);
 
     if (Function *RFn = R->getFunction(LFn->getName()))
       Queue.push_back(std::make_pair(LFn, RFn));
     else
       logf("function %l exists only in left module") << LFn;
   }
 
   for (Module::iterator I = R->begin(), E = R->end(); I != E; ++I) {
     Function *RFn = &*I;
-    if (!LNames.count(RFn->getName()))
+    StringRef Name = RFn->getName();
+    if (Name.empty()) {
+      ++RightAnonCount;
+      continue;
+    }
+
+    if (!LNames.count(Name))
       logf("function %r exists only in right module") << RFn;
   }
 
+
+  if (LeftAnonCount != 0 || RightAnonCount != 0) {
+    SmallString<32> Tmp;
+    Twine Message = "not comparing " + Twine(LeftAnonCount) +
+      " anonymous functions in the left module and " + Twine(RightAnonCount) +
+      " in the right module";
+    logf(Message.toStringRef(Tmp));
+  }
+
   for (SmallVectorImpl<std::pair<Function*,Function*> >::iterator
          I = Queue.begin(), E = Queue.end(); I != E; ++I)
     diff(I->first, I->second);
 }
 
 bool DifferenceEngine::equivalentAsOperands(GlobalValue *L, GlobalValue *R) {
   if (globalValueOracle) return (*globalValueOracle)(L, R);
   return L->getName() == R->getName();
 }