Improve static analysis of cold basic blocks

[hiraditya]

Summary

A basic block calling one of exception handling routines is cold.

[sebpop]

Looks good.

llvm/trunk/lib/Transforms/IPO/HotColdSplitting.cpp

if (BB.empty())
     return true;
   const TerminatorInst *I = BB.getTerminator();
   if (isa<ReturnInst>(I) || isa<IndirectBrInst>(I))
     return true;
   // Unreachable blocks do not have any successor.
   return succ_empty(&BB);
 }
 
+static bool exceptionHandlingFunctions(const CallInst *CI) {
+  auto F = CI->getCalledFunction();
+  if (!F)
+    return false;
+  auto FName = F->getName();
+  return FName == "__cxa_begin_catch" ||
+         FName == "__cxa_free_exception" ||
+         FName == "__cxa_allocate_exception" ||
+         FName == "__cxa_begin_catch" ||
+         FName == "__cxa_end_catch";
+}
+
 static
 bool unlikelyExecuted(const BasicBlock &BB) {
   if (blockEndsInUnreachable(BB))
     return true;
   // Exception handling blocks are unlikely executed.
   if (BB.isEHPad())
     return true;
   for (const Instruction &I : BB)
     if (const CallInst *CI = dyn_cast<CallInst>(&I)) {
       // The block is cold if it calls functions tagged as cold or noreturn.
       if (CI->hasFnAttr(Attribute::Cold) ||
-          CI->hasFnAttr(Attribute::NoReturn))
+          CI->hasFnAttr(Attribute::NoReturn) ||
+          exceptionHandlingFunctions(CI))
         return true;
 
       // Assume that inline assembly is hot code.
       if (isa<InlineAsm>(CI->getCalledValue()))
         return false;
     }
   return false;
 }