Intrinsic::getName: require a Module argument

[jeroen.dobbelaere]

Summary

Ensure that we provide a Module when checking if a rename of an intrinsic is necessary.

This fixes the issue that was detected by https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=32288
(as mentioned by @fhahn), after committing D91250.

Note that the LLVMIntrinsicCopyOverloadedName is being deprecated in favor of LLVMIntrinsicCopyOverloadedName2.

[jeroen.dobbelaere]

• rebased
• Introduced LLVMIntrinscicCopyOverloadedName2(...), Introduced `getBaseName(...)'

[fhahn]

Thanks for putting up this patch! I think it's preferable to D99066, because it ensures the Module is always available if it might be needed. It's probably also worth adding a note to the release notes?

llvm/include/llvm-c/Core.h

2550

Not sure about the name, but I think Eric's suggestion of LLVMIntrinsicCopyOverloadedNameWithModule on the list seems a bit more descriptive to me. Not sure what others think and naming is hard.

[jeroen.dobbelaere]

llvm/include/llvm-c/Core.h

2550

There are already 17 other deprecations in favor of a '...2' name. (ex. LLVMBuildLoad2, LLVMMDStringInContext2, ...)
Which seems to be far more than the deprecations in favor of a different name. (ex. LLVMGetUnnamedAddress instead of LLVMHasUnnamedAddr2)

For this particular case, my impression is that the '...2' name is easier to grasp and to understand what it will do. In the '...WithModule', somehow I get the feeling the the module will also be copied ?

Maybe it is better to completely deprecate the original version ?

Also I am thinking of moving the ModuleRef to the beginning. What do you think ?

[jeroen.dobbelaere]

• Deprecating LLVMIntrinsicCopyOverloadedName
• Added release note.

[jeroen.dobbelaere]

ping

[echristo]

llvm/include/llvm-c/Core.h

2550

I mostly think that the "2" names aren't particularly enlightening or helpful. I'd prefer something that doesn't give us a "3" when we need or want a new argument. WithModule is perhaps not a good naming, as Florian said it's hard. Any other thoughts? ID or ModuleRef should be first. Might want to take a look at some of the other C++ intrinsic calls to get a feel for it.

[jeroen.dobbelaere]

Thanks for the feedback.

llvm/include/llvm-c/Core.h

2550

I mostly think that the "2" names aren't particularly enlightening or helpful. I'd prefer something that doesn't give us a "3" when we need or want a new argument. WithModule is perhaps not a good naming, as Florian said it's hard. Any other thoughts? ID or ModuleRef should be first. Might want to take a look at some of the other C++ intrinsic calls to get a feel for it.

I already moved the ModuleRef to the front, similar as in LLVMGetIntrinsicDeclaration(Mod, ID, ..).
I also looked at the history of Core.h to get a feeling about the naming. My impression is that api updates result in a new different name when that makes the api cleaner as well. In other cases, the need to add arguments resulted in adding a 2 as suffix, and deprecating the original one. (See LLVMBuildGEP2, LLVMBuildStructGEP2, LLVMGetValueName2, ...).

[jeroen.dobbelaere]

Other possible alternative names:

• LLVMIntrinsicCopyOverloadedNameSupportingUnnamedTypes: maybe too long ?
• LLVMIntrinsicCopyOverloadedNameWithModule : the WithModule part is strange
• LLVMIntrinsicCopyOverloadedName2 : feels most natural to me: we needed to update the signature, but the functionality is still the same.

My current preference is still LLVMIntrinsicCopyOverloadedName2, although the LLVMIntrinsicCopyOverloadedNameSupportingUnnamedTypes also sounds ok.

What do you think ?

[jeroen.dobbelaere]

ping

[efriedma]

I don't really have any opinion on the name; otherwise looks fine.

llvm/include/llvm/IR/Intrinsics.h

66–74

I'd prefer to just say "M" is mandatory, rather than "recommended"; getNameNoUnnamedTypes is still available if anyone really needs it.

[jeroen.dobbelaere]

• Rebased
• Made the M parameter for 'getName' mandatory (with an assertion check)
• I got mixed feedback with regard to the naming. I decided to settle on 'LLVMIntrinsicCopyOverloadedName2'.

[jeroen.dobbelaere]

llvm/include/llvm/IR/Intrinsics.h

66–74

I removed the mentioning of M in the documentation and added an assertion check.

[jeroen.dobbelaere]

Ping.. I would think this one is ok to land ?

[nikic]

LGTM

llvm/lib/IR/Function.cpp

856

proved -> provide

860–862

... would be more obvious here, I think.

864

Why do we need the Intrinsic:: prefix now? Just a style change?

[jeroen.dobbelaere]

Rebased; Taken Nikita's comments into account.

[jeroen.dobbelaere]

Thanks for the review and the feedback !

llvm/lib/IR/Function.cpp

864

This now is a file local static function and we need the explicit Intrinsic:: to access the getType(...) method.

llvm/docs/ReleaseNotes.rst

 
 Changes to the OCaml bindings
 -----------------------------
 
 
 Changes to the C API
 --------------------
 
+* The C API function ``LLVMIntrinsicCopyOverloadedName`` has been deprecated.
+  Please migrate to ``LLVMIntrinsicCopyOverloadedName2`` which takes an extra
+  module argument and which also handles unnamed types.
+  ('D99173' <https://reviews.llvm.org/D99173>'_)
 
 Changes to the Go bindings
 --------------------------
 
 
 Changes to the FastISel infrastructure
 --------------------------------------
 

llvm/include/llvm-c/Core.h

 
 /**
  * Retrieves the name of an intrinsic.
  *
  * @see llvm::Intrinsic::getName()
  */
 const char *LLVMIntrinsicGetName(unsigned ID, size_t *NameLength);
 
+/** Deprecated: Use LLVMIntrinsicCopyOverloadedName2 instead. */
+const char *LLVMIntrinsicCopyOverloadedName(unsigned ID,
+                                            LLVMTypeRef *ParamTypes,
+                                            size_t ParamCount,
+                                            size_t *NameLength);
+
 /**
  * Copies the name of an overloaded intrinsic identified by a given list of
  * parameter types.
  *
  * Unlike LLVMIntrinsicGetName, the caller is responsible for freeing the
  * returned string.
  *
+ * This version also supports unnamed types.
+ *
  * @see llvm::Intrinsic::getName()
  */
-const char *LLVMIntrinsicCopyOverloadedName(unsigned ID,
+const char *LLVMIntrinsicCopyOverloadedName2(LLVMModuleRef Mod, unsigned ID,
                                              LLVMTypeRef *ParamTypes,
                                              size_t ParamCount,
                                              size_t *NameLength);
 
 /**
  * Obtain if the intrinsic identified by the given ID is overloaded.
  *
  * @see llvm::Intrinsic::isOverloaded()
  */
 LLVMBool LLVMIntrinsicIsOverloaded(unsigned ID);
 
 /**
  * Obtain the calling function of a function.
  *
  * The returned value corresponds to the LLVMCallConv enumeration.
  *
  * @see llvm::Function::getCallingConv()
  */
 unsigned LLVMGetFunctionCallConv(LLVMValueRef Fn);
 
 /**
  * Set the calling convention of a function.
  *
  * @see llvm::Function::setCallingConv()

llvm/include/llvm/IR/Intrinsics.h

 #undef GET_INTRINSIC_ENUM_VALUES
   };
 
   /// Return the LLVM name for an intrinsic, such as "llvm.ppc.altivec.lvx".
   /// Note, this version is for intrinsics with no overloads.  Use the other
   /// version of getName if overloads are required.
   StringRef getName(ID id);
 
-  /// Return the LLVM name for an intrinsic, such as "llvm.ppc.altivec.lvx".
-  /// Note, this version of getName supports overloads, but not unnamed types.
-  /// It is less efficient than the StringRef version of this function. If no
-  /// overloads are required, it is safe to use this version, but better to use
-  /// the StringRef version.
-  std::string getName(ID Id, ArrayRef<Type *> Tys);
-
-  /// Return the LLVM name for an intrinsic, such as "llvm.ssa.copy.p0s_s.1".
-  /// Note, this version of getName supports overloads and unnamed types, but is
-  /// less efficient than the StringRef version of this function.  If no
+  /// Return the LLVM name for an intrinsic, without encoded types for
+  /// overloading, such as "llvm.ssa.copy".
+  StringRef getBaseName(ID id);
+
+  /// Return the LLVM name for an intrinsic, such as "llvm.ppc.altivec.lvx" or
+  /// "llvm.ssa.copy.p0s_s.1". Note, this version of getName supports overloads.
+  /// This is less efficient than the StringRef version of this function.  If no
   /// overloads are required, it is safe to use this version, but better to use
-  /// the StringRef version. A function type FT can be provided to avoid
-  /// computing it. It is used (or computed) if one of the types is based on an
-  /// unnamed type.
-  std::string getName(ID Id, ArrayRef<Type *> Tys, Module *M, FunctionType *FT);
+  /// the StringRef version. If one of the types is based on an unnamed type, a
+  /// function type will be computed. Providing FT will avoid this computation.
+  std::string getName(ID Id, ArrayRef<Type *> Tys, Module *M,
+                      FunctionType *FT = nullptr);
+
+  /// Return the LLVM name for an intrinsic. This is a special version only to
+  /// be used by LLVMIntrinsicCopyOverloadedName. It only supports overloads
+  /// based on named types.
+  std::string getNameNoUnnamedTypes(ID Id, ArrayRef<Type *> Tys);
 
   /// Return the function type for an intrinsic.
   FunctionType *getType(LLVMContext &Context, ID id,
                         ArrayRef<Type*> Tys = None);
 
   /// Returns true if the intrinsic can be overloaded.
   bool isOverloaded(ID id);
 

llvm/lib/CodeGen/MachineOperand.cpp

if (const MachineFunction *MF = getMFIfAvailable(*this))
       printCFI(OS, MF->getFrameInstructions()[getCFIIndex()], TRI);
     else
       OS << "<cfi directive>";
     break;
   }
   case MachineOperand::MO_IntrinsicID: {
     Intrinsic::ID ID = getIntrinsicID();
     if (ID < Intrinsic::num_intrinsics)
-      OS << "intrinsic(@" << Intrinsic::getName(ID, None) << ')';
+      OS << "intrinsic(@" << Intrinsic::getBaseName(ID) << ')';
     else if (IntrinsicInfo)
       OS << "intrinsic(@" << IntrinsicInfo->getName(ID) << ')';
     else
       OS << "intrinsic(" << ID << ')';
     break;
   }
   case MachineOperand::MO_Predicate: {
     auto Pred = static_cast<CmpInst::Predicate>(getPredicate());

llvm/lib/CodeGen/ReplaceWithVeclib.cpp

for (auto Arg : enumerate(CI.arg_operands())) {
     }
   }
 
   // Try to reconstruct the name for the scalar version of this
   // intrinsic using the intrinsic ID and the argument types
   // converted to scalar above.
   std::string ScalarName;
   if (Intrinsic::isOverloaded(IntrinsicID)) {
-    ScalarName = Intrinsic::getName(IntrinsicID, ScalarTypes);
+    ScalarName = Intrinsic::getName(IntrinsicID, ScalarTypes, CI.getModule());
   } else {
     ScalarName = Intrinsic::getName(IntrinsicID).str();
   }
 
   if (!TLI.isFunctionVectorizable(ScalarName)) {
     // The TargetLibraryInfo does not contain a vectorized version of
     // the scalar function.
     return false;

llvm/lib/CodeGen/SelectionDAG/SelectionDAGDumper.cpp

#endif
   case ISD::ExternalSymbol:             return "ExternalSymbol";
   case ISD::BlockAddress:               return "BlockAddress";
   case ISD::INTRINSIC_WO_CHAIN:
   case ISD::INTRINSIC_VOID:
   case ISD::INTRINSIC_W_CHAIN: {
     unsigned OpNo = getOpcode() == ISD::INTRINSIC_WO_CHAIN ? 0 : 1;
     unsigned IID = cast<ConstantSDNode>(getOperand(OpNo))->getZExtValue();
     if (IID < Intrinsic::num_intrinsics)
-      return Intrinsic::getName((Intrinsic::ID)IID, None);
+      return Intrinsic::getBaseName((Intrinsic::ID)IID).str();
     else if (!G)
       return "Unknown intrinsic";
     else if (const TargetIntrinsicInfo *TII = G->getTarget().getIntrinsicInfo())
       return TII->getName(IID);
     llvm_unreachable("Invalid intrinsic ID");
   }
 
   case ISD::BUILD_VECTOR:               return "BUILD_VECTOR";

llvm/lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp

if (N->getOpcode() != ISD::INTRINSIC_W_CHAIN &&
       N->getOpcode() != ISD::INTRINSIC_VOID) {
     N->printrFull(Msg, CurDAG);
     Msg << "\nIn function: " << MF->getName();
   } else {
     bool HasInputChain = N->getOperand(0).getValueType() == MVT::Other;
     unsigned iid =
       cast<ConstantSDNode>(N->getOperand(HasInputChain))->getZExtValue();
     if (iid < Intrinsic::num_intrinsics)
-      Msg << "intrinsic %" << Intrinsic::getName((Intrinsic::ID)iid, None);
+      Msg << "intrinsic %" << Intrinsic::getBaseName((Intrinsic::ID)iid);
     else if (const TargetIntrinsicInfo *TII = TM.getIntrinsicInfo())
       Msg << "target intrinsic %" << TII->getName(iid);
     else
       Msg << "unknown intrinsic #" << iid;
   }
   report_fatal_error(Msg.str());
 }
 
 char SelectionDAGISel::ID = 0;

llvm/lib/IR/AutoUpgrade.cpp

static bool UpgradeIntrinsicFunction1(Function *F, Function *&NewFn) {
   case 'i':
   case 'l': {
     bool IsLifetimeStart = Name.startswith("lifetime.start");
     if (IsLifetimeStart || Name.startswith("invariant.start")) {
       Intrinsic::ID ID = IsLifetimeStart ?
         Intrinsic::lifetime_start : Intrinsic::invariant_start;
       auto Args = F->getFunctionType()->params();
       Type* ObjectPtr[1] = {Args[1]};
-      if (F->getName() != Intrinsic::getName(ID, ObjectPtr)) {
+      if (F->getName() != Intrinsic::getName(ID, ObjectPtr, F->getParent())) {
         rename(F);
         NewFn = Intrinsic::getDeclaration(F->getParent(), ID, ObjectPtr);
         return true;
       }
     }
 
     bool IsLifetimeEnd = Name.startswith("lifetime.end");
     if (IsLifetimeEnd || Name.startswith("invariant.end")) {
       Intrinsic::ID ID = IsLifetimeEnd ?
         Intrinsic::lifetime_end : Intrinsic::invariant_end;
 
       auto Args = F->getFunctionType()->params();
       Type* ObjectPtr[1] = {Args[IsLifetimeEnd ? 1 : 2]};
-      if (F->getName() != Intrinsic::getName(ID, ObjectPtr)) {
+      if (F->getName() != Intrinsic::getName(ID, ObjectPtr, F->getParent())) {
         rename(F);
         NewFn = Intrinsic::getDeclaration(F->getParent(), ID, ObjectPtr);
         return true;
       }
     }
     if (Name.startswith("invariant.group.barrier")) {
       // Rename invariant.group.barrier to launder.invariant.group
       auto Args = F->getFunctionType()->params();
       Type* ObjectPtr[1] = {Args[0]};
       rename(F);
       NewFn = Intrinsic::getDeclaration(F->getParent(),
           Intrinsic::launder_invariant_group, ObjectPtr);
       return true;
 
     }
 
     break;
   }
   case 'm': {
     if (Name.startswith("masked.load.")) {
       Type *Tys[] = { F->getReturnType(), F->arg_begin()->getType() };
-      if (F->getName() != Intrinsic::getName(Intrinsic::masked_load, Tys)) {
+      if (F->getName() !=
+          Intrinsic::getName(Intrinsic::masked_load, Tys, F->getParent())) {
         rename(F);
         NewFn = Intrinsic::getDeclaration(F->getParent(),
                                           Intrinsic::masked_load,
                                           Tys);
         return true;
       }
     }
     if (Name.startswith("masked.store.")) {
       auto Args = F->getFunctionType()->params();
       Type *Tys[] = { Args[0], Args[1] };
-      if (F->getName() != Intrinsic::getName(Intrinsic::masked_store, Tys)) {
+      if (F->getName() !=
+          Intrinsic::getName(Intrinsic::masked_store, Tys, F->getParent())) {
         rename(F);
         NewFn = Intrinsic::getDeclaration(F->getParent(),
                                           Intrinsic::masked_store,
                                           Tys);
         return true;
       }
     }
     // Renaming gather/scatter intrinsics with no address space overloading
     // to the new overload which includes an address space
     if (Name.startswith("masked.gather.")) {
       Type *Tys[] = {F->getReturnType(), F->arg_begin()->getType()};
-      if (F->getName() != Intrinsic::getName(Intrinsic::masked_gather, Tys)) {
+      if (F->getName() !=
+          Intrinsic::getName(Intrinsic::masked_gather, Tys, F->getParent())) {
         rename(F);
         NewFn = Intrinsic::getDeclaration(F->getParent(),
                                           Intrinsic::masked_gather, Tys);
         return true;
       }
     }
     if (Name.startswith("masked.scatter.")) {
       auto Args = F->getFunctionType()->params();
       Type *Tys[] = {Args[0], Args[1]};
-      if (F->getName() != Intrinsic::getName(Intrinsic::masked_scatter, Tys)) {
+      if (F->getName() !=
+          Intrinsic::getName(Intrinsic::masked_scatter, Tys, F->getParent())) {
         rename(F);
         NewFn = Intrinsic::getDeclaration(F->getParent(),
                                           Intrinsic::masked_scatter, Tys);
         return true;
       }
     }
     // Updating the memory intrinsics (memcpy/memmove/memset) that have an
     // alignment parameter to embedding the alignment as an attribute of
case 'n': {
     break;
   }
   case 'o':
     // We only need to change the name to match the mangling including the
     // address space.
     if (Name.startswith("objectsize.")) {
       Type *Tys[2] = { F->getReturnType(), F->arg_begin()->getType() };
       if (F->arg_size() == 2 || F->arg_size() == 3 ||
-          F->getName() != Intrinsic::getName(Intrinsic::objectsize, Tys)) {
+          F->getName() !=
+              Intrinsic::getName(Intrinsic::objectsize, Tys, F->getParent())) {
         rename(F);
         NewFn = Intrinsic::getDeclaration(F->getParent(), Intrinsic::objectsize,
                                           Tys);
         return true;
       }
     }
     break;
 
   case 'p':
     if (Name == "prefetch") {
       // Handle address space overloading.
       Type *Tys[] = {F->arg_begin()->getType()};
-      if (F->getName() != Intrinsic::getName(Intrinsic::prefetch, Tys)) {
+      if (F->getName() !=
+          Intrinsic::getName(Intrinsic::prefetch, Tys, F->getParent())) {
         rename(F);
         NewFn =
             Intrinsic::getDeclaration(F->getParent(), Intrinsic::prefetch, Tys);
         return true;
       }
     } else if (Name.startswith("ptr.annotation.") && F->arg_size() == 4) {
       rename(F);
       NewFn = Intrinsic::getDeclaration(F->getParent(),

llvm/lib/IR/Core.cpp

 }
 
 const char *LLVMIntrinsicCopyOverloadedName(unsigned ID,
                                             LLVMTypeRef *ParamTypes,
                                             size_t ParamCount,
                                             size_t *NameLength) {
   auto IID = llvm_map_to_intrinsic_id(ID);
   ArrayRef<Type*> Tys(unwrap(ParamTypes), ParamCount);
-  auto Str = llvm::Intrinsic::getName(IID, Tys);
+  auto Str = llvm::Intrinsic::getNameNoUnnamedTypes(IID, Tys);
+  *NameLength = Str.length();
+  return strdup(Str.c_str());
+}
+
+const char *LLVMIntrinsicCopyOverloadedName2(LLVMModuleRef Mod, unsigned ID,
+                                             LLVMTypeRef *ParamTypes,
+                                             size_t ParamCount,
+                                             size_t *NameLength) {
+  auto IID = llvm_map_to_intrinsic_id(ID);
+  ArrayRef<Type *> Tys(unwrap(ParamTypes), ParamCount);
+  auto Str = llvm::Intrinsic::getName(IID, Tys, unwrap(Mod));
   *NameLength = Str.length();
   return strdup(Str.c_str());
 }
 
 unsigned LLVMLookupIntrinsicID(const char *Name, size_t NameLen) {
   return Function::lookupIntrinsicID({Name, NameLen});
 }
 

llvm/lib/IR/Function.cpp

if (PointerType* PTyp = dyn_cast<PointerType>(Ty)) {
     case Type::IntegerTyID:
       Result += "i" + utostr(cast<IntegerType>(Ty)->getBitWidth());
       break;
     }
   }
   return Result;
 }
 
+StringRef Intrinsic::getBaseName(ID id) {
+  assert(id < num_intrinsics && "Invalid intrinsic ID!");
+  return IntrinsicNameTable[id];
+}
+
 StringRef Intrinsic::getName(ID id) {
   assert(id < num_intrinsics && "Invalid intrinsic ID!");
   assert(!Intrinsic::isOverloaded(id) &&
          "This version of getName does not support overloading");
-  return IntrinsicNameTable[id];
+  return getBaseName(id);
 }
 
-std::string Intrinsic::getName(ID Id, ArrayRef<Type *> Tys, Module *M,
-                               FunctionType *FT) {
-  assert(Id < num_intrinsics && "Invalid intrinsic ID!");
+static std::string getIntrinsicNameImpl(Intrinsic::ID Id, ArrayRef<Type *> Tys,
+                                        Module *M, FunctionType *FT,
+                                        bool EarlyModuleCheck) {
+
+  assert(Id < Intrinsic::num_intrinsics && "Invalid intrinsic ID!");
   assert((Tys.empty() || Intrinsic::isOverloaded(Id)) &&
          "This version of getName is for overloaded intrinsics only");
+  (void)EarlyModuleCheck;
+  assert((!EarlyModuleCheck || M ||
+          !any_of(Tys, [](Type *T) { return isa<PointerType>(T); })) &&
+         "Intrinsic overloading on pointer types need to provide a Module");
   bool HasUnnamedType = false;
-  std::string Result(IntrinsicNameTable[Id]);
-  for (Type *Ty : Tys) {
+  std::string Result(Intrinsic::getBaseName(Id));
+  for (Type *Ty : Tys)
     Result += "." + getMangledTypeStr(Ty, HasUnnamedType);
-  }
-  assert((M || !HasUnnamedType) && "unnamed types need a module");
-  if (M && HasUnnamedType) {
+  if (HasUnnamedType) {
+    assert(M && "unnamed types need a module");
     if (!FT)
-      FT = getType(M->getContext(), Id, Tys);
+      FT = Intrinsic::getType(M->getContext(), Id, Tys);
     else
-      assert((FT == getType(M->getContext(), Id, Tys)) &&
+      assert((FT == Intrinsic::getType(M->getContext(), Id, Tys)) &&
              "Provided FunctionType must match arguments");
     return M->getUniqueIntrinsicName(Result, Id, FT);
   }
   return Result;
 }
 
-std::string Intrinsic::getName(ID Id, ArrayRef<Type *> Tys) {
-  return getName(Id, Tys, nullptr, nullptr);
+std::string Intrinsic::getName(ID Id, ArrayRef<Type *> Tys, Module *M,
+                               FunctionType *FT) {
+  assert(M && "We need to have a Module");
+  return getIntrinsicNameImpl(Id, Tys, M, FT, true);
+}
+
+std::string Intrinsic::getNameNoUnnamedTypes(ID Id, ArrayRef<Type *> Tys) {
+  return getIntrinsicNameImpl(Id, Tys, nullptr, nullptr, false);
 }
 
 /// IIT_Info - These are enumerators that describe the entries returned by the
 /// getIntrinsicInfoTableEntries function.
 ///
 /// NOTE: This must be kept in synch with the copy in TblGen/IntrinsicEmitter!
 enum IIT_Info {
   // Common values should be encoded with 0-15.

llvm/lib/Transforms/Scalar/LowerMatrixIntrinsics.cpp

void writeFnName(CallInst *CI) {
         write("<no called fn>");
       else {
         StringRef Name = CI->getCalledFunction()->getName();
         if (!Name.startswith("llvm.matrix")) {
           write(Name);
           return;
         }
         IntrinsicInst *II = dyn_cast<IntrinsicInst>(CI);
-        write(StringRef(Intrinsic::getName(II->getIntrinsicID(), {}))
+        write(Intrinsic::getBaseName(II->getIntrinsicID())
                   .drop_front(StringRef("llvm.matrix.").size()));
         write(".");
         std::string Tmp;
         raw_string_ostream SS(Tmp);
 
         switch (II->getIntrinsicID()) {
         case Intrinsic::matrix_multiply:
           prettyPrintMatrixType(II->getOperand(0), SS);

llvm/test/Assembler/auto_upgrade_intrinsics.ll

 ; Test to make sure intrinsics are automatically upgraded.
 ; RUN: llvm-as < %s | llvm-dis | FileCheck %s
 ; RUN: verify-uselistorder %s
 
+%0 = type opaque;
+
 declare i8 @llvm.ctlz.i8(i8)
 declare i16 @llvm.ctlz.i16(i16)
 declare i32 @llvm.ctlz.i32(i32)
 declare i42 @llvm.ctlz.i42(i42)  ; Not a power-of-2
 
 
-declare i32 @llvm.objectsize.i32(i8*, i1) nounwind readonly
-
-
 define void @test.ctlz(i8 %a, i16 %b, i32 %c, i42 %d) {
 ; CHECK: @test.ctlz
 
 entry:
   ; CHECK: call i8 @llvm.ctlz.i8(i8 %a, i1 false)
   call i8 @llvm.ctlz.i8(i8 %a)
   ; CHECK: call i16 @llvm.ctlz.i16(i16 %b, i1 false)
   call i16 @llvm.ctlz.i16(i16 %b)
entry:
   call i42 @llvm.cttz.i42(i42 %d)
 
   ret void
 }
 
 
 @a = private global [60 x i8] zeroinitializer, align 1
 
+declare i32 @llvm.objectsize.i32(i8*, i1) nounwind readonly
 define i32 @test.objectsize() {
 ; CHECK-LABEL: @test.objectsize(
 ; CHECK: @llvm.objectsize.i32.p0i8(i8* getelementptr inbounds ([60 x i8], [60 x i8]* @a, i32 0, i32 0), i1 false, i1 false, i1 false)
   %s = call i32 @llvm.objectsize.i32(i8* getelementptr inbounds ([60 x i8], [60 x i8]* @a, i32 0, i32 0), i1 false)
   ret i32 %s
 }
 
 declare i64 @llvm.objectsize.i64.p0i8(i8*, i1) nounwind readonly
 define i64 @test.objectsize.2() {
 ; CHECK-LABEL: @test.objectsize.2(
 ; CHECK: @llvm.objectsize.i64.p0i8(i8* getelementptr inbounds ([60 x i8], [60 x i8]* @a, i32 0, i32 0), i1 false, i1 false, i1 false)
   %s = call i64 @llvm.objectsize.i64.p0i8(i8* getelementptr inbounds ([60 x i8], [60 x i8]* @a, i32 0, i32 0), i1 false)
   ret i64 %s
 }
 
+@u = private global [60 x %0*] zeroinitializer, align 1
+
+declare i32 @llvm.objectsize.i32.unnamed(%0**, i1) nounwind readonly
+define i32 @test.objectsize.unnamed() {
+; CHECK-LABEL: @test.objectsize.unnamed(
+; CHECK: @llvm.objectsize.i32.p0p0s_s.0(%0** getelementptr inbounds ([60 x %0*], [60 x %0*]* @u, i32 0, i32 0), i1 false, i1 false, i1 false)
+  %s = call i32 @llvm.objectsize.i32.unnamed(%0** getelementptr inbounds ([60 x %0*], [60 x %0*]* @u, i32 0, i32 0), i1 false)
+  ret i32 %s
+}
+
+declare i64 @llvm.objectsize.i64.p0p0s_s.0(%0**, i1) nounwind readonly
+define i64 @test.objectsize.unnamed.2() {
+; CHECK-LABEL: @test.objectsize.unnamed.2(
+; CHECK: @llvm.objectsize.i64.p0p0s_s.0(%0** getelementptr inbounds ([60 x %0*], [60 x %0*]* @u, i32 0, i32 0), i1 false, i1 false, i1 false)
+  %s = call i64 @llvm.objectsize.i64.p0p0s_s.0(%0** getelementptr inbounds ([60 x %0*], [60 x %0*]* @u, i32 0, i32 0), i1 false)
+  ret i64 %s
+}
+
 declare <2 x double> @llvm.masked.load.v2f64(<2 x double>* %ptrs, i32, <2 x i1> %mask, <2 x double> %src0)
 
 define <2 x double> @tests.masked.load(<2 x double>* %ptr, <2 x i1> %mask, <2 x double> %passthru)  {
 ; CHECK-LABEL: @tests.masked.load(
 ; CHECK: @llvm.masked.load.v2f64.p0v2f64
   %res = call <2 x double> @llvm.masked.load.v2f64(<2 x double>* %ptr, i32 1, <2 x i1> %mask, <2 x double> %passthru)
   ret <2 x double> %res
 }
define void @tests.invariant.start.end() {
   %i = call {}* @llvm.invariant.start(i64 1, i8* %a)
   ; CHECK: call {}* @llvm.invariant.start.p0i8
   store i8 0, i8* %a
   call void @llvm.invariant.end({}* %i, i64 1, i8* %a)
   ; CHECK: call void @llvm.invariant.end.p0i8
   ret void
 }
 
+declare {}* @llvm.invariant.start.unnamed(i64, %0** nocapture) nounwind readonly
+declare void @llvm.invariant.end.unnamed({}*, i64, %0** nocapture) nounwind
+
+define void @tests.invariant.start.end.unnamed() {
+  ; CHECK-LABEL: @tests.invariant.start.end.unnamed(
+  %a = alloca %0*
+  %i = call {}* @llvm.invariant.start.unnamed(i64 1, %0** %a)
+  ; CHECK: call {}* @llvm.invariant.start.p0p0s_s.0
+  store %0* null, %0** %a
+  call void @llvm.invariant.end.unnamed({}* %i, i64 1, %0** %a)
+  ; CHECK: call void @llvm.invariant.end.p0p0s_s.0
+  ret void
+}
+
 @__stack_chk_guard = external global i8*
 declare void @llvm.stackprotectorcheck(i8**)
 
 define void @test.stackprotectorcheck() {
 ; CHECK-LABEL: @test.stackprotectorcheck(
 ; CHECK-NEXT: ret void
   call void @llvm.stackprotectorcheck(i8** @__stack_chk_guard)
   ret void
 }
 
 declare void  @llvm.lifetime.start(i64, i8* nocapture) nounwind readonly
 declare void @llvm.lifetime.end(i64, i8* nocapture) nounwind
 
 define void @tests.lifetime.start.end() {
   ; CHECK-LABEL: @tests.lifetime.start.end(
   %a = alloca i8
   call void @llvm.lifetime.start(i64 1, i8* %a)
   ; CHECK: call void @llvm.lifetime.start.p0i8(i64 1, i8* %a)
   store i8 0, i8* %a
   call void @llvm.lifetime.end(i64 1, i8* %a)
   ; CHECK: call void @llvm.lifetime.end.p0i8(i64 1, i8* %a)
   ret void
 }
 
+declare void  @llvm.lifetime.start.unnamed(i64, %0** nocapture) nounwind readonly
+declare void @llvm.lifetime.end.unnamed(i64, %0** nocapture) nounwind
+
+define void @tests.lifetime.start.end.unnamed() {
+  ; CHECK-LABEL: @tests.lifetime.start.end.unnamed(
+  %a = alloca %0*
+  call void @llvm.lifetime.start.unnamed(i64 1, %0** %a)
+  ; CHECK: call void @llvm.lifetime.start.p0p0s_s.0(i64 1, %0** %a)
+  store %0* null, %0** %a
+  call void @llvm.lifetime.end.unnamed(i64 1, %0** %a)
+  ; CHECK: call void @llvm.lifetime.end.p0p0s_s.0(i64 1, %0** %a)
+  ret void
+}
+
 declare void @llvm.prefetch(i8*, i32, i32, i32)
 define void @test.prefetch(i8* %ptr) {
 ; CHECK-LABEL: @test.prefetch(
 ; CHECK: @llvm.prefetch.p0i8(i8* %ptr, i32 0, i32 3, i32 2)
   call void @llvm.prefetch(i8* %ptr, i32 0, i32 3, i32 2)
   ret void
 }
 
 declare void @llvm.prefetch.p0i8(i8*, i32, i32, i32)
 define void @test.prefetch.2(i8* %ptr) {
 ; CHECK-LABEL: @test.prefetch.2(
 ; CHECK: @llvm.prefetch.p0i8(i8* %ptr, i32 0, i32 3, i32 2)
   call void @llvm.prefetch(i8* %ptr, i32 0, i32 3, i32 2)
   ret void
 }
 
+declare void @llvm.prefetch.unnamed(%0**, i32, i32, i32)
+define void @test.prefetch.unnamed(%0** %ptr) {
+; CHECK-LABEL: @test.prefetch.unnamed(
+; CHECK: @llvm.prefetch.p0p0s_s.0(%0** %ptr, i32 0, i32 3, i32 2)
+  call void @llvm.prefetch.unnamed(%0** %ptr, i32 0, i32 3, i32 2)
+  ret void
+}
+
 ; This is part of @test.objectsize(), since llvm.objectsize declaration gets
 ; emitted at the end.
 ; CHECK: declare i32 @llvm.objectsize.i32.p0i8
-
+; CHECK: declare i32 @llvm.objectsize.i32.p0p0s_s.0
 
 ; CHECK: declare void @llvm.lifetime.start.p0i8(i64 immarg, i8* nocapture)
 ; CHECK: declare void @llvm.lifetime.end.p0i8(i64 immarg, i8* nocapture)
+; CHECK: declare void @llvm.lifetime.start.p0p0s_s.0(i64 immarg, %0** nocapture)
+; CHECK: declare void @llvm.lifetime.end.p0p0s_s.0(i64 immarg, %0** nocapture)