[NFC] Simplify some conversions from ArrayRef to SmallVector by using to_vector and to_vector_of utilities

[yurai007]

Summary

Extracted from/depends on: https://reviews.llvm.org/D129781

[yurai007]

Extracted based on comment: https://reviews.llvm.org/D129781#3685752

[dblaikie]

llvm/lib/Analysis/TypeBasedAliasAnalysis.cpp

814

I'm not sure changes like this add value - if we end up with a ctor that can take MD->operands() as a single argument. Is that possible already/will it be possible with some of the patches you're working on?

llvm/unittests/Analysis/VectorUtilsTest.cpp

510

if there is/we end up with a ctor that takes a range, maybe there should also be an assign function that does the same, that would be used here? Shape.Parameters.assign(Parameters)

[yurai007]

llvm/lib/Analysis/TypeBasedAliasAnalysis.cpp

814

Taking into account parallel change which adds SmallVector(ArrayRef<U>) the answer is yes - NextNodes (SmallVector) can be created directly from MD->operands(). So yeah we can skip using to_vector_of here.

[yurai007]

llvm/unittests/Analysis/VectorUtilsTest.cpp

510

I can think of extending SmallVector with range version of assign, but haven't checked yet how much value it would add excluding this particular usage. If you don't mind I would like to postpone it until rest of SmallVector related patches are submitted.

[dblaikie]

llvm/lib/Analysis/TypeBasedAliasAnalysis.cpp

814

Could you remove this/changes like this from the patch then, or do you plan to wait on changes for this patch until the ArrayRef ctor is added? (you can flag this review as "changes planned" or something)

llvm/unittests/Analysis/VectorUtilsTest.cpp

510

Fair enough - it is a bit unfortunate that this still causes copies & has to re-encode the small size (8 in this instance) but yeah, this is still simpler/tidier than the previous code.

[yurai007]

llvm/lib/Analysis/TypeBasedAliasAnalysis.cpp

814

do you plan to wait on changes for this patch until the ArrayRef ctor is added? (you can flag this review as "changes planned" or something)

Yes, that's my plan, I'm gonna submit https://reviews.llvm.org/D130268 first, and then rebase this change. So flagging this one as "changes planned" sounds good.

llvm/include/llvm/IR/Metadata.h

class MDTuple : public MDNode {
 
   void setHash(unsigned Hash) { SubclassData32 = Hash; }
   void recalculateHash();
 
   static MDTuple *getImpl(LLVMContext &Context, ArrayRef<Metadata *> MDs,
                           StorageType Storage, bool ShouldCreate = true);
 
   TempMDTuple cloneImpl() const {
-    ArrayRef<MDOperand> Operands = operands();
-    return getTemporary(getContext(), SmallVector<Metadata *, 4>(
-                                          Operands.begin(), Operands.end()));
+    return getTemporary(getContext(),
+                        llvm::to_vector_of<Metadata *, 4>(operands()));
   }
 
 public:
   /// Get the hash, if any.
   unsigned getHash() const { return SubclassData32; }
 
   static MDTuple *get(LLVMContext &Context, ArrayRef<Metadata *> MDs) {
     return getImpl(Context, MDs, Uniqued);

llvm/lib/Analysis/TypeBasedAliasAnalysis.cpp

MDNode *AAMDNodes::extendToTBAA(MDNode *MD, ssize_t Len) {
   if (!Tag.isNewFormat())
     return MD;
 
   // If unknown size, drop the TBAA.
   if (Len == -1)
     return nullptr;
 
   // Otherwise, create TBAA with the new Len
-  ArrayRef<MDOperand> MDOperands = MD->operands();
-  SmallVector<Metadata *, 4> NextNodes(MDOperands.begin(), MDOperands.end());
+  auto NextNodes = to_vector_of<Metadata *, 4>(MD->operands());
   ConstantInt *PreviousSize = mdconst::extract<ConstantInt>(NextNodes[3]);
 
   // Don't create a new MDNode if it is the same length.
   if (PreviousSize->equalsInt(Len))
     return MD;
 
   NextNodes[3] =
       ConstantAsMetadata::get(ConstantInt::get(PreviousSize->getType(), Len));
   return MDNode::get(MD->getContext(), NextNodes);
 }

llvm/lib/Linker/IRMover.cpp

if (SrcBehaviorValue != DstBehaviorValue) {
                          DstM.getModuleIdentifier() + "'");
     }
 
     auto ensureDistinctOp = [&](MDNode *DstValue) {
       assert(isa<MDTuple>(DstValue) &&
              "Expected MDTuple when appending module flags");
       if (DstValue->isDistinct())
         return dyn_cast<MDTuple>(DstValue);
-      ArrayRef<MDOperand> DstOperands = DstValue->operands();
       MDTuple *New = MDTuple::getDistinct(
           DstM.getContext(),
-          SmallVector<Metadata *, 4>(DstOperands.begin(), DstOperands.end()));
+          llvm::to_vector_of<Metadata *, 4>(DstValue->operands()));
       Metadata *FlagOps[] = {DstOp->getOperand(0), ID, New};
       MDNode *Flag = MDTuple::getDistinct(DstM.getContext(), FlagOps);
       DstModFlags->setOperand(DstIndex, Flag);
       Flags[ID].first = Flag;
       return New;
     };
 
     // Emit a warning if the values differ and either source or destination

llvm/tools/llvm-rc/ResourceScriptStmt.h

public:
 
     static VersionInfoFixedType getFixedType(StringRef Type);
     static bool isTypeSupported(VersionInfoFixedType Type);
     static bool isVersionType(VersionInfoFixedType Type);
 
     VersionInfoFixed() : IsTypePresent(FtNumTypes, false) {}
 
     void setValue(VersionInfoFixedType Type, ArrayRef<uint32_t> Value) {
-      FixedInfo[Type] = SmallVector<uint32_t, 4>(Value.begin(), Value.end());
+      FixedInfo[Type] = llvm::to_vector<4>(Value);
       IsTypePresent[Type] = true;
     }
 
     raw_ostream &log(raw_ostream &) const;
   };
 
   VersionInfoBlock MainBlock;
   VersionInfoFixed FixedData;

llvm/tools/llvm-symbolizer/llvm-symbolizer.cpp

 }
 
 static SmallVector<uint8_t> parseBuildID(StringRef Str) {
   std::string Bytes;
   if (!tryGetFromHex(Str, Bytes))
     return {};
   ArrayRef<uint8_t> BuildID(reinterpret_cast<const uint8_t *>(Bytes.data()),
                             Bytes.size());
-  return SmallVector<uint8_t>(BuildID.begin(), BuildID.end());
+  return llvm::to_vector(BuildID);
 }
 
 static bool parseCommand(StringRef BinaryName, bool IsAddr2Line,
                          StringRef InputString, Command &Cmd,
                          std::string &ModuleName,
                          SmallVectorImpl<uint8_t> &BuildID,
                          uint64_t &ModuleOffset) {
   const char kDelimiters[] = " \n\r";

llvm/unittests/Analysis/VectorUtilsTest.cpp

protected:
   VFShape Expected;
   SmallVector<VFParameter, 8> &ExpectedParams = Expected.Parameters;
 
   void buildShape(ElementCount VF, bool HasGlobalPred) {
     Shape = VFShape::get(*CI, VF, HasGlobalPred);
   }
 
   bool validParams(ArrayRef<VFParameter> Parameters) {
-    Shape.Parameters =
-        SmallVector<VFParameter, 8>(Parameters.begin(), Parameters.end());
+    Shape.Parameters = llvm::to_vector<8>(Parameters);
     return Shape.hasValidParameterList();
   }
 };
 
 TEST_F(VFShapeAPITest, API_buildVFShape) {
   buildShape(/*VF*/ ElementCount::getFixed(2), /*HasGlobalPred*/ false);
   Expected = {/*VF*/ ElementCount::getFixed(2), /*Parameters*/ {
                   {0, VFParamKind::Vector},