[LIR] Set attributes on memset_pattern16.

[ab]

Summary

"inferattrs" will deduce the attribute, but it will be too late for many optimizations.

[mcrosier]

@haicheng, would you mind giving this a look? If not, I can look at this tomorrow.

[haicheng]

I have no problem with this change.

[ab]

This is IMO a little too hacky; what do you think of exposing inferattrs into a utility function?

[mcrosier]

In D17598#362168, @ab wrote:

This is IMO a little too hacky;

I tend to agree with Ahmed..

[ab]

Now that we have a unified way of setting attributes, use it.

Depends on D19470 and D19471.

[mehdi_amini]

Thanks Ahmed. LGTM.

include/llvm/IR/Function.h

public:
 
   /// \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
   /// if the name of this function does not match an intrinsic in that header.
   /// Note, this method does not need to be called directly, as it is called
   /// from Value::setName() whenever the name of this function changes.
   void recalculateIntrinsicID();
 
+  /// Returns the intrinsic ID from its name, or Intrinsic::not_intrinsic if the
+  /// name does not match any intrinsic.
+  static Intrinsic::ID lookupIntrinsicID(StringRef ValName);
+
   /// getCallingConv()/setCallingConv(CC) - These method get and set the
   /// calling convention of this function.  The enum values for the known
   /// calling conventions are defined in CallingConv.h.
   CallingConv::ID getCallingConv() const {
     return static_cast<CallingConv::ID>((getSubclassDataFromValue() >> 4) &
                                         CallingConv::MaxID);
   }
   void setCallingConv(CallingConv::ID CC) {

lib/IR/Function.cpp

static const char * const IntrinsicNameTable[] = {
   "not_intrinsic",
 #define GET_INTRINSIC_NAME_TABLE
 #include "llvm/IR/Intrinsics.gen"
 #undef GET_INTRINSIC_NAME_TABLE
 };
 
 /// \brief This does the actual lookup of an intrinsic ID which
 /// matches the given function name.
-static Intrinsic::ID lookupIntrinsicID(const ValueName *ValName) {
-  StringRef Name = ValName->getKey();
-
+Intrinsic::ID Function::lookupIntrinsicID(StringRef Name) {
   ArrayRef<const char *> NameTable(&IntrinsicNameTable[1],
                                    std::end(IntrinsicNameTable));
   int Idx = Intrinsic::lookupLLVMIntrinsicByName(NameTable, Name);
   Intrinsic::ID ID = static_cast<Intrinsic::ID>(Idx + 1);
   if (ID == Intrinsic::not_intrinsic)
     return ID;
 
   // If the intrinsic is not overloaded, require an exact match. If it is
   // overloaded, require a prefix match.
   bool IsPrefixMatch = Name.size() > strlen(NameTable[Idx]);
   return IsPrefixMatch == isOverloaded(ID) ? ID : Intrinsic::not_intrinsic;
 }
 
 void Function::recalculateIntrinsicID() {
   const ValueName *ValName = this->getValueName();
   if (!ValName || !isIntrinsic()) {
     IntID = Intrinsic::not_intrinsic;
     return;
   }
-  IntID = lookupIntrinsicID(ValName);
+  IntID = lookupIntrinsicID(ValName->getKey());
 }
 
 /// Returns a stable mangling for the type specified for use in the name
 /// mangling scheme used by 'any' types in intrinsic signatures.  The mangling
 /// of named types is simply their name.  Manglings for unnamed types consist
 /// of a prefix ('p' for pointers, 'a' for arrays, 'f_' for functions)
 /// combined with the mangling of their component types.  A vararg function
 /// type will have a suffix of 'vararg'.  Since function types can contain

lib/Transforms/Scalar/LoopIdiomRecognize.cpp

 #include "llvm/Analysis/ScalarEvolutionExpressions.h"
 #include "llvm/Analysis/TargetLibraryInfo.h"
 #include "llvm/Analysis/TargetTransformInfo.h"
 #include "llvm/Analysis/ValueTracking.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/Dominators.h"
 #include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/IntrinsicInst.h"
+#include "llvm/IR/Intrinsics.h"
 #include "llvm/IR/Module.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Transforms/Utils/Local.h"
 #include "llvm/Transforms/Utils/LoopUtils.h"
 using namespace llvm;
 
 #define DEBUG_TYPE "loop-idiom"
bool LoopIdiomRecognize::processLoopStridedStore(
   } else {
     // Everything is emitted in default address space
     Type *Int8PtrTy = DestInt8PtrTy;
 
     Module *M = TheStore->getModule();
     Value *MSP =
         M->getOrInsertFunction("memset_pattern16", Builder.getVoidTy(),
                                Int8PtrTy, Int8PtrTy, IntPtr, (void *)nullptr);
+    // memset_pattern is not an intrinsic, so it won't automatically gets the
+    // right set of attributes. Let's manually pulled the same ones as memset
+    cast<Function>(MSP)->setAttributes(Intrinsic::getAttributes(
+        M->getContext(), Function::lookupIntrinsicID("llvm.memset.")));
 
     // Otherwise we should form a memset_pattern16.  PatternValue is known to be
     // an constant array of 16-bytes.  Plop the value into a mergable global.
     GlobalVariable *GV = new GlobalVariable(*M, PatternValue->getType(), true,
                                             GlobalValue::PrivateLinkage,
                                             PatternValue, ".memset_pattern");
     GV->setUnnamedAddr(true); // Ok to merge these.
     GV->setAlignment(16);

test/Transforms/LoopIdiom/basic.ll

 
 for.end6:                                         ; preds = %for.inc4
   ret void
 ; CHECK-LABEL: @test19(
 ; CHECK: entry:
 ; CHECK-NEXT: call void @llvm.memset.p0i8.i64(i8* %X, i8 0, i64 10000, i32 1, i1 false)
 ; CHECK: ret void
 }
+
+
+; Validate that "memset_pattern" has inherited attributed from memset
+; CHECK-LABEL: declare void @memset_pattern16(i8* nocapture, i8*, i64) #
+