[functionattrs] Ignore intrinsics that show up as affecting memory, but don't.

[mcrosier]

Summary

These are just markers and should be ignored.

Just something I saw in passing, but I"m not interested in pursuing at this time..

Chad

lib/Transforms/IPO/FunctionAttrs.cpp

static MemoryAccessKind checkFunctionMemoryAccess(Function &F, AAResults &AAR,
   // Scan the function body for instructions that may read or write memory.
   bool ReadsMemory = false;
   for (inst_iterator II = inst_begin(F), E = inst_end(F); II != E; ++II) {
     Instruction *I = &*II;
 
     // Some instructions can be ignored even if they read or write memory.
     // Detect these now, skipping to the next instruction if one is found.
     CallSite CS(cast<Value>(I));
-    if (CS) {
+    if (auto *II = dyn_cast<IntrinsicInst>(I)) {
+      // These intrinsics will show up as affecting memory, but they are just
+      // markers.
+      bool IsMarker = false;
+      switch (II->getIntrinsicID()) {
+      default:
+        break;
+      case Intrinsic::lifetime_start:
+      case Intrinsic::lifetime_end:
+      case Intrinsic::invariant_start:
+      case Intrinsic::invariant_end:
+      case Intrinsic::assume:
+        IsMarker = true;
+      }
+      if (IsMarker)
+        continue;
+    } else if (CS) {
       // Ignore calls to functions in the same SCC, as long as the call sites
       // don't have operand bundles.  Calls with operand bundles are allowed to
       // have memory effects not described by the memory effects of the call
       // target.
       if (!CS.hasOperandBundles() && CS.getCalledFunction() &&
           SCCNodes.count(CS.getCalledFunction()))
         continue;
       FunctionModRefBehavior MRB = AAR.getModRefBehavior(CS);