Analysis: Do not create call graph nodes for intrinsic functions.

[pcc]

Summary

Intrinsic functions do not participate in the call graph, so there is no
need to create call graph nodes for them.

This has the effect of inhibiting SCC-based function attribute inference for
intrinsic functions, which was previously incorrectly setting the readnone
attribute on the llvm.assume intrinsic as a result of propagating the AA
result introduced in D19730 to its attributes.

[llvm-commits]

You should probably note somewhere that assume is, in fact, readnone, we
just don't model it that way right now because it hasn't been changed to
use a real control dependency instead of a fake memory one.

:)

• msg-9431-7.txt162 BDownload

[pcc]

That's already noted in the definition of llvm.assume I believe: http://llvm-cs.pcc.me.uk/include/llvm/IR/Intrinsics.td#324

[pcc]

Obsoleted by D20658

lib/Analysis/CallGraph.cpp

 // assertion from firing.
 #ifndef NDEBUG
   for (auto &I : FunctionMap)
     I.second->allReferencesDropped();
 #endif
 }
 
 void CallGraph::addToCallGraph(Function *F) {
+  if (F->isIntrinsic())
+    return;
+
   CallGraphNode *Node = getOrInsertFunction(F);
 
   // If this function has external linkage, anything could call it.
   if (!F->hasLocalLinkage()) {
     ExternalCallingNode->addCalledFunction(CallSite(), Node);
 
     // Found the entry point?
     if (F->getName() == "main") {
       if (Root) // Found multiple external mains?  Don't pick one.
         Root = ExternalCallingNode;
       else
         Root = Node; // Found a main, keep track of it!
     }
   }
 
   // If this function has its address taken, anything could call it.
   if (F->hasAddressTaken())
     ExternalCallingNode->addCalledFunction(CallSite(), Node);
 
   // If this function is not defined in this translation unit, it could call
   // anything.
-  if (F->isDeclaration() && !F->isIntrinsic())
+  if (F->isDeclaration())
     Node->addCalledFunction(CallSite(), CallsExternalNode.get());
 
   // Look for calls by this function.
   for (Function::iterator BB = F->begin(), BBE = F->end(); BB != BBE; ++BB)
     for (BasicBlock::iterator II = BB->begin(), IE = BB->end(); II != IE;
          ++II) {
       CallSite CS(cast<Value>(II));
       if (CS) {

lib/Transforms/IPO/PruneEH.cpp

if (!F) {
             break;
 
           // Check to see if this function performs an unwind or calls an
           // unwinding function.
           if (CheckUnwind && !SCCMightUnwind && I.mayThrow()) {
             bool InstMightUnwind = true;
             if (const auto *CI = dyn_cast<CallInst>(&I)) {
               if (Function *Callee = CI->getCalledFunction()) {
+                // The call graph does not contain intrinsics.
+                if (!Callee->isIntrinsic()) {
                   CallGraphNode *CalleeNode = CG[Callee];
                   // If the callee is outside our current SCC then we may throw
                   // because it might.  If it is inside, do nothing.
                   if (SCCNodes.count(CalleeNode) > 0)
                     InstMightUnwind = false;
                 }
               }
+            }
             SCCMightUnwind |= InstMightUnwind;
           }
           if (CheckReturnViaAsm && !SCCMightReturn)
             if (auto ICS = ImmutableCallSite(&I))
               if (const auto *IA = dyn_cast<InlineAsm>(ICS.getCalledValue()))
                 if (IA->hasSideEffects())
                   SCCMightReturn = true;
         }

test/Transforms/FunctionAttrs/assume.ll

+; RUN: opt -S -o - -functionattrs %s | FileCheck %s
+
+; CHECK-NOT: readnone
+declare void @llvm.assume(i1)