[LoopIdiom] Set `elementtype` attribute for generated memory intrinsic if required.

[dantrushin]

Summary

Some garbage collectors require load and/or store barriers when
reading/storing object pointers. The only way to differentiate object
pointer from scalar type of the same size when using memory intrinsics
is elementtype attribute. Set it when we created new memcpy call
in function which has GCStrategy requiring barriers.

llvm/include/llvm/IR/GCStrategy.h

 //===- llvm/CodeGen/GCStrategy.h - Garbage collection -----------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // GCStrategy coordinates code generation algorithms and implements some itself

 
 protected:
   bool UseStatepoints = false; /// Uses gc.statepoints as opposed to gc.roots,
                                /// if set, none of the other options can be
                                /// anything but their default values.
 
   bool NeededSafePoints = false;    ///< if set, calls are inferred to be safepoints
   bool UsesMetadata = false;     ///< If set, backend must emit metadata tables.
+  bool RequiresLoadBarriers = false; ///< If set, GC requires read barriers on object
+                                     ///  pointer loads
+  bool RequiresStoreBarriers = false; ///< If set, GC requires store barriers on object
+                                      ///  pointer stores.
 
 public:
   GCStrategy();
   virtual ~GCStrategy() = default;
 
   /// Return the name of the GC strategy.  This is the value of the collector
   /// name string specified on functions which use this strategy.
   const std::string &getName() const { return Name; }
 
   /// Returns true if this strategy is expecting the use of gc.statepoints,
   /// and false otherwise.
   bool useStatepoints() const { return UseStatepoints; }
 
+  /// Returns true if GC requires load barriers on object pointers.
+  bool requiresLoadBarriers() const { return RequiresLoadBarriers; }
+
+  /// Returns true if GC requires store barriers on object pointers.
+  bool requiresStoreBarriers() const { return RequiresStoreBarriers; }
+
+  /// Returns true if GC requires load and/or store barriers on object pointers.
+  bool requiresBarriers() const {
+    return RequiresLoadBarriers || RequiresStoreBarriers;
+  }
+
   /** @name Statepoint Specific Properties */
   ///@{
 
   /// If the type specified can be reliably distinguished, returns true for
   /// pointers to GC managed locations and false for pointers to non-GC
   /// managed locations.  Note a GCStrategy can always return 'None' (i.e. an
   /// empty optional indicating it can't reliably distinguish.
   virtual Optional<bool> isGCManagedPointer(const Type *Ty) const {

llvm/lib/Transforms/Scalar/LoopIdiomRecognize.cpp

 //===- LoopIdiomRecognize.cpp - Loop idiom recognition --------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This pass implements an idiom recognizer that transforms simple loops into a

 #include "llvm/Analysis/ValueTracking.h"
 #include "llvm/IR/BasicBlock.h"
 #include "llvm/IR/Constant.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/DebugLoc.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/Dominators.h"
+#include "llvm/IR/GCStrategy.h"
 #include "llvm/IR/GlobalValue.h"
 #include "llvm/IR/GlobalVariable.h"
 #include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/InstrTypes.h"
 #include "llvm/IR/Instruction.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/IntrinsicInst.h"
 #include "llvm/IR/Intrinsics.h"
if (!TheStore->isAtomic() && !TheLoad->isAtomic()) {
     // have an alignment but non-atomic loads/stores may not.
     NewCall = Builder.CreateElementUnorderedAtomicMemCpy(
         StoreBasePtr, StoreAlign.getValue(), LoadBasePtr, LoadAlign.getValue(),
         NumBytes, StoreSize, AATags.TBAA, AATags.TBAAStruct, AATags.Scope,
         AATags.NoAlias);
   }
   NewCall->setDebugLoc(TheStore->getDebugLoc());
 
+  const auto *F = TheStore->getFunction();
+  if (F->hasGC())
+    if (auto GC = llvm::getGCStrategy(F->getGC()))
+      if (GC->requiresBarriers()) {
+        LLVMContext &Ctx = NewCall->getContext();
+        Type *ET = TheLoad->getType();
+        NewCall->addParamAttr(0, Attribute::get(Ctx, Attribute::ElementType, ET));
+        NewCall->addParamAttr(1, Attribute::get(Ctx, Attribute::ElementType, ET));
+      }
+
   if (MSSAU) {
     MemoryAccess *NewMemAcc = MSSAU->createMemoryAccessInBB(
         NewCall, nullptr, NewCall->getParent(), MemorySSA::BeforeTerminator);
     MSSAU->insertDef(cast<MemoryDef>(NewMemAcc), true);
   }
 
   LLVM_DEBUG(dbgs() << "  Formed new call: " << *NewCall << "\n"
                     << "    from load ptr=" << *LoadEv << " at: " << *TheLoad