Avoid unnecessary uses of `MDNode::getTemporary`, NFC

[dexonsmith]

Summary

TempMDNode includes a bunch of machinery for RAUW, and should only be
used when necessary. RAUW wasn't being used in any of these cases... it
was just a placeholder for a self-reference.

Where the real node was using MDNode::getDistinct, just replace the
temporary argument with nullptr.

Where the real node was using MDNode::get, the replaceOperandWith
call was "promoting" the node to a distinct one implicitly due to
self-reference detection in MDNode::handleChangedOperand. The
TempMDNode was serving a purpose by delaying uniquing, but it's way
simpler to just call MDNode::getDistinct in the first place.

Note that using a self-reference at all in these places is a hold-over
from before distinct metadata existed. It was an old trick to create
distinct nodes. It would be intrusive to change, including bitcode
upgrades, etc., and it's harmless so I'm not sure there's much value in
removing it from existing schemas. After this commit it still has a tiny
memory cost (in the extra metadata operand) but no more overhead in
construction.

[dexonsmith]

https://github.com/llvm/llvm-project/blob/master/llvm/lib/IR/Metadata.cpp#L716 is where the auto-detection of self-references is:

// Drop uniquing for self-reference cycles and deleted constants.
if (New == this || (!New && Old && isa<ConstantAsMetadata>(Old))) {
  if (!isResolved())
    resolve();
  storeDistinctInContext();
  return;
}

[dexonsmith]

BTW, this is a long-delayed follow-up to 5e5b85098dbeaea2cfa5d01695b5d2982634d7dd.

[aprantl]

The push_back(nullptr) reads weird to me, but it is an accurate reflection of what the IR will look like.

clang/lib/CodeGen/CGLoopInfo.cpp

 #include "llvm/IR/Metadata.h"
 using namespace clang::CodeGen;
 using namespace llvm;
 
 MDNode *
 LoopInfo::createLoopPropertiesMetadata(ArrayRef<Metadata *> LoopProperties) {
   LLVMContext &Ctx = Header->getContext();
   SmallVector<Metadata *, 4> NewLoopProperties;
-  TempMDTuple TempNode = MDNode::getTemporary(Ctx, None);
-  NewLoopProperties.push_back(TempNode.get());
+  NewLoopProperties.push_back(nullptr);
   NewLoopProperties.append(LoopProperties.begin(), LoopProperties.end());
 
   MDNode *LoopID = MDNode::getDistinct(Ctx, NewLoopProperties);
   LoopID->replaceOperandWith(0, LoopID);
   return LoopID;
 }
 
 MDNode *LoopInfo::createPipeliningMetadata(const LoopAttributes &Attrs,
if (Enabled == false) {
                             ConstantAsMetadata::get(ConstantInt::get(
                                 llvm::Type::getInt1Ty(Ctx), 1))}));
       LoopProperties = NewLoopProperties;
     }
     return createLoopPropertiesMetadata(LoopProperties);
   }
 
   SmallVector<Metadata *, 4> Args;
-  TempMDTuple TempNode = MDNode::getTemporary(Ctx, None);
-  Args.push_back(TempNode.get());
+  Args.push_back(nullptr);
   Args.append(LoopProperties.begin(), LoopProperties.end());
 
   if (Attrs.PipelineInitiationInterval > 0) {
     Metadata *Vals[] = {
         MDString::get(Ctx, "llvm.loop.pipeline.initiationinterval"),
         ConstantAsMetadata::get(ConstantInt::get(
             llvm::Type::getInt32Ty(Ctx), Attrs.PipelineInitiationInterval))};
     Args.push_back(MDNode::get(Ctx, Vals));
LoopInfo::createPartialUnrollMetadata(const LoopAttributes &Attrs,
   FollowupLoopProperties.push_back(
       MDNode::get(Ctx, MDString::get(Ctx, "llvm.loop.unroll.disable")));
 
   bool FollowupHasTransforms = false;
   MDNode *Followup = createPipeliningMetadata(Attrs, FollowupLoopProperties,
                                               FollowupHasTransforms);
 
   SmallVector<Metadata *, 4> Args;
-  TempMDTuple TempNode = MDNode::getTemporary(Ctx, None);
-  Args.push_back(TempNode.get());
+  Args.push_back(nullptr);
   Args.append(LoopProperties.begin(), LoopProperties.end());
 
   // Setting unroll.count
   if (Attrs.UnrollCount > 0) {
     Metadata *Vals[] = {MDString::get(Ctx, "llvm.loop.unroll.count"),
                         ConstantAsMetadata::get(ConstantInt::get(
                             llvm::Type::getInt32Ty(Ctx), Attrs.UnrollCount))};
     Args.push_back(MDNode::get(Ctx, Vals));
LoopInfo::createUnrollAndJamMetadata(const LoopAttributes &Attrs,
   FollowupLoopProperties.push_back(
       MDNode::get(Ctx, MDString::get(Ctx, "llvm.loop.unroll_and_jam.disable")));
 
   bool FollowupHasTransforms = false;
   MDNode *Followup = createPartialUnrollMetadata(Attrs, FollowupLoopProperties,
                                                  FollowupHasTransforms);
 
   SmallVector<Metadata *, 4> Args;
-  TempMDTuple TempNode = MDNode::getTemporary(Ctx, None);
-  Args.push_back(TempNode.get());
+  Args.push_back(nullptr);
   Args.append(LoopProperties.begin(), LoopProperties.end());
 
   // Setting unroll_and_jam.count
   if (Attrs.UnrollAndJamCount > 0) {
     Metadata *Vals[] = {
         MDString::get(Ctx, "llvm.loop.unroll_and_jam.count"),
         ConstantAsMetadata::get(ConstantInt::get(llvm::Type::getInt32Ty(Ctx),
                                                  Attrs.UnrollAndJamCount))};
LoopInfo::createLoopVectorizeMetadata(const LoopAttributes &Attrs,
   FollowupLoopProperties.push_back(
       MDNode::get(Ctx, MDString::get(Ctx, "llvm.loop.isvectorized")));
 
   bool FollowupHasTransforms = false;
   MDNode *Followup = createUnrollAndJamMetadata(Attrs, FollowupLoopProperties,
                                                 FollowupHasTransforms);
 
   SmallVector<Metadata *, 4> Args;
-  TempMDTuple TempNode = MDNode::getTemporary(Ctx, None);
-  Args.push_back(TempNode.get());
+  Args.push_back(nullptr);
   Args.append(LoopProperties.begin(), LoopProperties.end());
 
   // Setting vectorize.predicate
   bool IsVectorPredicateEnabled = false;
   if (Attrs.VectorizePredicateEnable != LoopAttributes::Unspecified &&
       Attrs.VectorizeEnable != LoopAttributes::Disable &&
       Attrs.VectorizeWidth < 1) {
 
Args.push_back(
                               llvm::Type::getInt1Ty(Ctx), AttrVal))}));
   }
 
   if (FollowupHasTransforms)
     Args.push_back(MDNode::get(
         Ctx,
         {MDString::get(Ctx, "llvm.loop.vectorize.followup_all"), Followup}));
 
-  MDNode *LoopID = MDNode::get(Ctx, Args);
+  MDNode *LoopID = MDNode::getDistinct(Ctx, Args);
   LoopID->replaceOperandWith(0, LoopID);
   HasUserTransforms = true;
   return LoopID;
 }
 
 MDNode *
 LoopInfo::createLoopDistributeMetadata(const LoopAttributes &Attrs,
                                        ArrayRef<Metadata *> LoopProperties,
return createLoopVectorizeMetadata(Attrs, LoopProperties,
                                        HasUserTransforms);
   }
 
   bool FollowupHasTransforms = false;
   MDNode *Followup =
       createLoopVectorizeMetadata(Attrs, LoopProperties, FollowupHasTransforms);
 
   SmallVector<Metadata *, 4> Args;
-  TempMDTuple TempNode = MDNode::getTemporary(Ctx, None);
-  Args.push_back(TempNode.get());
+  Args.push_back(nullptr);
   Args.append(LoopProperties.begin(), LoopProperties.end());
 
   Metadata *Vals[] = {MDString::get(Ctx, "llvm.loop.distribute.enable"),
                       ConstantAsMetadata::get(ConstantInt::get(
                           llvm::Type::getInt1Ty(Ctx),
                           (Attrs.DistributeEnable == LoopAttributes::Enable)))};
   Args.push_back(MDNode::get(Ctx, Vals));
 
   if (FollowupHasTransforms)
     Args.push_back(MDNode::get(
         Ctx,
         {MDString::get(Ctx, "llvm.loop.distribute.followup_all"), Followup}));
 
-  MDNode *LoopID = MDNode::get(Ctx, Args);
+  MDNode *LoopID = MDNode::getDistinct(Ctx, Args);
   LoopID->replaceOperandWith(0, LoopID);
   HasUserTransforms = true;
   return LoopID;
 }
 
 MDNode *LoopInfo::createFullUnrollMetadata(const LoopAttributes &Attrs,
                                            ArrayRef<Metadata *> LoopProperties,
                                            bool &HasUserTransforms) {
if (Enabled == false) {
           MDNode::get(Ctx, MDString::get(Ctx, "llvm.loop.unroll.disable")));
       LoopProperties = NewLoopProperties;
     }
     return createLoopDistributeMetadata(Attrs, LoopProperties,
                                         HasUserTransforms);
   }
 
   SmallVector<Metadata *, 4> Args;
-  TempMDTuple TempNode = MDNode::getTemporary(Ctx, None);
-  Args.push_back(TempNode.get());
+  Args.push_back(nullptr);
   Args.append(LoopProperties.begin(), LoopProperties.end());
   Args.push_back(MDNode::get(Ctx, MDString::get(Ctx, "llvm.loop.unroll.full")));
 
   // No follow-up: there is no loop after full unrolling.
   // TODO: Warn if there are transformations after full unrolling.
 
   MDNode *LoopID = MDNode::getDistinct(Ctx, Args);
   LoopID->replaceOperandWith(0, LoopID);

llvm/lib/Analysis/LoopInfo.cpp

 MDNode *llvm::makePostTransformationMetadata(LLVMContext &Context,
                                              MDNode *OrigLoopID,
                                              ArrayRef<StringRef> RemovePrefixes,
                                              ArrayRef<MDNode *> AddAttrs) {
   // First remove any existing loop metadata related to this transformation.
   SmallVector<Metadata *, 4> MDs;
 
   // Reserve first location for self reference to the LoopID metadata node.
-  TempMDTuple TempNode = MDNode::getTemporary(Context, None);
-  MDs.push_back(TempNode.get());
+  MDs.push_back(nullptr);
 
   // Remove metadata for the transformation that has been applied or that became
   // outdated.
   if (OrigLoopID) {
     for (unsigned i = 1, ie = OrigLoopID->getNumOperands(); i < ie; ++i) {
       bool IsVectorMetadata = false;
       Metadata *Op = OrigLoopID->getOperand(i);
       if (MDNode *MD = dyn_cast<MDNode>(Op)) {

llvm/lib/IR/MDBuilder.cpp

assert(NewCBCalleeIdx != OldCBCalleeIdx &&
            "Cannot map a callback callee index twice!");
   }
 
   Ops[NumExistingOps] = NewCB;
   return MDNode::get(Context, Ops);
 }
 
 MDNode *MDBuilder::createAnonymousAARoot(StringRef Name, MDNode *Extra) {
-  // To ensure uniqueness the root node is self-referential.
-  auto Dummy = MDNode::getTemporary(Context, None);
-
-  SmallVector<Metadata *, 3> Args(1, Dummy.get());
+  SmallVector<Metadata *, 3> Args(1, nullptr);
   if (Extra)
     Args.push_back(Extra);
   if (!Name.empty())
     Args.push_back(createString(Name));
-  MDNode *Root = MDNode::get(Context, Args);
+  MDNode *Root = MDNode::getDistinct(Context, Args);
 
   // At this point we have
-  //   !0 = metadata !{}            <- dummy
-  //   !1 = metadata !{metadata !0} <- root
-  // Replace the dummy operand with the root node itself and delete the dummy.
+  //   !0 = distinct !{null} <- root
+  // Replace the reserved operand with the root node itself.
   Root->replaceOperandWith(0, Root);
 
   // We now have
-  //   !1 = metadata !{metadata !1} <- self-referential root
+  //   !0 = distinct !{!0} <- root
   return Root;
 }
 
 MDNode *MDBuilder::createTBAARoot(StringRef Name) {
   return MDNode::get(Context, createString(Name));
 }
 
 /// Return metadata for a non-root TBAA node with the given name,

polly/lib/CodeGen/IRBuilder.cpp

 using namespace polly;
 
 static const int MaxArraysInAliasScops = 10;
 
 /// Get a self referencing id metadata node.
 ///
 /// The MDNode looks like this (if arg0/arg1 are not null):
 ///
-///    '!n = metadata !{metadata !n, arg0, arg1}'
+///    '!n = distinct !{!n, arg0, arg1}'
 ///
 /// @return The self referencing id metadata node.
 static MDNode *getID(LLVMContext &Ctx, Metadata *arg0 = nullptr,
                      Metadata *arg1 = nullptr) {
   MDNode *ID;
   SmallVector<Metadata *, 3> Args;
-  // Use a temporary node to safely create a unique pointer for the first arg.
-  auto TempNode = MDNode::getTemporary(Ctx, None);
   // Reserve operand 0 for loop id self reference.
-  Args.push_back(TempNode.get());
+  Args.push_back(nullptr);
 
   if (arg0)
     Args.push_back(arg0);
   if (arg1)
     Args.push_back(arg1);
 
-  ID = MDNode::get(Ctx, Args);
+  ID = MDNode::getDistinct(Ctx, Args);
   ID->replaceOperandWith(0, ID);
   return ID;
 }
 
 ScopAnnotator::ScopAnnotator() : SE(nullptr), AliasScopeDomain(nullptr) {}
 
 void ScopAnnotator::buildAliasScopes(Scop &S) {
   SE = S.getSE();