Revert "Don't invoke getName() from Function::isIntrinsic().", rL276942.

This broke some out-of-tree AMDGPU tests that relied on the old behavior
wherein isIntrinsic() would return true for any function that starts
with "llvm.".  And in general that change will not play nicely with
out-of-tree backends.

llvm-svn: 277087

include/llvm/IR/Function.h

@@ -137,13 +137,7 @@ public:
   /// The particular intrinsic functions which correspond to this value are
   /// defined in llvm/Intrinsics.h.
   Intrinsic::ID getIntrinsicID() const LLVM_READONLY { return IntID; }
-  bool isIntrinsic() const {
-    // Intrinsic::not_intrinsic must be 0.
-    return IntID != 0;
-  }
-  /// Return true if the function's name starts with "llvm.".  All intrinsics
-  /// have this prefix.
-  bool hasLLVMReservedName() const { return getName().startswith("llvm."); }
+  bool isIntrinsic() const { return getName().startswith("llvm."); }
 
   /// \brief Recalculate the ID for this function if it is an Intrinsic defined
   /// in llvm/Intrinsics.h.  Sets the intrinsic ID to Intrinsic::not_intrinsic

lib/CodeGen/WinEHPrepare.cpp

@@ -949,14 +949,10 @@ void WinEHPrepare::removeImplausibleInstructions(Function &F) {
           continue;
 
         // Skip call sites which are nounwind intrinsics or inline asm.
-        //
-        // FIXME: Should this check isIntrinsic() instead of
-        // hasLLVMReservedName?  The latter is conservative.
         auto *CalledFn =
             dyn_cast<Function>(CS.getCalledValue()->stripPointerCasts());
-        if (CalledFn &&
-            ((CalledFn->hasLLVMReservedName() && CS.doesNotThrow()) ||
-             CS.isInlineAsm()))
+        if (CalledFn && ((CalledFn->isIntrinsic() && CS.doesNotThrow()) ||
+                         CS.isInlineAsm()))
           continue;
 
         // This call site was not part of this funclet, remove it.

lib/IR/AsmWriter.cpp

@@ -905,7 +905,7 @@ void SlotTracker::processInstructionMetadata(const Instruction &I) {
   // Process metadata used directly by intrinsics.
   if (const CallInst *CI = dyn_cast<CallInst>(&I))
     if (Function *F = CI->getCalledFunction())
-      if (F->hasLLVMReservedName())
+      if (F->isIntrinsic())
         for (auto &Op : I.operands())
           if (auto *V = dyn_cast_or_null<MetadataAsValue>(Op))
             if (MDNode *N = dyn_cast<MDNode>(V->getMetadata()))
@@ -3378,7 +3378,7 @@ void Type::print(raw_ostream &OS, bool /*IsForDebug*/, bool NoDetails) const {
 static bool isReferencingMDNode(const Instruction &I) {
   if (const auto *CI = dyn_cast<CallInst>(&I))
     if (Function *F = CI->getCalledFunction())
-      if (F->hasLLVMReservedName())
+      if (F->isIntrinsic())
         for (auto &Op : I.operands())
           if (auto *V = dyn_cast_or_null<MetadataAsValue>(Op))
             if (isa<MDNode>(V->getMetadata()))

lib/IR/Function.cpp

@@ -488,7 +488,9 @@ static ArrayRef<const char *> findTargetSubtable(StringRef Name) {
 
 /// \brief This does the actual lookup of an intrinsic ID which
 /// matches the given function name.
-static Intrinsic::ID lookupIntrinsicID(StringRef Name) {
+static Intrinsic::ID lookupIntrinsicID(const ValueName *ValName) {
+  StringRef Name = ValName->getKey();
+
   ArrayRef<const char *> NameTable = findTargetSubtable(Name);
   int Idx = Intrinsic::lookupLLVMIntrinsicByName(NameTable, Name);
   if (Idx == -1)
@@ -506,11 +508,12 @@ static Intrinsic::ID lookupIntrinsicID(StringRef Name) {
 }
 
 void Function::recalculateIntrinsicID() {
-  if (!hasLLVMReservedName()) {
+  const ValueName *ValName = this->getValueName();
+  if (!ValName || !isIntrinsic()) {
     IntID = Intrinsic::not_intrinsic;
     return;
   }
-  IntID = lookupIntrinsicID(getName());
+  IntID = lookupIntrinsicID(ValName);
 }
 
 /// Returns a stable mangling for the type specified for use in the name

lib/IR/Verifier.cpp

@@ -3657,7 +3657,7 @@ void Verifier::visitInstruction(Instruction &I) {
       // Check to make sure that the "address of" an intrinsic function is never
       // taken.
       Assert(
-          !F->hasLLVMReservedName() ||
+          !F->isIntrinsic() ||
               i == (isa<CallInst>(I) ? e - 1 : isa<InvokeInst>(I) ? e - 3 : 0),
           "Cannot take the address of an intrinsic!", &I);
       Assert(