Create instruction classes for identifying any atomicity of memory intrinsic. (NFC)

[dneilson]

Summary

For reference, see: http://lists.llvm.org/pipermail/llvm-dev/2017-August/116589.html

This patch fleshes out the instruction class hierarchy with respect to atomic and
non-atomic memory intrinsics. With this change, the relevant part of the class
hierarchy becomes:

IntrinsicInst

-> MemIntrinsicBase (methods-only class)
  -> MemIntrinsic (non-atomic intrinsics)
    -> MemSetInst
    -> MemTransferInst
      -> MemCpyInst
      -> MemMoveInst
  -> AtomicMemIntrinsic (atomic intrinsics)
    -> AtomicMemSetInst
    -> AtomicMemTransferInst
      -> AtomicMemCpyInst
      -> AtomicMemMoveInst
  -> AnyMemIntrinsic (both atomicities)
    -> AnyMemSetInst
    -> AnyMemTransferInst
      -> AnyMemCpyInst
      -> AnyMemMoveInst

This involves some class renaming:

ElementUnorderedAtomicMemCpyInst -> AtomicMemCpyInst
ElementUnorderedAtomicMemMoveInst -> AtomicMemMoveInst
ElementUnorderedAtomicMemSetInst -> AtomicMemSetInst

A script for doing this renaming in downstream trees is included below.

An example of where the Any* classes should be used in LLVM is when reasoning
about the effects of an instruction (ex: aliasing).

---

Script for renaming AtomicMem* classes:
PREFIXES="[<,([:space:]]"
CLASSES="MemIntrinsic|MemTransferInst|MemSetInst|MemMoveInst|MemCpyInst"
SUFFIXES="[;)>,[:space:]]"

REGEX="(${PREFIXES})ElementUnorderedAtomic(${CLASSES})(${SUFFIXES})"
REGEX2="visitElementUnorderedAtomic(${CLASSES})"

FILES=$( grep -E "(${REGEX}|${REGEX2})" -r . | tr ':' ' ' | awk '{print $1}' | sort | uniq )

SED_SCRIPT="s~${REGEX}~\1Atomic\2\3~g"
SED_SCRIPT2="s~${REGEX2}~visitAtomic\1~g"

for f in $FILES; do

echo "Processing: $f"
sed  -i ".bak" -E "${SED_SCRIPT};${SED_SCRIPT2};${EA_SED_SCRIPT};${EA_SED_SCRIPT2}" $f

done

[dneilson]

Pulling this, for now. I'm going to make sure that the joint part of the hierarchy (i.e. the AnyMem* classes) will work before trying to land this part.

[hfinkel]

In D38419#884799, @dneilson wrote:

Pulling this, for now. I'm going to make sure that the joint part of the hierarchy (i.e. the AnyMem* classes) will work before trying to land this part.

FWIW, I don't really like the PainMem* names, although the AtomicMem* looks like an improvement. Can't you just leave the plain ones alone?

[dneilson]

In D38419#884865, @hfinkel wrote:

In D38419#884799, @dneilson wrote:

Pulling this, for now. I'm going to make sure that the joint part of the hierarchy (i.e. the AnyMem* classes) will work before trying to land this part.

FWIW, I don't really like the PainMem* names, although the AtomicMem* looks like an improvement. Can't you just leave the plain ones alone?

I have no particular objection to leaving the plain ones as is. It's what I suggested: http://lists.llvm.org/pipermail/llvm-dev/2017-August/116716.html

A counter suggestion, that wasn't challenged, was made to change the plain ones as well: http://lists.llvm.org/pipermail/llvm-dev/2017-August/116722.html

[hfinkel]

In D38419#884869, @dneilson wrote:

In D38419#884865, @hfinkel wrote:

In D38419#884799, @dneilson wrote:

Pulling this, for now. I'm going to make sure that the joint part of the hierarchy (i.e. the AnyMem* classes) will work before trying to land this part.

FWIW, I don't really like the PainMem* names, although the AtomicMem* looks like an improvement. Can't you just leave the plain ones alone?

I have no particular objection to leaving the plain ones as is. It's what I suggested: http://lists.llvm.org/pipermail/llvm-dev/2017-August/116716.html

A counter suggestion, that wasn't challenged, was made to change the plain ones as well: http://lists.llvm.org/pipermail/llvm-dev/2017-August/116722.html

Fair enough. I challenge :-) -- Sanjoy's comment about silent failures downstream is legitimate, but given how new the atomic versions of these are, I don't think that I'm concerned (and it will fail in the right way: by not recognizing the atomic forms, which is what any current code is probably intended to do (because it was written before the atomic forms existed)).

[dneilson]

In D38419#884894, @hfinkel wrote:

In D38419#884869, @dneilson wrote:

In D38419#884865, @hfinkel wrote:

In D38419#884799, @dneilson wrote:

Pulling this, for now. I'm going to make sure that the joint part of the hierarchy (i.e. the AnyMem* classes) will work before trying to land this part.

FWIW, I don't really like the PainMem* names, although the AtomicMem* looks like an improvement. Can't you just leave the plain ones alone?

I have no particular objection to leaving the plain ones as is. It's what I suggested: http://lists.llvm.org/pipermail/llvm-dev/2017-August/116716.html

A counter suggestion, that wasn't challenged, was made to change the plain ones as well: http://lists.llvm.org/pipermail/llvm-dev/2017-August/116722.html

Fair enough. I challenge :-) -- Sanjoy's comment about silent failures downstream is legitimate, but given how new the atomic versions of these are, I don't think that I'm concerned (and it will fail in the right way: by not recognizing the atomic forms, which is what any current code is probably intended to do (because it was written before the atomic forms existed)).

Playing a little devil's advocate... A benefit I can see, off the top of my head, in favour of changing to PlainMem* is cognitive. Having all of PlainMem* & AtomicMem* & AnyMem* makes the programmer have to think, briefly, about whether they're dealing with atomic or non-atomic variants. Leaving the non-atomic variants as is makes it easier to not even consider that the atomic variants exist.

[hfinkel]

In D38419#884898, @dneilson wrote:

In D38419#884894, @hfinkel wrote:

In D38419#884869, @dneilson wrote:

In D38419#884865, @hfinkel wrote:

In D38419#884799, @dneilson wrote:

Pulling this, for now. I'm going to make sure that the joint part of the hierarchy (i.e. the AnyMem* classes) will work before trying to land this part.

FWIW, I don't really like the PainMem* names, although the AtomicMem* looks like an improvement. Can't you just leave the plain ones alone?

I have no particular objection to leaving the plain ones as is. It's what I suggested: http://lists.llvm.org/pipermail/llvm-dev/2017-August/116716.html

A counter suggestion, that wasn't challenged, was made to change the plain ones as well: http://lists.llvm.org/pipermail/llvm-dev/2017-August/116722.html

Fair enough. I challenge :-) -- Sanjoy's comment about silent failures downstream is legitimate, but given how new the atomic versions of these are, I don't think that I'm concerned (and it will fail in the right way: by not recognizing the atomic forms, which is what any current code is probably intended to do (because it was written before the atomic forms existed)).

Playing a little devil's advocate... A benefit I can see, off the top of my head, in favour of changing to PlainMem* is cognitive. Having all of PlainMem* & AtomicMem* & AnyMem* makes the programmer have to think, briefly, about whether they're dealing with atomic or non-atomic variants. Leaving the non-atomic variants as is makes it easier to not even consider that the atomic variants exist.

I know. Of course, trying to force people to think in this fashion doesn't always have the desired effect (doing the text substitution and moving on is more likely). It's also true that most people will never see these and we're not really giving people clear guidance on how to update their code. I think we can give relatively-clear guidance, something like, "If your code is looking at Mem* to reason about its effect on memory, then it can probably use AnyMem*, if you're transforming the Mem*, then you probably need to switch to using PlainMem* (or leave it alone, as the case may be). Frankly, I think we'll just need to be diligent in code review for a while regardless of what we do.

I'm also, in general, just not a fan of "Plain" as a prefix. Our memcpy intrinsics (and friends) are already extensions of the underlying C functions (we can specify alignments, volatileness, etc.). If we really want to rename in this way, I think that using NonAtomic as the prefix is better.

[dneilson]

Flush out the hierarchy, and do not rename the classes for the non-atomic memory intrinsics.

[dneilson]

ping - Could someone please take a look at this? Thank you.

[dneilson]

ping - Review still requested/needed. It may look daunting, but the change is pretty simple.

[dneilson]

• Rebasing.
• Removing change to AliasSetTracker; this makes this change purely NFC.

[sanjoy]

Hi Daniel,

I'll take a look at this today; but you might want to reply to the llvm-dev RFC thread with a link to this patch to get some more eyeballs on it.

[sanjoy]

Just to be clear, at the isa<>, dyn_cast<> level, this is the hierarchy you're shooting for right:

digraph G {
	AnyMemI -> MemI
	AnyMemI -> AtomicMemI
	AnyMemI -> AnyMemSetI
	AnyMemI -> AnyMemTransferI

	AnyMemSetI -> MemSetI
	AnyMemSetI -> AtomicMemSetI

	AnyMemTransferI -> AtomicMemTransferI
	AnyMemTransferI -> MemTransferI
	AnyMemTransferI -> AnyMemCpyI
	AnyMemTransferI -> AnyMemMoveI

	AtomicMemTransferI -> AtomicMemcpyI
	AtomicMemTransferI -> AtomicMemMoveI

	MemTransferI -> MemcpyI
	MemTransferI -> MemMoveI

	AnyMemCpyI -> MemcpyI
	AnyMemCpyI -> AtomicMemcpyI

	AnyMemMoveI -> MemMoveI
	AnyMemMoveI -> AtomicMemMoveI

	MemI -> MemTransferI
	MemI -> MemMoveI

	AtomicMemI -> AtomicMemTransferI
	AtomicMemI -> AtomicMemMoveI
}

include/llvm/IR/IntrinsicInst.h

221

This will let users up-cast AtomicMemInstrinsic and MemIntrinsic objects to MemIntrinsicBase objects -- is that okay? If it isn't, we can use CRTP to avoid giving AtomicMemInstrinsic and MemIntrinsic the same base class, as in:

template<typename Derived>
class MemIntrinsicBase : public IntrinsicInst { ... /* No real use of Derived anywhere */ };

class AtomicMemIntrinsic : public MemIntrinsicBase<AtomicMemIntrinsic> { ... };
class MemIntrinsic : public MemIntrinsicBase<MemIntrinsic> { ... };

// Now MemIntrinsic and AtomicMemIntrinsic do not have a common base class (at the C++ level).

258

Maybe explicitly note that this also strips addrspacecast?

424

The inline attribute is not necessary here I think -- member defined within the class are automatically inline.

489

Should we implement this for the atomic intrinsics as well?

633

Isn't the the common base for atomic *and non-atomic* mem(set|move|cpy)?

641

Did you consider not providing the isVolatile() accessor on AtomicMemIntrinsic? Design-wise I find that (not having the acccessor) slightly more preferable, but if that would require a lot of extra code then it isn't worth it.

740

These comments need to be updated.

[dneilson]

In D38419#907201, @sanjoy wrote:

Just to be clear, at the isa<>, dyn_cast<> level, this is the hierarchy you're shooting for right:

digraph G {
	AnyMemI -> MemI
	AnyMemI -> AtomicMemI
	AnyMemI -> AnyMemSetI
	AnyMemI -> AnyMemTransferI

	AnyMemSetI -> MemSetI
	AnyMemSetI -> AtomicMemSetI

	AnyMemTransferI -> AtomicMemTransferI
	AnyMemTransferI -> MemTransferI
	AnyMemTransferI -> AnyMemCpyI
	AnyMemTransferI -> AnyMemMoveI

	AtomicMemTransferI -> AtomicMemcpyI
	AtomicMemTransferI -> AtomicMemMoveI

	MemTransferI -> MemcpyI
	MemTransferI -> MemMoveI

	AnyMemCpyI -> MemcpyI
	AnyMemCpyI -> AtomicMemcpyI

	AnyMemMoveI -> MemMoveI
	AnyMemMoveI -> AtomicMemMoveI

	MemI -> MemTransferI
	MemI -> MemMoveI

	AtomicMemI -> AtomicMemTransferI
	AtomicMemI -> AtomicMemMoveI
}

The current isa<> hierarchy is this, minus the transitive edges:

digraph Existing {
  MemCpy -> MemTransfer
  MemMove -> MemTransfer
  MemTransfer -> MemI
  MemSet -> MemI
}

So, all of the following are true: isa<MemTransfer>(MemCpy), isa<MemTransfer>(MemMove), isa<MemI>(MemTransfer), and isa<MemI>(MemSet). Plus, the transitive relations: isa<MemI>(MemCpy), isa<MemI>(MemMove)

The new hierarchy is this exact same thing within each of of the atomicity-types (non-atomic, Atomic, and Any). In addition we have as true: isa<AnyX>(X) , isa<AnyX>(AtomicX), and all of the transitive edges like isa<AnyMemTransfer>(MemCpy) and isa<AnyMemI>(AtomicMemMove).

Stating the obvious... this is not a bidirectional relation. For example, it is not the case that isa<X>(AnyX) or isa<AtomicX>(AnyX).

include/llvm/IR/IntrinsicInst.h

221

I don't know that it actually matters whether they have a common C++ base class or not; I can't really see the base class ever being used outside of these class definitions.

CRTP seems to be more the norm in the LLVM codebase, so I could change this to use CRTP if only to be more consistent with other parts of LLVM.

I've no strong preference; I could go either way.

258

No harm in that.

489

The alignment stuff is trickier for the atomic memory intrinsics. Alignment is a property of the source & dest arguments, rather than an argument of its own. For the atomic intrinsics we'd need to implement getSourceAlignmentCst() and getDestAlignmentCst().

So, I was erring on the side of leaving it unimplemented for now and adding it in once we see whether it's useful and how it would be used.

Also, I'm hoping to get to revisiting the old patch that removes the alignment parameter from the non-atomic intrinsics and makes it an argument property. Once that's been done, then we could unify the alignment interfaces between atomic & non-atomic intrinsics.

641

Definitely considered it. I went for symmetry of implementation for no other reason than aesthetics.

Design-wise, there's definitely benefit to not having isVolatile() in the atomic hierarchy. Minimally, it's less confusing to implementers if it's not there -- since its always false for the atomic intrinsics.

If someone wants to add a volatile version of the atomic memory intrinsics down the line, for some reason, then they could always add isVolatile as part of that work.

[dneilson]

• Rebase.
• Fixing cut & paste errors in comments.
• Remove isVolatile() method from the atomic memory intrinsic hierarchy.
• Change MemInstrinsicBase to use CRTP.
• Remove inline keyword from classof() method declarations.

[sanjoy]

lgtm

I'd suggest waiting 1-2 days to give time for someone to chime in (after reading the llvm-dev ping you sent out) and then checking this in.

include/llvm/IR/IntrinsicInst.h

220

Please also add a comment on why we have CRTP here.

221

I don't know that it actually matters whether they have a common C++ base class or not; I can't really see the base class ever being used outside of these class definitions.

Another way of stating what I meant to say is that the fact that there is a MemIntrinsicBase class that is the base of all these classes is an implementation detail (I assumed this, maybe you have a different picture in mind); and for this reason we should help users not rely on this property by not actually providing a common base class.

489

SGTM

641

Minor nit: you could just use one dyn_cast here:

if (auto *MI = dyn_cast<MemIntrinsic>(...))
  return MI->isVolatile();

lib/IR/Verifier.cpp

4030

Mind removing this extra semi-colon as well?

[dneilson]

• Address minor nits.
• Clang-formatting change.

[dneilson]

• Missed a comment regarding why we use CRTP for the MemIntrinsicBase class.

include/llvm-c/Core.h

macro(Constant)                         \
           macro(GlobalVariable)             \
       macro(UndefValue)                     \
     macro(Instruction)                      \
       macro(BinaryOperator)                 \
       macro(CallInst)                       \
         macro(IntrinsicInst)                \
           macro(DbgInfoIntrinsic)           \
             macro(DbgDeclareInst)           \
-          macro(MemIntrinsic)               \
-            macro(MemCpyInst)               \
-            macro(MemMoveInst)              \
-            macro(MemSetInst)               \
+          macro(PlainMemIntrinsic)               \
+            macro(PlainMemCpyInst)               \
+            macro(PlainMemMoveInst)              \
+            macro(PlainMemSetInst)               \
       macro(CmpInst)                        \
         macro(FCmpInst)                     \
         macro(ICmpInst)                     \
       macro(ExtractElementInst)             \
       macro(GetElementPtrInst)              \
       macro(InsertElementInst)              \
       macro(InsertValueInst)                \
       macro(LandingPadInst)                 \

include/llvm/Analysis/AliasSetTracker.h

 #include <iterator>
 #include <vector>
 
 namespace llvm {
 
 class AliasSetTracker;
 class BasicBlock;
 class LoadInst;
-class MemSetInst;
-class MemTransferInst;
+class PlainMemSetInst;
+class PlainMemTransferInst;
 class raw_ostream;
 class StoreInst;
 class VAArgInst;
 class Value;
 
 class AliasSet : public ilist_node<AliasSet> {
   friend class AliasSetTracker;
 
public:
   ///
   /// These methods return true if inserting the instruction resulted in the
   /// addition of a new alias set (i.e., the pointer did not alias anything).
   ///
   void add(Value *Ptr, uint64_t Size, const AAMDNodes &AAInfo); // Add a loc.
   void add(LoadInst *LI);
   void add(StoreInst *SI);
   void add(VAArgInst *VAAI);
-  void add(MemSetInst *MSI);
-  void add(MemTransferInst *MTI);
+  void add(PlainMemSetInst *MSI);
+  void add(PlainMemTransferInst *MTI);
   void add(Instruction *I);       // Dispatch to one of the other add methods...
   void add(BasicBlock &BB);       // Add all instructions in basic block
   void add(const AliasSetTracker &AST); // Add alias relations from another AST
   void addUnknown(Instruction *I);
 
   void clear();
 
   /// Return the alias sets that are active.

include/llvm/Analysis/MemoryLocation.h

 #include "llvm/ADT/DenseMapInfo.h"
 #include "llvm/IR/CallSite.h"
 #include "llvm/IR/Metadata.h"
 
 namespace llvm {
 
 class LoadInst;
 class StoreInst;
-class MemTransferInst;
-class MemIntrinsic;
+class PlainMemTransferInst;
+class PlainMemIntrinsic;
 class TargetLibraryInfo;
 
 /// Representation for a specific memory location.
 ///
 /// This abstraction can be used to represent a specific location in memory.
 /// The goal of the location is to represent enough information to describe
 /// abstract aliasing, modification, and reference behaviors of whatever
 /// value(s) are stored in memory at the particular location.
static Optional<MemoryLocation> getOrNone(const Instruction *Inst) {
     case Instruction::AtomicRMW:
       return get(cast<AtomicRMWInst>(Inst));
     default:
       return None;
     }
   }
 
   /// Return a location representing the source of a memory transfer.
-  static MemoryLocation getForSource(const MemTransferInst *MTI);
+  static MemoryLocation getForSource(const PlainMemTransferInst *MTI);
 
   /// Return a location representing the destination of a memory set or
   /// transfer.
-  static MemoryLocation getForDest(const MemIntrinsic *MI);
+  static MemoryLocation getForDest(const PlainMemIntrinsic *MI);
 
   /// Return a location representing a particular argument of a call.
   static MemoryLocation getForArgument(ImmutableCallSite CS, unsigned ArgIdx,
                                        const TargetLibraryInfo &TLI);
 
   explicit MemoryLocation(const Value *Ptr = nullptr,
                           uint64_t Size = UnknownSize,
                           const AAMDNodes &AATags = AAMDNodes())

include/llvm/Analysis/PtrUseVisitor.h

void visitGetElementPtrInst(GetElementPtrInst &GEPI) {
 
     // Enqueue the users now that the offset has been adjusted.
     enqueueUsers(GEPI);
   }
 
   // No-op intrinsics which we know don't escape the pointer to to logic in
   // some other function.
   void visitDbgInfoIntrinsic(DbgInfoIntrinsic &I) {}
-  void visitMemIntrinsic(MemIntrinsic &I) {}
+  void visitPlainMemIntrinsic(PlainMemIntrinsic &I) {}
   void visitIntrinsicInst(IntrinsicInst &II) {
     switch (II.getIntrinsicID()) {
     default:
       return Base::visitIntrinsicInst(II);
 
     case Intrinsic::lifetime_start:
     case Intrinsic::lifetime_end:
       return; // No-op intrinsics.

include/llvm/IR/InstVisitor.h

#include "llvm/IR/Instruction.def"
   RetTy visitFuncletPadInst(FuncletPadInst &I) { DELEGATE(Instruction); }
   RetTy visitCleanupPadInst(CleanupPadInst &I) { DELEGATE(FuncletPadInst); }
   RetTy visitCatchPadInst(CatchPadInst &I)     { DELEGATE(FuncletPadInst); }
 
   // Handle the special instrinsic instruction classes.
   RetTy visitDbgDeclareInst(DbgDeclareInst &I)    { DELEGATE(DbgInfoIntrinsic);}
   RetTy visitDbgValueInst(DbgValueInst &I)        { DELEGATE(DbgInfoIntrinsic);}
   RetTy visitDbgInfoIntrinsic(DbgInfoIntrinsic &I) { DELEGATE(IntrinsicInst); }
-  RetTy visitMemSetInst(MemSetInst &I)            { DELEGATE(MemIntrinsic); }
-  RetTy visitMemCpyInst(MemCpyInst &I)            { DELEGATE(MemTransferInst); }
-  RetTy visitMemMoveInst(MemMoveInst &I)          { DELEGATE(MemTransferInst); }
-  RetTy visitMemTransferInst(MemTransferInst &I)  { DELEGATE(MemIntrinsic); }
-  RetTy visitMemIntrinsic(MemIntrinsic &I)        { DELEGATE(IntrinsicInst); }
+  RetTy visitPlainMemSetInst(PlainMemSetInst &I)            { DELEGATE(PlainMemIntrinsic); }
+  RetTy visitPlainMemCpyInst(PlainMemCpyInst &I)            { DELEGATE(PlainMemTransferInst); }
+  RetTy visitPlainMemMoveInst(PlainMemMoveInst &I)          { DELEGATE(PlainMemTransferInst); }
+  RetTy visitPlainMemTransferInst(PlainMemTransferInst &I)  { DELEGATE(PlainMemIntrinsic); }
+  RetTy visitPlainMemIntrinsic(PlainMemIntrinsic &I)        { DELEGATE(IntrinsicInst); }
   RetTy visitVAStartInst(VAStartInst &I)          { DELEGATE(IntrinsicInst); }
   RetTy visitVAEndInst(VAEndInst &I)              { DELEGATE(IntrinsicInst); }
   RetTy visitVACopyInst(VACopyInst &I)            { DELEGATE(IntrinsicInst); }
   RetTy visitIntrinsicInst(IntrinsicInst &I)      { DELEGATE(CallInst); }
 
   // Call and Invoke are slightly different as they delegate first through
   // a generic CallSite visitor.
   RetTy visitCallInst(CallInst &I) {

 private:
   // Special helper function to delegate to CallInst subclass visitors.
   RetTy delegateCallInst(CallInst &I) {
     if (const Function *F = I.getCalledFunction()) {
       switch (F->getIntrinsicID()) {
       default:                     DELEGATE(IntrinsicInst);
       case Intrinsic::dbg_declare: DELEGATE(DbgDeclareInst);
       case Intrinsic::dbg_value:   DELEGATE(DbgValueInst);
-      case Intrinsic::memcpy:      DELEGATE(MemCpyInst);
-      case Intrinsic::memmove:     DELEGATE(MemMoveInst);
-      case Intrinsic::memset:      DELEGATE(MemSetInst);
+      case Intrinsic::memcpy:      DELEGATE(PlainMemCpyInst);
+      case Intrinsic::memmove:     DELEGATE(PlainMemMoveInst);
+      case Intrinsic::memset:      DELEGATE(PlainMemSetInst);
       case Intrinsic::vastart:     DELEGATE(VAStartInst);
       case Intrinsic::vaend:       DELEGATE(VAEndInst);
       case Intrinsic::vacopy:      DELEGATE(VACopyInst);
       case Intrinsic::not_intrinsic: break;
       }
     }
     DELEGATE(CallInst);
   }

include/llvm/IR/IntrinsicInst.h

 //===-- llvm/IntrinsicInst.h - Intrinsic Instruction Wrappers ---*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines classes that make it really easy to deal with intrinsic
 // functions with the isa/dyncast family of functions.  In particular, this
 // allows you to do things like:
 //
-//     if (MemCpyInst *MCI = dyn_cast<MemCpyInst>(Inst))
+//     if (PlainMemCpyInst *MCI = dyn_cast<PlainMemCpyInst>(Inst))
 //        ... MCI->getDest() ... MCI->getSource() ...
 //
 // All intrinsic function calls are instances of the call instruction, so these
 // are all subclasses of the CallInst class.  Note that none of these classes
 // has state or virtual methods, which is an important part of this gross/neat
 // hack working.
 //
 //===----------------------------------------------------------------------===//
static bool classof(const IntrinsicInst *I) {
       }
     }
     static bool classof(const Value *V) {
       return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
     }
   };
 
   /// This class represents atomic memcpy intrinsic
-  /// TODO: Integrate this class into MemIntrinsic hierarchy; for now this is
+  /// TODO: Integrate this class into PlainMemIntrinsic hierarchy; for now this is
   /// C&P of all methods from that hierarchy
-  class ElementUnorderedAtomicMemCpyInst : public IntrinsicInst {
+  class AtomicMemCpyInst : public IntrinsicInst {
   private:
     enum { ARG_DEST = 0, ARG_SOURCE = 1, ARG_LENGTH = 2, ARG_ELEMENTSIZE = 3 };
 
   public:
     Value *getRawDest() const {
       return const_cast<Value *>(getArgOperand(ARG_DEST));
     }
     const Use &getRawDestUse() const { return getArgOperandUse(ARG_DEST); }
     Use &getRawDestUse() { return getArgOperandUse(ARG_DEST); }
 
ConstantInt *getElementSizeInBytesCst() const {
       return cast<ConstantInt>(getRawElementSizeInBytes());
     }
 
     uint32_t getElementSizeInBytes() const {
       return getElementSizeInBytesCst()->getZExtValue();
     }
 
     /// This is just like getRawDest, but it strips off any cast
     /// instructions that feed it, giving the original input.  The returned
     /// value is guaranteed to be a pointer.
     Value *getDest() const { return getRawDest()->stripPointerCasts(); }
 
     /// This is just like getRawSource, but it strips off any cast
     /// instructions that feed it, giving the original input.  The returned
     /// value is guaranteed to be a pointer.
     Value *getSource() const { return getRawSource()->stripPointerCasts(); }
 
public:
     static bool classof(const IntrinsicInst *I) {
       return I->getIntrinsicID() == Intrinsic::memcpy_element_unordered_atomic;
     }
     static bool classof(const Value *V) {
       return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
     }
   };
 
-  class ElementUnorderedAtomicMemMoveInst : public IntrinsicInst {
+  class AtomicMemMoveInst : public IntrinsicInst {
   private:
     enum { ARG_DEST = 0, ARG_SOURCE = 1, ARG_LENGTH = 2, ARG_ELEMENTSIZE = 3 };
 
   public:
     Value *getRawDest() const {
       return const_cast<Value *>(getArgOperand(ARG_DEST));
     }
     const Use &getRawDestUse() const { return getArgOperandUse(ARG_DEST); }
static inline bool classof(const IntrinsicInst *I) {
       return I->getIntrinsicID() == Intrinsic::memmove_element_unordered_atomic;
     }
     static inline bool classof(const Value *V) {
       return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
     }
   };
 
   /// This class represents atomic memset intrinsic
-  /// TODO: Integrate this class into MemIntrinsic hierarchy; for now this is
+  /// TODO: Integrate this class into PlainMemIntrinsic hierarchy; for now this is
   /// C&P of all methods from that hierarchy
-  class ElementUnorderedAtomicMemSetInst : public IntrinsicInst {
+  class AtomicMemSetInst : public IntrinsicInst {
   private:
     enum { ARG_DEST = 0, ARG_VALUE = 1, ARG_LENGTH = 2, ARG_ELEMENTSIZE = 3 };
 
   public:
     Value *getRawDest() const {
       return const_cast<Value *>(getArgOperand(ARG_DEST));
     }
     const Use &getRawDestUse() const { return getArgOperandUse(ARG_DEST); }
     Use &getRawDestUse() { return getArgOperandUse(ARG_DEST); }
 
     Value *getValue() const { return const_cast<Value*>(getArgOperand(ARG_VALUE)); }
     const Use &getValueUse() const { return getArgOperandUse(ARG_VALUE); }
     Use &getValueUse() { return getArgOperandUse(ARG_VALUE); }
 
     Value *getLength() const {
       return const_cast<Value *>(getArgOperand(ARG_LENGTH));
     }
     const Use &getLengthUse() const { return getArgOperandUse(ARG_LENGTH); }
     Use &getLengthUse() { return getArgOperandUse(ARG_LENGTH); }
 
     bool isVolatile() const { return false; }
 
     Value *getRawElementSizeInBytes() const {
       return const_cast<Value *>(getArgOperand(ARG_ELEMENTSIZE));
     }
 
     ConstantInt *getElementSizeInBytesCst() const {
       return cast<ConstantInt>(getRawElementSizeInBytes());
     }
 
     uint32_t getElementSizeInBytes() const {
       return getElementSizeInBytesCst()->getZExtValue();
static inline bool classof(const IntrinsicInst *I) {
       return I->getIntrinsicID() == Intrinsic::memset_element_unordered_atomic;
     }
     static inline bool classof(const Value *V) {
       return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
     }
   };
 
   /// This is the common base class for memset/memcpy/memmove.
-  class MemIntrinsic : public IntrinsicInst {
+  class PlainMemIntrinsic : public IntrinsicInst {
   public:
     Value *getRawDest() const { return const_cast<Value*>(getArgOperand(0)); }
     const Use &getRawDestUse() const { return getArgOperandUse(0); }
     Use &getRawDestUse() { return getArgOperandUse(0); }
 
     Value *getLength() const { return const_cast<Value*>(getArgOperand(2)); }
     const Use &getLengthUse() const { return getArgOperandUse(2); }
     Use &getLengthUse() { return getArgOperandUse(2); }
 
     ConstantInt *getAlignmentCst() const {
       return cast<ConstantInt>(const_cast<Value*>(getArgOperand(3)));
     }
 
     unsigned getAlignment() const {
       return getAlignmentCst()->getZExtValue();
     }
 
     ConstantInt *getVolatileCst() const {
       return cast<ConstantInt>(const_cast<Value*>(getArgOperand(4)));
static bool classof(const IntrinsicInst *I) {
       }
     }
     static bool classof(const Value *V) {
       return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
     }
   };
 
   /// This class wraps the llvm.memset intrinsic.
-  class MemSetInst : public MemIntrinsic {
+  class PlainMemSetInst : public PlainMemIntrinsic {
   public:
     /// Return the arguments to the instruction.
     Value *getValue() const { return const_cast<Value*>(getArgOperand(1)); }
     const Use &getValueUse() const { return getArgOperandUse(1); }
     Use &getValueUse() { return getArgOperandUse(1); }
 
     void setValue(Value *Val) {
       assert(getValue()->getType() == Val->getType() &&
              "setValue called with value of wrong type!");
       setArgOperand(1, Val);
     }
 
     // Methods for support type inquiry through isa, cast, and dyn_cast:
     static bool classof(const IntrinsicInst *I) {
       return I->getIntrinsicID() == Intrinsic::memset;
     }
     static bool classof(const Value *V) {
       return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
     }
   };
 
   /// This class wraps the llvm.memcpy/memmove intrinsics.
-  class MemTransferInst : public MemIntrinsic {
+  class PlainMemTransferInst : public PlainMemIntrinsic {
   public:
     /// Return the arguments to the instruction.
     Value *getRawSource() const { return const_cast<Value*>(getArgOperand(1)); }
     const Use &getRawSourceUse() const { return getArgOperandUse(1); }
     Use &getRawSourceUse() { return getArgOperandUse(1); }
 
     /// This is just like getRawSource, but it strips off any cast
     /// instructions that feed it, giving the original input.  The returned
static bool classof(const IntrinsicInst *I) {
              I->getIntrinsicID() == Intrinsic::memmove;
     }
     static bool classof(const Value *V) {
       return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
     }
   };
 
   /// This class wraps the llvm.memcpy intrinsic.
-  class MemCpyInst : public MemTransferInst {
+  class PlainMemCpyInst : public PlainMemTransferInst {
   public:
     // Methods for support type inquiry through isa, cast, and dyn_cast:
     static bool classof(const IntrinsicInst *I) {
       return I->getIntrinsicID() == Intrinsic::memcpy;
     }
     static bool classof(const Value *V) {
       return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
     }
   };
 
   /// This class wraps the llvm.memmove intrinsic.
-  class MemMoveInst : public MemTransferInst {
+  class PlainMemMoveInst : public PlainMemTransferInst {
   public:
     // Methods for support type inquiry through isa, cast, and dyn_cast:
     static bool classof(const IntrinsicInst *I) {
       return I->getIntrinsicID() == Intrinsic::memmove;
     }
     static bool classof(const Value *V) {
       return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
     }
   };
 
   /// This represents the llvm.va_start intrinsic.
   class VAStartInst : public IntrinsicInst {
   public:
     static bool classof(const IntrinsicInst *I) {
       return I->getIntrinsicID() == Intrinsic::vastart;
     }
     static bool classof(const Value *V) {
       return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
     }
 
     Value *getArgList() const { return const_cast<Value*>(getArgOperand(0)); }
   };
 
   /// This represents the llvm.va_end intrinsic.
   class VAEndInst : public IntrinsicInst {
   public:
     static bool classof(const IntrinsicInst *I) {
public:
     Value *getTargetValue() const {
       return cast<Value>(const_cast<Value *>(getArgOperand(2)));
     }
 
     ConstantInt *getValueKind() const {
       return cast<ConstantInt>(const_cast<Value *>(getArgOperand(3)));
     }
 
     // Returns the value site index.
     ConstantInt *getIndex() const {
       return cast<ConstantInt>(const_cast<Value *>(getArgOperand(4)));
     }
   };
 
 } // end namespace llvm
 
 #endif // LLVM_IR_INTRINSICINST_H

include/llvm/Transforms/Scalar/AlignmentFromAssumptions.h

struct AlignmentFromAssumptionsPass
   // Glue for old PM.
   bool runImpl(Function &F, AssumptionCache &AC, ScalarEvolution *SE_,
                DominatorTree *DT_);
 
   // For memory transfers, we need a common alignment for both the source and
   // destination. If we have a new alignment for only one operand of a transfer
   // instruction, save it in these maps.  If we reach the other operand through
   // another assumption later, then we may change the alignment at that point.
-  DenseMap<MemTransferInst *, unsigned> NewDestAlignments, NewSrcAlignments;
+  DenseMap<PlainMemTransferInst *, unsigned> NewDestAlignments, NewSrcAlignments;
 
   ScalarEvolution *SE = nullptr;
   DominatorTree *DT = nullptr;
 
   bool extractAlignmentInfo(CallInst *I, Value *&AAPtr, const SCEV *&AlignSCEV,
                             const SCEV *&OffSCEV);
   bool processAssumption(CallInst *I);
 };
 }
 
 #endif // LLVM_TRANSFORMS_SCALAR_ALIGNMENTFROMASSUMPTIONS_H

include/llvm/Transforms/Scalar/MemCpyOptimizer.h

bool runImpl(Function &F, MemoryDependenceResults *MD_,
                TargetLibraryInfo *TLI_,
                std::function<AliasAnalysis &()> LookupAliasAnalysis_,
                std::function<AssumptionCache &()> LookupAssumptionCache_,
                std::function<DominatorTree &()> LookupDomTree_);
 
 private:
   // Helper functions
   bool processStore(StoreInst *SI, BasicBlock::iterator &BBI);
-  bool processMemSet(MemSetInst *SI, BasicBlock::iterator &BBI);
-  bool processMemCpy(MemCpyInst *M);
-  bool processMemMove(MemMoveInst *M);
+  bool processMemSet(PlainMemSetInst *SI, BasicBlock::iterator &BBI);
+  bool processMemCpy(PlainMemCpyInst *M);
+  bool processMemMove(PlainMemMoveInst *M);
   bool performCallSlotOptzn(Instruction *cpy, Value *cpyDst, Value *cpySrc,
                             uint64_t cpyLen, unsigned cpyAlign, CallInst *C);
-  bool processMemCpyMemCpyDependence(MemCpyInst *M, MemCpyInst *MDep);
-  bool processMemSetMemCpyDependence(MemCpyInst *M, MemSetInst *MDep);
-  bool performMemCpyToMemSetOptzn(MemCpyInst *M, MemSetInst *MDep);
+  bool processMemCpyMemCpyDependence(PlainMemCpyInst *M, PlainMemCpyInst *MDep);
+  bool processMemSetMemCpyDependence(PlainMemCpyInst *M, PlainMemSetInst *MDep);
+  bool performMemCpyToMemSetOptzn(PlainMemCpyInst *M, PlainMemSetInst *MDep);
   bool processByValArgument(CallSite CS, unsigned ArgNo);
   Instruction *tryMergingIntoMemset(Instruction *I, Value *StartPtr,
                                     Value *ByteVal);
 
   bool iterateOnFunction(Function &F);
 };
 
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_SCALAR_MEMCPYOPTIMIZER_H

include/llvm/Transforms/Utils/LowerMemIntrinsics.h

 
 #ifndef LLVM_TRANSFORMS_UTILS_LOWERMEMINTRINSICS_H
 #define LLVM_TRANSFORMS_UTILS_LOWERMEMINTRINSICS_H
 
 namespace llvm {
 
 class ConstantInt;
 class Instruction;
-class MemCpyInst;
-class MemMoveInst;
-class MemSetInst;
+class PlainMemCpyInst;
+class PlainMemMoveInst;
+class PlainMemSetInst;
 class TargetTransformInfo;
 class Value;
 
 /// Emit a loop implementing the semantics of llvm.memcpy with the equivalent
 /// arguments at \p InsertBefore.
 void createMemCpyLoop(Instruction *InsertBefore, Value *SrcAddr, Value *DstAddr,
                       Value *CopyLen, unsigned SrcAlign, unsigned DestAlign,
                       bool SrcIsVolatile, bool DstIsVolatile);

 void createMemCpyLoopKnownSize(Instruction *InsertBefore, Value *SrcAddr,
                                Value *DstAddr, ConstantInt *CopyLen,
                                unsigned SrcAlign, unsigned DestAlign,
                                bool SrcIsVolatile, bool DstIsVolatile,
                                const TargetTransformInfo &TTI);
 
 
 /// Expand \p MemCpy as a loop. \p MemCpy is not deleted.
-void expandMemCpyAsLoop(MemCpyInst *MemCpy, const TargetTransformInfo &TTI);
+void expandMemCpyAsLoop(PlainMemCpyInst *MemCpy, const TargetTransformInfo &TTI);
 
 /// Expand \p MemMove as a loop. \p MemMove is not deleted.
-void expandMemMoveAsLoop(MemMoveInst *MemMove);
+void expandMemMoveAsLoop(PlainMemMoveInst *MemMove);
 
 /// Expand \p MemSet as a loop. \p MemSet is not deleted.
-void expandMemSetAsLoop(MemSetInst *MemSet);
+void expandMemSetAsLoop(PlainMemSetInst *MemSet);
 
 } // End llvm namespace
 
 #endif

include/llvm/Transforms/Utils/VNCoercion.h

 #ifndef LLVM_TRANSFORMS_UTILS_VNCOERCION_H
 #define LLVM_TRANSFORMS_UTILS_VNCOERCION_H
 #include "llvm/IR/IRBuilder.h"
 
 namespace llvm {
 class Function;
 class StoreInst;
 class LoadInst;
-class MemIntrinsic;
+class PlainMemIntrinsic;
 class Instruction;
 class Value;
 class Type;
 class DataLayout;
 namespace VNCoercion {
 /// Return true if CoerceAvailableValueToLoadType would succeed if it was
 /// called.
 bool canCoerceMustAliasedValueToLoad(Value *StoredVal, Type *LoadTy,
int analyzeLoadFromClobberingLoad(Type *LoadTy, Value *LoadPtr, LoadInst *DepLI,
                                   const DataLayout &DL);
 
 /// This function determines whether a value for the pointer LoadPtr can be
 /// extracted from the memory intrinsic at DepMI.
 ///
 /// On success, it returns the offset into DepMI that extraction would start.
 /// On failure, it returns -1.
 int analyzeLoadFromClobberingMemInst(Type *LoadTy, Value *LoadPtr,
-                                     MemIntrinsic *DepMI, const DataLayout &DL);
+                                     PlainMemIntrinsic *DepMI, const DataLayout &DL);
 
 /// If analyzeLoadFromClobberingStore returned an offset, this function can be
 /// used to actually perform the extraction of the bits from the store. It
 /// inserts instructions to do so at InsertPt, and returns the extracted value.
 Value *getStoreValueForLoad(Value *SrcVal, unsigned Offset, Type *LoadTy,
                             Instruction *InsertPt, const DataLayout &DL);
 // This is the same as getStoreValueForLoad, except it performs no insertion
 // It only allows constant inputs.

 // a constant. It returns nullptr if it would require widening the load.
 Constant *getConstantLoadValueForLoad(Constant *SrcVal, unsigned Offset,
                                       Type *LoadTy, const DataLayout &DL);
 
 /// If analyzeLoadFromClobberingMemInst returned an offset, this function can be
 /// used to actually perform the extraction of the bits from the memory
 /// intrinsic.  It inserts instructions to do so at InsertPt, and returns the
 /// extracted value.
-Value *getMemInstValueForLoad(MemIntrinsic *SrcInst, unsigned Offset,
+Value *getMemInstValueForLoad(PlainMemIntrinsic *SrcInst, unsigned Offset,
                               Type *LoadTy, Instruction *InsertPt,
                               const DataLayout &DL);
 // This is the same as getStoreValueForLoad, except it performs no insertion.
 // It returns nullptr if it cannot produce a constant.
-Constant *getConstantMemInstValueForLoad(MemIntrinsic *SrcInst, unsigned Offset,
+Constant *getConstantMemInstValueForLoad(PlainMemIntrinsic *SrcInst, unsigned Offset,
                                          Type *LoadTy, const DataLayout &DL);
 }
 }
 #endif

lib/Analysis/AliasSetTracker.cpp

 void AliasSetTracker::add(VAArgInst *VAAI) {
   AAMDNodes AAInfo;
   VAAI->getAAMetadata(AAInfo);
 
   addPointer(VAAI->getOperand(0), MemoryLocation::UnknownSize, AAInfo,
              AliasSet::ModRefAccess);
 }
 
-void AliasSetTracker::add(MemSetInst *MSI) {
+void AliasSetTracker::add(PlainMemSetInst *MSI) {
   AAMDNodes AAInfo;
   MSI->getAAMetadata(AAInfo);
 
   uint64_t Len;
 
   if (ConstantInt *C = dyn_cast<ConstantInt>(MSI->getLength()))
     Len = C->getZExtValue();
   else
     Len = MemoryLocation::UnknownSize;
 
   AliasSet &AS =
       addPointer(MSI->getRawDest(), Len, AAInfo, AliasSet::ModAccess);
   if (MSI->isVolatile())
     AS.setVolatile();
 }
 
-void AliasSetTracker::add(MemTransferInst *MTI) {
+void AliasSetTracker::add(PlainMemTransferInst *MTI) {
   AAMDNodes AAInfo;
   MTI->getAAMetadata(AAInfo);
 
   uint64_t Len;
   if (ConstantInt *C = dyn_cast<ConstantInt>(MTI->getLength()))
     Len = C->getZExtValue();
   else
     Len = MemoryLocation::UnknownSize;

 void AliasSetTracker::add(Instruction *I) {
   // Dispatch to one of the other add methods.
   if (LoadInst *LI = dyn_cast<LoadInst>(I))
     return add(LI);
   if (StoreInst *SI = dyn_cast<StoreInst>(I))
     return add(SI);
   if (VAArgInst *VAAI = dyn_cast<VAArgInst>(I))
     return add(VAAI);
-  if (MemSetInst *MSI = dyn_cast<MemSetInst>(I))
+  if (PlainMemSetInst *MSI = dyn_cast<PlainMemSetInst>(I))
     return add(MSI);
-  if (MemTransferInst *MTI = dyn_cast<MemTransferInst>(I))
+  if (PlainMemTransferInst *MTI = dyn_cast<PlainMemTransferInst>(I))
     return add(MTI);
   return addUnknown(I);
 }
 
 void AliasSetTracker::add(BasicBlock &BB) {
   for (auto &I : BB)
     add(&I);
 }

lib/Analysis/BasicAliasAnalysis.cpp

if (isMallocOrCallocLikeFn(Inst, &TLI)) {
     if (getBestAAResults().alias(MemoryLocation(Inst), Loc) == NoAlias)
       return MRI_NoModRef;
   }
 
   // The semantics of memcpy intrinsics forbid overlap between their respective
   // operands, i.e., source and destination of any given memcpy must no-alias.
   // If Loc must-aliases either one of these two locations, then it necessarily
   // no-aliases the other.
-  if (auto *Inst = dyn_cast<MemCpyInst>(CS.getInstruction())) {
+  if (auto *Inst = dyn_cast<PlainMemCpyInst>(CS.getInstruction())) {
     AliasResult SrcAA, DestAA;
 
     if ((SrcAA = getBestAAResults().alias(MemoryLocation::getForSource(Inst),
                                           Loc)) == MustAlias)
       // Loc is exactly the memcpy source thus disjoint from memcpy dest.
       return MRI_Ref;
     if ((DestAA = getBestAAResults().alias(MemoryLocation::getForDest(Inst),
                                            Loc)) == MustAlias)

lib/Analysis/CaptureTracking.cpp

case Instruction::Invoke: {
       // Not captured if the callee is readonly, doesn't return a copy through
       // its return value and doesn't unwind (a readonly function can leak bits
       // by throwing an exception or not depending on the input value).
       if (CS.onlyReadsMemory() && CS.doesNotThrow() && I->getType()->isVoidTy())
         break;
 
       // Volatile operations effectively capture the memory location that they
       // load and store to.
-      if (auto *MI = dyn_cast<MemIntrinsic>(I))
+      if (auto *MI = dyn_cast<PlainMemIntrinsic>(I))
         if (MI->isVolatile())
           if (Tracker->captured(U))
             return;
 
       // Not captured if only passed via 'nocapture' arguments.  Note that
       // calling a function pointer does not in itself cause the pointer to
       // be captured.  This is a subtle point considering that (for example)
       // the callee might return its own address.  It is analogous to saying

lib/Analysis/LazyValueInfo.cpp

return L->getPointerAddressSpace() == 0 &&
            GetUnderlyingObject(L->getPointerOperand(),
                                L->getModule()->getDataLayout()) == Ptr;
   }
   if (StoreInst *S = dyn_cast<StoreInst>(I)) {
     return S->getPointerAddressSpace() == 0 &&
            GetUnderlyingObject(S->getPointerOperand(),
                                S->getModule()->getDataLayout()) == Ptr;
   }
-  if (MemIntrinsic *MI = dyn_cast<MemIntrinsic>(I)) {
+  if (PlainMemIntrinsic *MI = dyn_cast<PlainMemIntrinsic>(I)) {
     if (MI->isVolatile()) return false;
 
     // FIXME: check whether it has a valuerange that excludes zero?
     ConstantInt *Len = dyn_cast<ConstantInt>(MI->getLength());
     if (!Len || Len->isZero()) return false;
 
     if (MI->getDestAddressSpace() == 0)
       if (GetUnderlyingObject(MI->getRawDest(),
                               MI->getModule()->getDataLayout()) == Ptr)
         return true;
-    if (MemTransferInst *MTI = dyn_cast<MemTransferInst>(MI))
+    if (PlainMemTransferInst *MTI = dyn_cast<PlainMemTransferInst>(MI))
       if (MTI->getSourceAddressSpace() == 0)
         if (GetUnderlyingObject(MTI->getRawSource(),
                                 MTI->getModule()->getDataLayout()) == Ptr)
           return true;
   }
   return false;
 }
 

lib/Analysis/Lint.cpp

void Lint::visitCallSite(CallSite CS) {
 
   if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(&I))
     switch (II->getIntrinsicID()) {
     default: break;
 
     // TODO: Check more intrinsics
 
     case Intrinsic::memcpy: {
-      MemCpyInst *MCI = cast<MemCpyInst>(&I);
+      PlainMemCpyInst *MCI = cast<PlainMemCpyInst>(&I);
       // TODO: If the size is known, use it.
       visitMemoryReference(I, MCI->getDest(), MemoryLocation::UnknownSize,
                            MCI->getAlignment(), nullptr, MemRef::Write);
       visitMemoryReference(I, MCI->getSource(), MemoryLocation::UnknownSize,
                            MCI->getAlignment(), nullptr, MemRef::Read);
 
       // Check that the memcpy arguments don't overlap. The AliasAnalysis API
       // isn't expressive enough for what we really want to do. Known partial
       // overlap is not distinguished from the case where nothing is known.
       uint64_t Size = 0;
       if (const ConstantInt *Len =
               dyn_cast<ConstantInt>(findValue(MCI->getLength(),
                                               /*OffsetOk=*/false)))
         if (Len->getValue().isIntN(32))
           Size = Len->getValue().getZExtValue();
       Assert(AA->alias(MCI->getSource(), Size, MCI->getDest(), Size) !=
                  MustAlias,
              "Undefined behavior: memcpy source and destination overlap", &I);
       break;
     }
     case Intrinsic::memmove: {
-      MemMoveInst *MMI = cast<MemMoveInst>(&I);
+      PlainMemMoveInst *MMI = cast<PlainMemMoveInst>(&I);
       // TODO: If the size is known, use it.
       visitMemoryReference(I, MMI->getDest(), MemoryLocation::UnknownSize,
                            MMI->getAlignment(), nullptr, MemRef::Write);
       visitMemoryReference(I, MMI->getSource(), MemoryLocation::UnknownSize,
                            MMI->getAlignment(), nullptr, MemRef::Read);
       break;
     }
     case Intrinsic::memset: {
-      MemSetInst *MSI = cast<MemSetInst>(&I);
+      PlainMemSetInst *MSI = cast<PlainMemSetInst>(&I);
       // TODO: If the size is known, use it.
       visitMemoryReference(I, MSI->getDest(), MemoryLocation::UnknownSize,
                            MSI->getAlignment(), nullptr, MemRef::Write);
       break;
     }
 
     case Intrinsic::vastart:
       Assert(I.getParent()->getParent()->isVarArg(),

lib/Analysis/MemoryLocation.cpp

MemoryLocation MemoryLocation::get(const AtomicRMWInst *RMWI) {
   RMWI->getAAMetadata(AATags);
   const auto &DL = RMWI->getModule()->getDataLayout();
 
   return MemoryLocation(RMWI->getPointerOperand(),
                         DL.getTypeStoreSize(RMWI->getValOperand()->getType()),
                         AATags);
 }
 
-MemoryLocation MemoryLocation::getForSource(const MemTransferInst *MTI) {
+MemoryLocation MemoryLocation::getForSource(const PlainMemTransferInst *MTI) {
   uint64_t Size = UnknownSize;
   if (ConstantInt *C = dyn_cast<ConstantInt>(MTI->getLength()))
     Size = C->getValue().getZExtValue();
 
   // memcpy/memmove can have AA tags. For memcpy, they apply
   // to both the source and the destination.
   AAMDNodes AATags;
   MTI->getAAMetadata(AATags);
 
   return MemoryLocation(MTI->getRawSource(), Size, AATags);
 }
 
-MemoryLocation MemoryLocation::getForDest(const MemIntrinsic *MTI) {
+MemoryLocation MemoryLocation::getForDest(const PlainMemIntrinsic *MTI) {
   uint64_t Size = UnknownSize;
   if (ConstantInt *C = dyn_cast<ConstantInt>(MTI->getLength()))
     Size = C->getValue().getZExtValue();
 
   // memcpy/memmove can have AA tags. For memcpy, they apply
   // to both the source and the destination.
   AAMDNodes AATags;
   MTI->getAAMetadata(AATags);

lib/Analysis/ValueTracking.cpp

bool llvm::isGuaranteedToTransferExecutionToSuccessor(const Instruction *I) {
   if (const LoadInst *LI = dyn_cast<LoadInst>(I))
     return !LI->isVolatile();
   if (const StoreInst *SI = dyn_cast<StoreInst>(I))
     return !SI->isVolatile();
   if (const AtomicCmpXchgInst *CXI = dyn_cast<AtomicCmpXchgInst>(I))
     return !CXI->isVolatile();
   if (const AtomicRMWInst *RMWI = dyn_cast<AtomicRMWInst>(I))
     return !RMWI->isVolatile();
-  if (const MemIntrinsic *MII = dyn_cast<MemIntrinsic>(I))
+  if (const PlainMemIntrinsic *MII = dyn_cast<PlainMemIntrinsic>(I))
     return !MII->isVolatile();
 
   // If there is no successor, then execution can't transfer to it.
   if (const auto *CRI = dyn_cast<CleanupReturnInst>(I))
     return !CRI->unwindsToCaller();
   if (const auto *CatchSwitch = dyn_cast<CatchSwitchInst>(I))
     return !CatchSwitch->unwindsToCaller();
   if (isa<ResumeInst>(I))

lib/CodeGen/CodeGenPrepare.cpp

for (auto &Arg : CI->arg_operands()) {
       if ((GV = dyn_cast<GlobalVariable>(Val)) && GV->canIncreaseAlignment() &&
           GV->getPointerAlignment(*DL) < PrefAlign &&
           DL->getTypeAllocSize(GV->getValueType()) >=
               MinSize + Offset2)
         GV->setAlignment(PrefAlign);
     }
     // If this is a memcpy (or similar) then we may be able to improve the
     // alignment
-    if (MemIntrinsic *MI = dyn_cast<MemIntrinsic>(CI)) {
+    if (PlainMemIntrinsic *MI = dyn_cast<PlainMemIntrinsic>(CI)) {
       unsigned Align = getKnownAlignment(MI->getDest(), *DL);
-      if (MemTransferInst *MTI = dyn_cast<MemTransferInst>(MI))
+      if (PlainMemTransferInst *MTI = dyn_cast<PlainMemTransferInst>(MI))
         Align = std::min(Align, getKnownAlignment(MTI->getSource(), *DL));
       if (Align > MI->getAlignment())
         MI->setAlignment(ConstantInt::get(MI->getAlignmentType(), Align));
     }
   }
 
   // If we have a cold call site, try to sink addressing computation into the
   // cold block.  This interacts with our handling for loads and stores to

lib/CodeGen/SafeStack.cpp

class SafeStack {
   /// space dynamically on the unsafe stack and store the dynamic unsafe stack
   /// top to \p DynamicTop if non-null.
   void moveDynamicAllocasToUnsafeStack(Function &F, Value *UnsafeStackPtr,
                                        AllocaInst *DynamicTop,
                                        ArrayRef<AllocaInst *> DynamicAllocas);
 
   bool IsSafeStackAlloca(const Value *AllocaPtr, uint64_t AllocaSize);
 
-  bool IsMemIntrinsicSafe(const MemIntrinsic *MI, const Use &U,
+  bool IsMemIntrinsicSafe(const PlainMemIntrinsic *MI, const Use &U,
                           const Value *AllocaPtr, uint64_t AllocaSize);
   bool IsAccessSafe(Value *Addr, uint64_t Size, const Value *AllocaPtr,
                     uint64_t AllocaSize);
 
 public:
   SafeStack(Function &F, const TargetLoweringBase &TL, const DataLayout &DL,
             ScalarEvolution &SE)
       : F(F), TL(TL), DL(DL), SE(SE),
DEBUG(dbgs() << "[SafeStack] "
                << ", S: " << SE.getSignedRange(Expr) << "\n"
                << "            Range " << AccessRange << "\n"
                << "            AllocaRange " << AllocaRange << "\n"
                << "            " << (Safe ? "safe" : "unsafe") << "\n");
 
   return Safe;
 }
 
-bool SafeStack::IsMemIntrinsicSafe(const MemIntrinsic *MI, const Use &U,
+bool SafeStack::IsMemIntrinsicSafe(const PlainMemIntrinsic *MI, const Use &U,
                                    const Value *AllocaPtr,
                                    uint64_t AllocaSize) {
   // All MemIntrinsics have destination address in Arg0 and size in Arg2.
   if (MI->getRawDest() != U) return true;
   const auto *Len = dyn_cast<ConstantInt>(MI->getLength());
   // Non-constant size => unsafe. FIXME: try SCEV getRange.
   if (!Len) return false;
   return IsAccessSafe(U, Len->getZExtValue(), AllocaPtr, AllocaSize);
for (const Use &UI : V->uses()) {
         ImmutableCallSite CS(I);
 
         if (const IntrinsicInst *II = dyn_cast<IntrinsicInst>(I)) {
           if (II->getIntrinsicID() == Intrinsic::lifetime_start ||
               II->getIntrinsicID() == Intrinsic::lifetime_end)
             continue;
         }
 
-        if (const MemIntrinsic *MI = dyn_cast<MemIntrinsic>(I)) {
+        if (const PlainMemIntrinsic *MI = dyn_cast<PlainMemIntrinsic>(I)) {
           if (!IsMemIntrinsicSafe(MI, UI, AllocaPtr, AllocaSize)) {
             DEBUG(dbgs() << "[SafeStack] Unsafe alloca: " << *AllocaPtr
                          << "\n            unsafe memintrinsic: " << *I
                          << "\n");
             return false;
           }
           continue;
         }

lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

case Intrinsic::memmove: {
     bool isTC = I.isTailCall() && isInTailCallPosition(&I, DAG.getTarget());
     SDValue MM = DAG.getMemmove(getRoot(), sdl, Op1, Op2, Op3, Align, isVol,
                                 isTC, MachinePointerInfo(I.getArgOperand(0)),
                                 MachinePointerInfo(I.getArgOperand(1)));
     updateDAGForMaybeTailCall(MM);
     return nullptr;
   }
   case Intrinsic::memcpy_element_unordered_atomic: {
-    const ElementUnorderedAtomicMemCpyInst &MI =
-        cast<ElementUnorderedAtomicMemCpyInst>(I);
+    const AtomicMemCpyInst &MI =
+        cast<AtomicMemCpyInst>(I);
     SDValue Dst = getValue(MI.getRawDest());
     SDValue Src = getValue(MI.getRawSource());
     SDValue Length = getValue(MI.getLength());
 
     // Emit a library call.
     TargetLowering::ArgListTy Args;
     TargetLowering::ArgListEntry Entry;
     Entry.Ty = DAG.getDataLayout().getIntPtrType(*DAG.getContext());
CLI.setDebugLoc(sdl).setChain(getRoot()).setLibCallee(
                               TLI.getPointerTy(DAG.getDataLayout())),
         std::move(Args));
 
     std::pair<SDValue, SDValue> CallResult = TLI.LowerCallTo(CLI);
     DAG.setRoot(CallResult.second);
     return nullptr;
   }
   case Intrinsic::memmove_element_unordered_atomic: {
-    auto &MI = cast<ElementUnorderedAtomicMemMoveInst>(I);
+    auto &MI = cast<AtomicMemMoveInst>(I);
     SDValue Dst = getValue(MI.getRawDest());
     SDValue Src = getValue(MI.getRawSource());
     SDValue Length = getValue(MI.getLength());
 
     // Emit a library call.
     TargetLowering::ArgListTy Args;
     TargetLowering::ArgListEntry Entry;
     Entry.Ty = DAG.getDataLayout().getIntPtrType(*DAG.getContext());
CLI.setDebugLoc(sdl).setChain(getRoot()).setLibCallee(
                               TLI.getPointerTy(DAG.getDataLayout())),
         std::move(Args));
 
     std::pair<SDValue, SDValue> CallResult = TLI.LowerCallTo(CLI);
     DAG.setRoot(CallResult.second);
     return nullptr;
   }
   case Intrinsic::memset_element_unordered_atomic: {
-    auto &MI = cast<ElementUnorderedAtomicMemSetInst>(I);
+    auto &MI = cast<AtomicMemSetInst>(I);
     SDValue Dst = getValue(MI.getRawDest());
     SDValue Val = getValue(MI.getValue());
     SDValue Length = getValue(MI.getLength());
 
     // Emit a library call.
     TargetLowering::ArgListTy Args;
     TargetLowering::ArgListEntry Entry;
     Entry.Ty = DAG.getDataLayout().getIntPtrType(*DAG.getContext());

lib/IR/Verifier.cpp

case Intrinsic::memset: {
     Assert(AlignCI->isZero() || AlignVal.isPowerOf2(),
            "alignment argument of memory intrinsics must be a power of 2", CS);
     Assert(isa<ConstantInt>(CS.getArgOperand(4)),
            "isvolatile argument of memory intrinsics must be a constant int",
            CS);
     break;
   }
   case Intrinsic::memcpy_element_unordered_atomic: {
-    const ElementUnorderedAtomicMemCpyInst *MI =
-        cast<ElementUnorderedAtomicMemCpyInst>(CS.getInstruction());
+    const AtomicMemCpyInst *MI =
+        cast<AtomicMemCpyInst>(CS.getInstruction());
     ;
 
     ConstantInt *ElementSizeCI =
         dyn_cast<ConstantInt>(MI->getRawElementSizeInBytes());
     Assert(ElementSizeCI,
            "element size of the element-wise unordered atomic memory "
            "intrinsic must be a constant int",
            CS);
     const APInt &ElementSizeVal = ElementSizeCI->getValue();
uint64_t DstAlignment = CS.getParamAlignment(0),
              SrcAlignment = CS.getParamAlignment(1);
     Assert(IsValidAlignment(DstAlignment),
            "incorrect alignment of the destination argument", CS);
     Assert(IsValidAlignment(SrcAlignment),
            "incorrect alignment of the source argument", CS);
     break;
   }
   case Intrinsic::memmove_element_unordered_atomic: {
-    auto *MI = cast<ElementUnorderedAtomicMemMoveInst>(CS.getInstruction());
+    auto *MI = cast<AtomicMemMoveInst>(CS.getInstruction());
 
     ConstantInt *ElementSizeCI =
         dyn_cast<ConstantInt>(MI->getRawElementSizeInBytes());
     Assert(ElementSizeCI,
            "element size of the element-wise unordered atomic memory "
            "intrinsic must be a constant int",
            CS);
     const APInt &ElementSizeVal = ElementSizeCI->getValue();
uint64_t DstAlignment = CS.getParamAlignment(0),
              SrcAlignment = CS.getParamAlignment(1);
     Assert(IsValidAlignment(DstAlignment),
            "incorrect alignment of the destination argument", CS);
     Assert(IsValidAlignment(SrcAlignment),
            "incorrect alignment of the source argument", CS);
     break;
   }
   case Intrinsic::memset_element_unordered_atomic: {
-    auto *MI = cast<ElementUnorderedAtomicMemSetInst>(CS.getInstruction());
+    auto *MI = cast<AtomicMemSetInst>(CS.getInstruction());
 
     ConstantInt *ElementSizeCI =
         dyn_cast<ConstantInt>(MI->getRawElementSizeInBytes());
     Assert(ElementSizeCI,
            "element size of the element-wise unordered atomic memory "
            "intrinsic must be a constant int",
            CS);
     const APInt &ElementSizeVal = ElementSizeCI->getValue();

lib/Target/AArch64/AArch64FastISel.cpp

while (Depth--) {
       SrcReg = DestReg;
     }
 
     updateValueMap(II, SrcReg);
     return true;
   }
   case Intrinsic::memcpy:
   case Intrinsic::memmove: {
-    const auto *MTI = cast<MemTransferInst>(II);
+    const auto *MTI = cast<PlainMemTransferInst>(II);
     // Don't handle volatile.
     if (MTI->isVolatile())
       return false;
 
     // Disable inlining for memmove before calls to ComputeAddress.  Otherwise,
     // we would emit dead code because we don't currently handle memmoves.
     bool IsMemCpy = (II->getIntrinsicID() == Intrinsic::memcpy);
     if (isa<ConstantInt>(MTI->getLength()) && IsMemCpy) {
case Intrinsic::memmove: {
     if (!MTI->getLength()->getType()->isIntegerTy(64))
       return false;
 
     if (MTI->getSourceAddressSpace() > 255 || MTI->getDestAddressSpace() > 255)
       // Fast instruction selection doesn't support the special
       // address spaces.
       return false;
 
-    const char *IntrMemName = isa<MemCpyInst>(II) ? "memcpy" : "memmove";
+    const char *IntrMemName = isa<PlainMemCpyInst>(II) ? "memcpy" : "memmove";
     return lowerCallTo(II, IntrMemName, II->getNumArgOperands() - 2);
   }
   case Intrinsic::memset: {
-    const MemSetInst *MSI = cast<MemSetInst>(II);
+    const PlainMemSetInst *MSI = cast<PlainMemSetInst>(II);
     // Don't handle volatile.
     if (MSI->isVolatile())
       return false;
 
     if (!MSI->getLength()->getType()->isIntegerTy(64))
       return false;
 
     if (MSI->getDestAddressSpace() > 255)

lib/Target/AMDGPU/AMDGPULowerIntrinsics.cpp

bool AMDGPULowerIntrinsics::expandMemIntrinsicUses(Function &F) {
   bool Changed = false;
 
   for (auto I = F.user_begin(), E = F.user_end(); I != E;) {
     Instruction *Inst = cast<Instruction>(*I);
     ++I;
 
     switch (ID) {
     case Intrinsic::memcpy: {
-      auto *Memcpy = cast<MemCpyInst>(Inst);
+      auto *Memcpy = cast<PlainMemCpyInst>(Inst);
       if (shouldExpandOperationWithSize(Memcpy->getLength())) {
         Function *ParentFunc = Memcpy->getParent()->getParent();
         const TargetTransformInfo &TTI =
             getAnalysis<TargetTransformInfoWrapperPass>().getTTI(*ParentFunc);
         expandMemCpyAsLoop(Memcpy, TTI);
         Changed = true;
         Memcpy->eraseFromParent();
       }
 
       break;
     }
     case Intrinsic::memmove: {
-      auto *Memmove = cast<MemMoveInst>(Inst);
+      auto *Memmove = cast<PlainMemMoveInst>(Inst);
       if (shouldExpandOperationWithSize(Memmove->getLength())) {
         expandMemMoveAsLoop(Memmove);
         Changed = true;
         Memmove->eraseFromParent();
       }
 
       break;
     }
     case Intrinsic::memset: {
-      auto *Memset = cast<MemSetInst>(Inst);
+      auto *Memset = cast<PlainMemSetInst>(Inst);
       if (shouldExpandOperationWithSize(Memset->getLength())) {
         expandMemSetAsLoop(Memset);
         Changed = true;
         Memset->eraseFromParent();
       }
 
       break;
     }

lib/Target/AMDGPU/AMDGPUPromoteAlloca.cpp

for (Value *V : WorkList) {
     Builder.SetInsertPoint(Intr);
     switch (Intr->getIntrinsicID()) {
     case Intrinsic::lifetime_start:
     case Intrinsic::lifetime_end:
       // These intrinsics are for address space 0 only
       Intr->eraseFromParent();
       continue;
     case Intrinsic::memcpy: {
-      MemCpyInst *MemCpy = cast<MemCpyInst>(Intr);
+      PlainMemCpyInst *MemCpy = cast<PlainMemCpyInst>(Intr);
       Builder.CreateMemCpy(MemCpy->getRawDest(), MemCpy->getRawSource(),
                            MemCpy->getLength(), MemCpy->getAlignment(),
                            MemCpy->isVolatile());
       Intr->eraseFromParent();
       continue;
     }
     case Intrinsic::memmove: {
-      MemMoveInst *MemMove = cast<MemMoveInst>(Intr);
+      PlainMemMoveInst *MemMove = cast<PlainMemMoveInst>(Intr);
       Builder.CreateMemMove(MemMove->getRawDest(), MemMove->getRawSource(),
                             MemMove->getLength(), MemMove->getAlignment(),
                             MemMove->isVolatile());
       Intr->eraseFromParent();
       continue;
     }
     case Intrinsic::memset: {
-      MemSetInst *MemSet = cast<MemSetInst>(Intr);
+      PlainMemSetInst *MemSet = cast<PlainMemSetInst>(Intr);
       Builder.CreateMemSet(MemSet->getRawDest(), MemSet->getValue(),
                            MemSet->getLength(), MemSet->getAlignment(),
                            MemSet->isVolatile());
       Intr->eraseFromParent();
       continue;
     }
     case Intrinsic::invariant_start:
     case Intrinsic::invariant_end:

lib/Target/ARM/ARMFastISel.cpp

while (Depth--) {
                       .addReg(SrcReg).addImm(0));
       SrcReg = DestReg;
     }
     updateValueMap(&I, SrcReg);
     return true;
   }
   case Intrinsic::memcpy:
   case Intrinsic::memmove: {
-    const MemTransferInst &MTI = cast<MemTransferInst>(I);
+    const PlainMemTransferInst &MTI = cast<PlainMemTransferInst>(I);
     // Don't handle volatile.
     if (MTI.isVolatile())
       return false;
 
     // Disable inlining for memmove before calls to ComputeAddress.  Otherwise,
     // we would emit dead code because we don't currently handle memmoves.
     bool isMemCpy = (I.getIntrinsicID() == Intrinsic::memcpy);
     if (isa<ConstantInt>(MTI.getLength()) && isMemCpy) {
case Intrinsic::memmove: {
     }
 
     if (!MTI.getLength()->getType()->isIntegerTy(32))
       return false;
 
     if (MTI.getSourceAddressSpace() > 255 || MTI.getDestAddressSpace() > 255)
       return false;
 
-    const char *IntrMemName = isa<MemCpyInst>(I) ? "memcpy" : "memmove";
+    const char *IntrMemName = isa<PlainMemCpyInst>(I) ? "memcpy" : "memmove";
     return SelectCall(&I, IntrMemName);
   }
   case Intrinsic::memset: {
-    const MemSetInst &MSI = cast<MemSetInst>(I);
+    const PlainMemSetInst &MSI = cast<PlainMemSetInst>(I);
     // Don't handle volatile.
     if (MSI.isVolatile())
       return false;
 
     if (!MSI.getLength()->getType()->isIntegerTy(32))
       return false;
 
     if (MSI.getDestAddressSpace() > 255)

lib/Target/ARM/ARMISelLowering.cpp

const TargetRegisterClass *ARMTargetLowering::getRegClassFor(MVT VT) const {
   return TargetLowering::getRegClassFor(VT);
 }
 
 // memcpy, and other memory intrinsics, typically tries to use LDM/STM if the
 // source/dest is aligned and the copy size is large enough. We therefore want
 // to align such objects passed to memory intrinsics.
 bool ARMTargetLowering::shouldAlignPointerArgs(CallInst *CI, unsigned &MinSize,
                                                unsigned &PrefAlign) const {
-  if (!isa<MemIntrinsic>(CI))
+  if (!isa<PlainMemIntrinsic>(CI))
     return false;
   MinSize = 8;
   // On ARM11 onwards (excluding M class) 8-byte aligned LDM is typically 1
   // cycle faster than 4-byte aligned LDM.
   PrefAlign = (Subtarget->hasV6Ops() && !Subtarget->isMClass() ? 8 : 4);
   return true;
 }
 

lib/Target/Mips/MipsFastISel.cpp

if (VT == MVT::i16) {
         updateValueMap(II, DestReg);
         return true;
       }
     }
     return false;
   }
   case Intrinsic::memcpy:
   case Intrinsic::memmove: {
-    const auto *MTI = cast<MemTransferInst>(II);
+    const auto *MTI = cast<PlainMemTransferInst>(II);
     // Don't handle volatile.
     if (MTI->isVolatile())
       return false;
     if (!MTI->getLength()->getType()->isIntegerTy(32))
       return false;
-    const char *IntrMemName = isa<MemCpyInst>(II) ? "memcpy" : "memmove";
+    const char *IntrMemName = isa<PlainMemCpyInst>(II) ? "memcpy" : "memmove";
     return lowerCallTo(II, IntrMemName, II->getNumArgOperands() - 2);
   }
   case Intrinsic::memset: {
-    const MemSetInst *MSI = cast<MemSetInst>(II);
+    const PlainMemSetInst *MSI = cast<PlainMemSetInst>(II);
     // Don't handle volatile.
     if (MSI->isVolatile())
       return false;
     if (!MSI->getLength()->getType()->isIntegerTy(32))
       return false;
     return lowerCallTo(II, "memset", II->getNumArgOperands() - 2);
   }
   }

lib/Target/NVPTX/NVPTXLowerAggrCopies.cpp

StringRef getPassName() const override {
     return "Lower aggregate copies/intrinsics into loops";
   }
 };
 
 char NVPTXLowerAggrCopies::ID = 0;
 
 bool NVPTXLowerAggrCopies::runOnFunction(Function &F) {
   SmallVector<LoadInst *, 4> AggrLoads;
-  SmallVector<MemIntrinsic *, 4> MemCalls;
+  SmallVector<PlainMemIntrinsic *, 4> MemCalls;
 
   const DataLayout &DL = F.getParent()->getDataLayout();
   LLVMContext &Context = F.getParent()->getContext();
   const TargetTransformInfo &TTI =
       getAnalysis<TargetTransformInfoWrapperPass>().getTTI(F);
 
   // Collect all aggregate loads and mem* calls.
   for (Function::iterator BI = F.begin(), BE = F.end(); BI != BE; ++BI) {
     for (BasicBlock::iterator II = BI->begin(), IE = BI->end(); II != IE;
          ++II) {
       if (LoadInst *LI = dyn_cast<LoadInst>(II)) {
         if (!LI->hasOneUse())
           continue;
 
         if (DL.getTypeStoreSize(LI->getType()) < MaxAggrCopySize)
           continue;
 
         if (StoreInst *SI = dyn_cast<StoreInst>(LI->user_back())) {
           if (SI->getOperand(0) != LI)
             continue;
           AggrLoads.push_back(LI);
         }
-      } else if (MemIntrinsic *IntrCall = dyn_cast<MemIntrinsic>(II)) {
+      } else if (PlainMemIntrinsic *IntrCall = dyn_cast<PlainMemIntrinsic>(II)) {
         // Convert intrinsic calls with variable size or with constant size
         // larger than the MaxAggrCopySize threshold.
         if (ConstantInt *LenCI = dyn_cast<ConstantInt>(IntrCall->getLength())) {
           if (LenCI->getZExtValue() >= MaxAggrCopySize) {
             MemCalls.push_back(IntrCall);
           }
         } else {
           MemCalls.push_back(IntrCall);
if (!TTI.useWideIRMemcpyLoopLowering()) {
                                 /* DstIsVolatile */ SI->isVolatile(), TTI);
     }
 
     SI->eraseFromParent();
     LI->eraseFromParent();
   }
 
   // Transform mem* intrinsic calls.
-  for (MemIntrinsic *MemCall : MemCalls) {
-    if (MemCpyInst *Memcpy = dyn_cast<MemCpyInst>(MemCall)) {
+  for (PlainMemIntrinsic *MemCall : MemCalls) {
+    if (PlainMemCpyInst *Memcpy = dyn_cast<PlainMemCpyInst>(MemCall)) {
       expandMemCpyAsLoop(Memcpy, TTI);
-    } else if (MemMoveInst *Memmove = dyn_cast<MemMoveInst>(MemCall)) {
+    } else if (PlainMemMoveInst *Memmove = dyn_cast<PlainMemMoveInst>(MemCall)) {
       expandMemMoveAsLoop(Memmove);
-    } else if (MemSetInst *Memset = dyn_cast<MemSetInst>(MemCall)) {
+    } else if (PlainMemSetInst *Memset = dyn_cast<PlainMemSetInst>(MemCall)) {
       expandMemSetAsLoop(Memset);
     }
     MemCall->eraseFromParent();
   }
 
   return true;
 }
 

lib/Target/X86/X86FastISel.cpp

while (Depth--) {
                            TII.get(Opc), DestReg), SrcReg);
       SrcReg = DestReg;
     }
 
     updateValueMap(II, SrcReg);
     return true;
   }
   case Intrinsic::memcpy: {
-    const MemCpyInst *MCI = cast<MemCpyInst>(II);
+    const PlainMemCpyInst *MCI = cast<PlainMemCpyInst>(II);
     // Don't handle volatile or variable length memcpys.
     if (MCI->isVolatile())
       return false;
 
     if (isa<ConstantInt>(MCI->getLength())) {
       // Small memcpy's are common enough that we want to do them
       // without a call if possible.
       uint64_t Len = cast<ConstantInt>(MCI->getLength())->getZExtValue();
if (!MCI->getLength()->getType()->isIntegerTy(SizeWidth))
       return false;
 
     if (MCI->getSourceAddressSpace() > 255 || MCI->getDestAddressSpace() > 255)
       return false;
 
     return lowerCallTo(II, "memcpy", II->getNumArgOperands() - 2);
   }
   case Intrinsic::memset: {
-    const MemSetInst *MSI = cast<MemSetInst>(II);
+    const PlainMemSetInst *MSI = cast<PlainMemSetInst>(II);
 
     if (MSI->isVolatile())
       return false;
 
     unsigned SizeWidth = Subtarget->is64Bit() ? 64 : 32;
     if (!MSI->getLength()->getType()->isIntegerTy(SizeWidth))
       return false;
 

lib/Transforms/IPO/GlobalOpt.cpp

if (StoreInst *SI = dyn_cast<StoreInst>(U)) {
       Value *V = SI->getValueOperand();
       if (isa<Constant>(V)) {
         Changed = true;
         SI->eraseFromParent();
       } else if (Instruction *I = dyn_cast<Instruction>(V)) {
         if (I->hasOneUse())
           Dead.push_back(std::make_pair(I, SI));
       }
-    } else if (MemSetInst *MSI = dyn_cast<MemSetInst>(U)) {
+    } else if (PlainMemSetInst *MSI = dyn_cast<PlainMemSetInst>(U)) {
       if (isa<Constant>(MSI->getValue())) {
         Changed = true;
         MSI->eraseFromParent();
       } else if (Instruction *I = dyn_cast<Instruction>(MSI->getValue())) {
         if (I->hasOneUse())
           Dead.push_back(std::make_pair(I, MSI));
       }
-    } else if (MemTransferInst *MTI = dyn_cast<MemTransferInst>(U)) {
+    } else if (PlainMemTransferInst *MTI = dyn_cast<PlainMemTransferInst>(U)) {
       GlobalVariable *MemSrc = dyn_cast<GlobalVariable>(MTI->getSource());
       if (MemSrc && MemSrc->isConstant()) {
         Changed = true;
         MTI->eraseFromParent();
       } else if (Instruction *I = dyn_cast<Instruction>(MemSrc)) {
         if (I->hasOneUse())
           Dead.push_back(std::make_pair(I, MTI));
       }
if (LoadInst *LI = dyn_cast<LoadInst>(U)) {
           SubInit = Constant::getNullValue(GEP->getResultElementType());
       }
       Changed |= CleanupConstantGlobalUsers(GEP, SubInit, DL, TLI);
 
       if (GEP->use_empty()) {
         GEP->eraseFromParent();
         Changed = true;
       }
-    } else if (MemIntrinsic *MI = dyn_cast<MemIntrinsic>(U)) { // memset/cpy/mv
+    } else if (PlainMemIntrinsic *MI = dyn_cast<PlainMemIntrinsic>(U)) { // memset/cpy/mv
       if (MI->getRawDest() == V) {
         MI->eraseFromParent();
         Changed = true;
       }
 
     } else if (Constant *C = dyn_cast<Constant>(U)) {
       // If we have a chain of dead constantexprs or other things dangling from
       // us, and if they are all dead, nuke them without remorse.

lib/Transforms/InstCombine/InstCombineCalls.cpp

bool Sign = V->getElementType()->isIntegerTy()
                     ? cast<ConstantInt>(Elt)->isNegative()
                     : cast<ConstantFP>(Elt)->isNegative();
     BoolVec.push_back(ConstantInt::get(BoolTy, Sign));
   }
   return ConstantVector::get(BoolVec);
 }
 
 Instruction *InstCombiner::SimplifyElementUnorderedAtomicMemCpy(
-    ElementUnorderedAtomicMemCpyInst *AMI) {
+    AtomicMemCpyInst *AMI) {
   // Try to unfold this intrinsic into sequence of explicit atomic loads and
   // stores.
   // First check that number of elements is compile time constant.
   auto *LengthCI = dyn_cast<ConstantInt>(AMI->getLength());
   if (!LengthCI)
     return nullptr;
 
   // Check that there are not too many elements.
Instruction *InstCombiner::SimplifyElementUnorderedAtomicMemCpy(
   }
 
   // Set the number of elements of the copy to 0, it will be deleted on the
   // next iteration.
   AMI->setLength(Constant::getNullValue(LengthCI->getType()));
   return AMI;
 }
 
-Instruction *InstCombiner::SimplifyMemTransfer(MemIntrinsic *MI) {
+Instruction *InstCombiner::SimplifyMemTransfer(PlainMemIntrinsic *MI) {
   unsigned DstAlign = getKnownAlignment(MI->getArgOperand(0), DL, MI, &AC, &DT);
   unsigned SrcAlign = getKnownAlignment(MI->getArgOperand(1), DL, MI, &AC, &DT);
   unsigned MinAlign = std::min(DstAlign, SrcAlign);
   unsigned CopyAlign = MI->getAlignment();
 
   if (CopyAlign < MinAlign) {
     MI->setAlignment(ConstantInt::get(MI->getAlignmentType(), MinAlign, false));
     return MI;
   }
 
-  // If MemCpyInst length is 1/2/4/8 bytes then replace memcpy with
+  // If PlainMemCpyInst length is 1/2/4/8 bytes then replace memcpy with
   // load/store.
   ConstantInt *MemOpLength = dyn_cast<ConstantInt>(MI->getArgOperand(2));
   if (!MemOpLength) return nullptr;
 
   // Source and destination pointer types are always "i8*" for intrinsic.  See
   // if the size is something we can handle with a single primitive load/store.
   // A single load+store correctly handles overlapping memory in the memmove
   // case.
Instruction *InstCombiner::SimplifyMemTransfer(PlainMemIntrinsic *MI) {
   if (LoopMemParallelMD)
     S->setMetadata(LLVMContext::MD_mem_parallel_loop_access, LoopMemParallelMD);
 
   // Set the size of the copy to 0, it will be deleted on the next iteration.
   MI->setArgOperand(2, Constant::getNullValue(MemOpLength->getType()));
   return MI;
 }
 
-Instruction *InstCombiner::SimplifyMemSet(MemSetInst *MI) {
+Instruction *InstCombiner::SimplifyMemSet(PlainMemSetInst *MI) {
   unsigned Alignment = getKnownAlignment(MI->getDest(), DL, MI, &AC, &DT);
   if (MI->getAlignment() < Alignment) {
     MI->setAlignment(ConstantInt::get(MI->getAlignmentType(),
                                              Alignment, false));
     return MI;
   }
 
   // Extract the length and alignment and fill if they are constant.
if (CI.getFunction()->doesNotThrow() && !CI.doesNotThrow()) {
     return &CI;
   }
 
   IntrinsicInst *II = dyn_cast<IntrinsicInst>(&CI);
   if (!II) return visitCallSite(&CI);
 
   // Intrinsics cannot occur in an invoke, so handle them here instead of in
   // visitCallSite.
-  if (MemIntrinsic *MI = dyn_cast<MemIntrinsic>(II)) {
+  if (PlainMemIntrinsic *MI = dyn_cast<PlainMemIntrinsic>(II)) {
     bool Changed = false;
 
     // memmove/cpy/set of zero bytes is a noop.
     if (Constant *NumBytes = dyn_cast<Constant>(MI->getLength())) {
       if (NumBytes->isNullValue())
         return eraseInstFromFunction(CI);
 
       if (ConstantInt *CI = dyn_cast<ConstantInt>(NumBytes))
         if (CI->getZExtValue() == 1) {
           // Replace the instruction with just byte operations.  We would
           // transform other cases to loads/stores, but we don't know if
           // alignment is sufficient.
         }
     }
 
     // No other transformations apply to volatile transfers.
     if (MI->isVolatile())
       return nullptr;
 
     // If we have a memmove and the source operation is a constant global,
     // then the source and dest pointers can't alias, so we can change this
     // into a call to memcpy.
-    if (MemMoveInst *MMI = dyn_cast<MemMoveInst>(MI)) {
+    if (PlainMemMoveInst *MMI = dyn_cast<PlainMemMoveInst>(MI)) {
       if (GlobalVariable *GVSrc = dyn_cast<GlobalVariable>(MMI->getSource()))
         if (GVSrc->isConstant()) {
           Module *M = CI.getModule();
           Intrinsic::ID MemCpyID = Intrinsic::memcpy;
           Type *Tys[3] = { CI.getArgOperand(0)->getType(),
                            CI.getArgOperand(1)->getType(),
                            CI.getArgOperand(2)->getType() };
           CI.setCalledFunction(Intrinsic::getDeclaration(M, MemCpyID, Tys));
           Changed = true;
         }
     }
 
-    if (MemTransferInst *MTI = dyn_cast<MemTransferInst>(MI)) {
+    if (PlainMemTransferInst *MTI = dyn_cast<PlainMemTransferInst>(MI)) {
       // memmove(x,x,size) -> noop.
       if (MTI->getSource() == MTI->getDest())
         return eraseInstFromFunction(CI);
     }
 
     // If we can determine a pointer alignment that is bigger than currently
     // set, update the alignment.
-    if (isa<MemTransferInst>(MI)) {
+    if (isa<PlainMemTransferInst>(MI)) {
       if (Instruction *I = SimplifyMemTransfer(MI))
         return I;
-    } else if (MemSetInst *MSI = dyn_cast<MemSetInst>(MI)) {
+    } else if (PlainMemSetInst *MSI = dyn_cast<PlainMemSetInst>(MI)) {
       if (Instruction *I = SimplifyMemSet(MSI))
         return I;
     }
 
     if (Changed) return II;
   }
 
-  if (auto *AMI = dyn_cast<ElementUnorderedAtomicMemCpyInst>(II)) {
+  if (auto *AMI = dyn_cast<AtomicMemCpyInst>(II)) {
     if (Constant *C = dyn_cast<Constant>(AMI->getLength()))
       if (C->isNullValue())
         return eraseInstFromFunction(*AMI);
 
     if (Instruction *I = SimplifyElementUnorderedAtomicMemCpy(AMI))
       return I;
   }
 

lib/Transforms/InstCombine/InstCombineInternal.h

 
 #define DEBUG_TYPE "instcombine"
 
 namespace llvm {
 class CallSite;
 class DataLayout;
 class DominatorTree;
 class TargetLibraryInfo;
-class MemIntrinsic;
-class MemSetInst;
+class PlainMemIntrinsic;
+class PlainMemSetInst;
 class OptimizationRemarkEmitter;
 
 /// Assign a complexity or rank value to LLVM Values. This is used to reduce
 /// the amount of pattern matching needed for compares and commutative
 /// instructions. For example, if we have:
 ///   icmp ugt X, Constant
 /// or
 ///   xor (add X, Constant), cast Z
private:
 
   Value *insertRangeTest(Value *V, const APInt &Lo, const APInt &Hi,
                          bool isSigned, bool Inside);
   Instruction *PromoteCastOfAllocation(BitCastInst &CI, AllocaInst &AI);
   Instruction *MatchBSwap(BinaryOperator &I);
   bool SimplifyStoreAtEndOfBlock(StoreInst &SI);
 
   Instruction *
-  SimplifyElementUnorderedAtomicMemCpy(ElementUnorderedAtomicMemCpyInst *AMI);
-  Instruction *SimplifyMemTransfer(MemIntrinsic *MI);
-  Instruction *SimplifyMemSet(MemSetInst *MI);
+  SimplifyElementUnorderedAtomicMemCpy(AtomicMemCpyInst *AMI);
+  Instruction *SimplifyMemTransfer(PlainMemIntrinsic *MI);
+  Instruction *SimplifyMemSet(PlainMemSetInst *MI);
 
   Value *EvaluateInDifferentType(Value *V, Type *Ty, bool isSigned);
 
   /// \brief Returns a value X such that Val = X * Scale, or null if none.
   ///
   /// If the multiplication is known not to overflow then NoSignedWrap is set.
   Value *Descale(Value *Val, APInt Scale, bool &NoSignedWrap);
 };
 
 } // end namespace llvm.
 
 #undef DEBUG_TYPE
 
 #endif

lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp

 /// isOnlyCopiedFromConstantGlobal - Recursively walk the uses of a (derived)
 /// pointer to an alloca.  Ignore any reads of the pointer, return false if we
 /// see any stores or other unknown uses.  If we see pointer arithmetic, keep
 /// track of whether it moves the pointer (with IsOffset) but otherwise traverse
 /// the uses.  If we see a memcpy/memmove that targets an unoffseted pointer to
 /// the alloca, and if the source pointer is a pointer to a constant global, we
 /// can optimize this.
 static bool
-isOnlyCopiedFromConstantGlobal(Value *V, MemTransferInst *&TheCopy,
+isOnlyCopiedFromConstantGlobal(Value *V, PlainMemTransferInst *&TheCopy,
                                SmallVectorImpl<Instruction *> &ToDelete) {
   // We track lifetime intrinsics as we encounter them.  If we decide to go
   // ahead and replace the value with the global, this lets the caller quickly
   // eliminate the markers.
 
   SmallVector<std::pair<Value *, bool>, 35> ValuesToInspect;
   ValuesToInspect.emplace_back(V, false);
   while (!ValuesToInspect.empty()) {
for (auto &U : ValuePair.first->uses()) {
           assert(II->use_empty() && "Lifetime markers have no result to use!");
           ToDelete.push_back(II);
           continue;
         }
       }
 
       // If this is isn't our memcpy/memmove, reject it as something we can't
       // handle.
-      MemTransferInst *MI = dyn_cast<MemTransferInst>(I);
+      PlainMemTransferInst *MI = dyn_cast<PlainMemTransferInst>(I);
       if (!MI)
         return false;
 
       // If the transfer is using the alloca as a source of the transfer, then
       // ignore it since it is a load (unless the transfer is volatile).
       if (U.getOperandNo() == 1) {
         if (MI->isVolatile()) return false;
         continue;
while (!ValuesToInspect.empty()) {
     }
   }
   return true;
 }
 
 /// isOnlyCopiedFromConstantGlobal - Return true if the specified alloca is only
 /// modified by a copy from a constant global.  If we can prove this, we can
 /// replace any uses of the alloca with uses of the global directly.
-static MemTransferInst *
+static PlainMemTransferInst *
 isOnlyCopiedFromConstantGlobal(AllocaInst *AI,
                                SmallVectorImpl<Instruction *> &ToDelete) {
-  MemTransferInst *TheCopy = nullptr;
+  PlainMemTransferInst *TheCopy = nullptr;
   if (isOnlyCopiedFromConstantGlobal(AI, TheCopy, ToDelete))
     return TheCopy;
   return nullptr;
 }
 
 /// Returns true if V is dereferenceable for size of alloca.
 static bool isDereferenceableForAllocaSize(const Value *V, const AllocaInst *AI,
                                            const DataLayout &DL) {
Instruction *InstCombiner::visitAllocaInst(AllocaInst &AI) {
   if (AI.getAlignment()) {
     // Check to see if this allocation is only modified by a memcpy/memmove from
     // a constant global whose alignment is equal to or exceeds that of the
     // allocation.  If this is the case, we can change all users to use
     // the constant global instead.  This is commonly produced by the CFE by
     // constructs like "void foo() { int A[] = {1,2,3,4,5,6,7,8,9...}; }" if 'A'
     // is only subsequently read.
     SmallVector<Instruction *, 4> ToDelete;
-    if (MemTransferInst *Copy = isOnlyCopiedFromConstantGlobal(&AI, ToDelete)) {
+    if (PlainMemTransferInst *Copy = isOnlyCopiedFromConstantGlobal(&AI, ToDelete)) {
       unsigned SourceAlign = getOrEnforceKnownAlignment(
           Copy->getSource(), AI.getAlignment(), DL, &AI, &AC, &DT);
       if (AI.getAlignment() <= SourceAlign &&
           isDereferenceableForAllocaSize(Copy->getSource(), &AI, DL)) {
         DEBUG(dbgs() << "Found alloca equal to global: " << AI << '\n');
         DEBUG(dbgs() << "  memcpy = " << *Copy << '\n');
         for (unsigned i = 0, e = ToDelete.size(); i != e; ++i)
           eraseInstFromFunction(*ToDelete[i]);

lib/Transforms/InstCombine/InstructionCombining.cpp

for (User *U : PI->users()) {
         if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(I)) {
           switch (II->getIntrinsicID()) {
           default:
             return false;
 
           case Intrinsic::memmove:
           case Intrinsic::memcpy:
           case Intrinsic::memset: {
-            MemIntrinsic *MI = cast<MemIntrinsic>(II);
+            PlainMemIntrinsic *MI = cast<PlainMemIntrinsic>(II);
             if (MI->isVolatile() || MI->getRawDest() != PI)
               return false;
             LLVM_FALLTHROUGH;
           }
           case Intrinsic::invariant_start:
           case Intrinsic::invariant_end:
           case Intrinsic::lifetime_start:
           case Intrinsic::lifetime_end:

lib/Transforms/Instrumentation/AddressSanitizer.cpp

void instrumentUnusualSizeOrAlignment(Instruction *I,
                                         uint32_t TypeSize, bool IsWrite,
                                         Value *SizeArgument, bool UseCalls,
                                         uint32_t Exp);
   Value *createSlowPathCmp(IRBuilder<> &IRB, Value *AddrLong,
                            Value *ShadowValue, uint32_t TypeSize);
   Instruction *generateCrashCode(Instruction *InsertBefore, Value *Addr,
                                  bool IsWrite, size_t AccessSizeIndex,
                                  Value *SizeArgument, uint32_t Exp);
-  void instrumentMemIntrinsic(MemIntrinsic *MI);
+  void instrumentMemIntrinsic(PlainMemIntrinsic *MI);
   Value *memToShadow(Value *Shadow, IRBuilder<> &IRB);
   bool runOnFunction(Function &F) override;
   bool maybeInsertAsanInitAtFunctionEntry(Function &F);
   void maybeInsertDynamicShadowAtFunctionEntry(Function &F);
   void markEscapedLocalAllocas(Function &F);
   bool doInitialization(Module &M) override;
   bool doFinalization(Module &M) override;
   static char ID;  // Pass identification, replacement for typeid
else
     ShadowBase = ConstantInt::get(IntptrTy, Mapping.Offset);
   if (Mapping.OrShadowOffset)
     return IRB.CreateOr(Shadow, ShadowBase);
   else
     return IRB.CreateAdd(Shadow, ShadowBase);
 }
 
 // Instrument memset/memmove/memcpy
-void AddressSanitizer::instrumentMemIntrinsic(MemIntrinsic *MI) {
+void AddressSanitizer::instrumentMemIntrinsic(PlainMemIntrinsic *MI) {
   IRBuilder<> IRB(MI);
-  if (isa<MemTransferInst>(MI)) {
+  if (isa<PlainMemTransferInst>(MI)) {
     IRB.CreateCall(
-        isa<MemMoveInst>(MI) ? AsanMemmove : AsanMemcpy,
+        isa<PlainMemMoveInst>(MI) ? AsanMemmove : AsanMemcpy,
         {IRB.CreatePointerCast(MI->getOperand(0), IRB.getInt8PtrTy()),
          IRB.CreatePointerCast(MI->getOperand(1), IRB.getInt8PtrTy()),
          IRB.CreateIntCast(MI->getOperand(2), IntptrTy, false)});
-  } else if (isa<MemSetInst>(MI)) {
+  } else if (isa<PlainMemSetInst>(MI)) {
     IRB.CreateCall(
         AsanMemset,
         {IRB.CreatePointerCast(MI->getOperand(0), IRB.getInt8PtrTy()),
          IRB.CreateIntCast(MI->getOperand(1), IRB.getInt32Ty(), false),
          IRB.CreateIntCast(MI->getOperand(2), IntptrTy, false)});
   }
   MI->eraseFromParent();
 }
for (auto &Inst : BB) {
             if (!TempsToInstrument.insert(Addr).second)
               continue; // We've seen this temp in the current BB.
           }
         }
       } else if (ClInvalidPointerPairs &&
                  isInterestingPointerComparisonOrSubtraction(&Inst)) {
         PointerComparisonsOrSubtracts.push_back(&Inst);
         continue;
-      } else if (isa<MemIntrinsic>(Inst)) {
+      } else if (isa<PlainMemIntrinsic>(Inst)) {
         // ok, take it.
       } else {
         if (isa<AllocaInst>(Inst)) NumAllocas++;
         CallSite CS(&Inst);
         if (CS) {
           // A call inside BB.
           TempsToInstrument.clear();
           if (CS.doesNotReturn()) NoReturnCalls.push_back(CS.getInstruction());
bool AddressSanitizer::runOnFunction(Function &F) {
   int NumInstrumented = 0;
   for (auto Inst : ToInstrument) {
     if (ClDebugMin < 0 || ClDebugMax < 0 ||
         (NumInstrumented >= ClDebugMin && NumInstrumented <= ClDebugMax)) {
       if (isInterestingMemoryAccess(Inst, &IsWrite, &TypeSize, &Alignment))
         instrumentMop(ObjSizeVis, Inst, UseCalls,
                       F.getParent()->getDataLayout());
       else
-        instrumentMemIntrinsic(cast<MemIntrinsic>(Inst));
+        instrumentMemIntrinsic(cast<PlainMemIntrinsic>(Inst));
     }
     NumInstrumented++;
   }
 
   FunctionStackPoisoner FSP(F, *this);
   bool ChangedStack = FSP.runOnFunction();
 
   // We must unpoison the stack before every NoReturn call (throw, _exit, etc).

lib/Transforms/Instrumentation/DataFlowSanitizer.cpp

public:
   void visitPHINode(PHINode &PN);
   void visitExtractElementInst(ExtractElementInst &I);
   void visitInsertElementInst(InsertElementInst &I);
   void visitShuffleVectorInst(ShuffleVectorInst &I);
   void visitExtractValueInst(ExtractValueInst &I);
   void visitInsertValueInst(InsertValueInst &I);
   void visitAllocaInst(AllocaInst &I);
   void visitSelectInst(SelectInst &I);
-  void visitMemSetInst(MemSetInst &I);
-  void visitMemTransferInst(MemTransferInst &I);
+  void visitPlainMemSetInst(PlainMemSetInst &I);
+  void visitPlainMemTransferInst(PlainMemTransferInst &I);
 };
 
 }
 
 char DataFlowSanitizer::ID;
 INITIALIZE_PASS(DataFlowSanitizer, "dfsan",
                 "DataFlowSanitizer: dynamic data flow analysis.", false, false)
 
if (isa<VectorType>(I.getCondition()->getType())) {
     } else {
       ShadowSel =
           SelectInst::Create(I.getCondition(), TrueShadow, FalseShadow, "", &I);
     }
     DFSF.setShadow(&I, DFSF.combineShadows(CondShadow, ShadowSel, &I));
   }
 }
 
-void DFSanVisitor::visitMemSetInst(MemSetInst &I) {
+void DFSanVisitor::visitPlainMemSetInst(PlainMemSetInst &I) {
   IRBuilder<> IRB(&I);
   Value *ValShadow = DFSF.getShadow(I.getValue());
   IRB.CreateCall(DFSF.DFS.DFSanSetLabelFn,
                  {ValShadow, IRB.CreateBitCast(I.getDest(), Type::getInt8PtrTy(
                                                                 *DFSF.DFS.Ctx)),
                   IRB.CreateZExtOrTrunc(I.getLength(), DFSF.DFS.IntptrTy)});
 }
 
-void DFSanVisitor::visitMemTransferInst(MemTransferInst &I) {
+void DFSanVisitor::visitPlainMemTransferInst(PlainMemTransferInst &I) {
   IRBuilder<> IRB(&I);
   Value *DestShadow = DFSF.DFS.getShadowAddress(I.getDest(), &I);
   Value *SrcShadow = DFSF.DFS.getShadowAddress(I.getSource(), &I);
   Value *LenShadow = IRB.CreateMul(
       I.getLength(),
       ConstantInt::get(I.getLength()->getType(), DFSF.DFS.ShadowWidth / 8));
   Value *AlignShadow;
   if (ClPreserveAlignment) {

lib/Transforms/Instrumentation/EfficiencySanitizer.cpp

void createCacheFragAuxGV(
     Module &M, const DataLayout &DL, StructType *StructTy,
     GlobalVariable *&TypeNames, GlobalVariable *&Offsets, GlobalVariable *&Size);
   GlobalVariable *createCacheFragInfoGV(Module &M, const DataLayout &DL,
                                         Constant *UnitName);
   Constant *createEsanInitToolInfoArg(Module &M, const DataLayout &DL);
   void createDestructor(Module &M, Constant *ToolInfoArg);
   bool runOnFunction(Function &F, Module &M);
   bool instrumentLoadOrStore(Instruction *I, const DataLayout &DL);
-  bool instrumentMemIntrinsic(MemIntrinsic *MI);
+  bool instrumentMemIntrinsic(PlainMemIntrinsic *MI);
   bool instrumentGetElementPtr(Instruction *I, Module &M);
   bool insertCounterUpdate(Instruction *I, StructType *StructTy,
                            unsigned CounterIdx);
   unsigned getFieldCounterIdx(StructType *StructTy) {
     return 0;
   }
   unsigned getArrayCounterIdx(StructType *StructTy) {
     return StructTy->getNumElements();
const TargetLibraryInfo *TLI =
       &getAnalysis<TargetLibraryInfoWrapperPass>().getTLI();
 
   for (auto &BB : F) {
     for (auto &Inst : BB) {
       if ((isa<LoadInst>(Inst) || isa<StoreInst>(Inst) ||
            isa<AtomicRMWInst>(Inst) || isa<AtomicCmpXchgInst>(Inst)) &&
           !shouldIgnoreMemoryAccess(&Inst))
         LoadsAndStores.push_back(&Inst);
-      else if (isa<MemIntrinsic>(Inst))
+      else if (isa<PlainMemIntrinsic>(Inst))
         MemIntrinCalls.push_back(&Inst);
       else if (isa<GetElementPtrInst>(Inst))
         GetElementPtrs.push_back(&Inst);
       else if (CallInst *CI = dyn_cast<CallInst>(&Inst))
         maybeMarkSanitizerLibraryCallNoBuiltin(CI, TLI);
     }
   }
 
   if (ClInstrumentLoadsAndStores) {
     for (auto Inst : LoadsAndStores) {
       Res |= instrumentLoadOrStore(Inst, DL);
     }
   }
 
   if (ClInstrumentMemIntrinsics) {
     for (auto Inst : MemIntrinCalls) {
-      Res |= instrumentMemIntrinsic(cast<MemIntrinsic>(Inst));
+      Res |= instrumentMemIntrinsic(cast<PlainMemIntrinsic>(Inst));
     }
   }
 
   if (Options.ToolType == EfficiencySanitizerOptions::ESAN_CacheFrag) {
     for (auto Inst : GetElementPtrs) {
       Res |= instrumentGetElementPtr(Inst, M);
     }
   }
IRB.CreateCall(OnAccessFunc,
                    IRB.CreatePointerCast(Addr, IRB.getInt8PtrTy()));
   }
   return true;
 }
 
 // It's simplest to replace the memset/memmove/memcpy intrinsics with
 // calls that the runtime library intercepts.
 // Our pass is late enough that calls should not turn back into intrinsics.
-bool EfficiencySanitizer::instrumentMemIntrinsic(MemIntrinsic *MI) {
+bool EfficiencySanitizer::instrumentMemIntrinsic(PlainMemIntrinsic *MI) {
   IRBuilder<> IRB(MI);
   bool Res = false;
-  if (isa<MemSetInst>(MI)) {
+  if (isa<PlainMemSetInst>(MI)) {
     IRB.CreateCall(
         MemsetFn,
         {IRB.CreatePointerCast(MI->getArgOperand(0), IRB.getInt8PtrTy()),
          IRB.CreateIntCast(MI->getArgOperand(1), IRB.getInt32Ty(), false),
          IRB.CreateIntCast(MI->getArgOperand(2), IntptrTy, false)});
     MI->eraseFromParent();
     Res = true;
-  } else if (isa<MemTransferInst>(MI)) {
+  } else if (isa<PlainMemTransferInst>(MI)) {
     IRB.CreateCall(
-        isa<MemCpyInst>(MI) ? MemcpyFn : MemmoveFn,
+        isa<PlainMemCpyInst>(MI) ? MemcpyFn : MemmoveFn,
         {IRB.CreatePointerCast(MI->getArgOperand(0), IRB.getInt8PtrTy()),
          IRB.CreatePointerCast(MI->getArgOperand(1), IRB.getInt8PtrTy()),
          IRB.CreateIntCast(MI->getArgOperand(2), IntptrTy, false)});
     MI->eraseFromParent();
     Res = true;
   } else
     llvm_unreachable("Unsupported mem intrinsic type");
   return Res;

lib/Transforms/Instrumentation/MemorySanitizer.cpp

#endif
   /// At this point we don't know if llvm.memmove will be inlined or not.
   /// If we don't instrument it and it gets inlined,
   /// our interceptor will not kick in and we will lose the memmove.
   /// If we instrument the call here, but it does not get inlined,
   /// we will memove the shadow twice: which is bad in case
   /// of overlapping regions. So, we simply lower the intrinsic to a call.
   ///
   /// Similar situation exists for memcpy and memset.
-  void visitMemMoveInst(MemMoveInst &I) {
+  void visitPlainMemMoveInst(PlainMemMoveInst &I) {
     IRBuilder<> IRB(&I);
     IRB.CreateCall(
         MS.MemmoveFn,
         {IRB.CreatePointerCast(I.getArgOperand(0), IRB.getInt8PtrTy()),
          IRB.CreatePointerCast(I.getArgOperand(1), IRB.getInt8PtrTy()),
          IRB.CreateIntCast(I.getArgOperand(2), MS.IntptrTy, false)});
     I.eraseFromParent();
   }
 
   // Similar to memmove: avoid copying shadow twice.
   // This is somewhat unfortunate as it may slowdown small constant memcpys.
   // FIXME: consider doing manual inline for small constant sizes and proper
   // alignment.
-  void visitMemCpyInst(MemCpyInst &I) {
+  void visitPlainMemCpyInst(PlainMemCpyInst &I) {
     IRBuilder<> IRB(&I);
     IRB.CreateCall(
         MS.MemcpyFn,
         {IRB.CreatePointerCast(I.getArgOperand(0), IRB.getInt8PtrTy()),
          IRB.CreatePointerCast(I.getArgOperand(1), IRB.getInt8PtrTy()),
          IRB.CreateIntCast(I.getArgOperand(2), MS.IntptrTy, false)});
     I.eraseFromParent();
   }
 
   // Same as memcpy.
-  void visitMemSetInst(MemSetInst &I) {
+  void visitPlainMemSetInst(PlainMemSetInst &I) {
     IRBuilder<> IRB(&I);
     IRB.CreateCall(
         MS.MemsetFn,
         {IRB.CreatePointerCast(I.getArgOperand(0), IRB.getInt8PtrTy()),
          IRB.CreateIntCast(I.getArgOperand(1), IRB.getInt32Ty(), false),
          IRB.CreateIntCast(I.getArgOperand(2), MS.IntptrTy, false)});
     I.eraseFromParent();
   }

lib/Transforms/Instrumentation/PGOInstrumentation.cpp

struct MemIntrinsicVisitor : public InstVisitor<MemIntrinsicVisitor> {
   std::vector<Instruction *> findMemIntrinsics(Function &Func) {
     Candidates.clear();
     Mode = VM_annotate;
     visit(Func);
     return Candidates;
   }
 
   // Visit the IR stream and annotate all mem intrinsic call instructions.
-  void instrumentOneMemIntrinsic(MemIntrinsic &MI);
+  void instrumentOneMemIntrinsic(PlainMemIntrinsic &MI);
   // Visit \p MI instruction and perform tasks according to visit mode.
-  void visitMemIntrinsic(MemIntrinsic &SI);
+  void visitPlainMemIntrinsic(PlainMemIntrinsic &SI);
   unsigned getNumOfMemIntrinsics() const { return NMemIs; }
 };
 
 class PGOInstrumentationGenLegacyPass : public ModulePass {
 public:
   static char ID;
 
   PGOInstrumentationGenLegacyPass() : ModulePass(ID) {
void SelectInstVisitor::visitSelectInst(SelectInst &SI) {
   case VM_annotate:
     annotateOneSelectInst(SI);
     return;
   }
 
   llvm_unreachable("Unknown visiting mode");
 }
 
-void MemIntrinsicVisitor::instrumentOneMemIntrinsic(MemIntrinsic &MI) {
+void MemIntrinsicVisitor::instrumentOneMemIntrinsic(PlainMemIntrinsic &MI) {
   Module *M = F.getParent();
   IRBuilder<> Builder(&MI);
   Type *Int64Ty = Builder.getInt64Ty();
   Type *I8PtrTy = Builder.getInt8PtrTy();
   Value *Length = MI.getLength();
   assert(!dyn_cast<ConstantInt>(Length));
   Builder.CreateCall(
       Intrinsic::getDeclaration(M, Intrinsic::instrprof_value_profile),
       {llvm::ConstantExpr::getBitCast(FuncNameVar, I8PtrTy),
        Builder.getInt64(FuncHash), Builder.CreateZExtOrTrunc(Length, Int64Ty),
        Builder.getInt32(IPVK_MemOPSize), Builder.getInt32(CurCtrId)});
   ++CurCtrId;
 }
 
-void MemIntrinsicVisitor::visitMemIntrinsic(MemIntrinsic &MI) {
+void MemIntrinsicVisitor::visitPlainMemIntrinsic(PlainMemIntrinsic &MI) {
   if (!PGOInstrMemOP)
     return;
   Value *Length = MI.getLength();
   // Not instrument constant length calls.
   if (dyn_cast<ConstantInt>(Length))
     return;
 
   switch (Mode) {

lib/Transforms/Instrumentation/PGOMemOPSizeOpt.cpp

for (auto &MI : WorkList) {
         Changed = true;
         ++NumOfPGOMemOPOpt;
         DEBUG(dbgs() << "MemOP call: " << MI->getCalledFunction()->getName()
                      << "is Transformed.\n");
       }
     }
   }
 
-  void visitMemIntrinsic(MemIntrinsic &MI) {
+  void visitPlainMemIntrinsic(PlainMemIntrinsic &MI) {
     Value *Length = MI.getLength();
     // Not perform on constant length calls.
     if (dyn_cast<ConstantInt>(Length))
       return;
     WorkList.push_back(&MI);
   }
 
 private:
   Function &Func;
   BlockFrequencyInfo &BFI;
   OptimizationRemarkEmitter &ORE;
   bool Changed;
-  std::vector<MemIntrinsic *> WorkList;
+  std::vector<PlainMemIntrinsic *> WorkList;
   // Start of the previse range.
   int64_t PreciseRangeStart;
   // Last value of the previse range.
   int64_t PreciseRangeLast;
   // The space to read the profile annotation.
   std::unique_ptr<InstrProfValueData[]> ValueDataArray;
-  bool perform(MemIntrinsic *MI);
+  bool perform(PlainMemIntrinsic *MI);
 
   // This kind shows which group the value falls in. For PreciseValue, we have
   // the profile count for that value. LargeGroup groups the values that are in
   // range [LargeValue, +inf). NonLargeGroup groups the rest of values.
   enum MemOPSizeKind { PreciseValue, NonLargeGroup, LargeGroup };
 
   MemOPSizeKind getMemOPSizeKind(int64_t Value) const {
     if (Value == MemOPSizeLarge && MemOPSizeLarge != 0)
       return LargeGroup;
     if (Value == PreciseRangeLast + 1)
       return NonLargeGroup;
     return PreciseValue;
   }
 };
 
-static const char *getMIName(const MemIntrinsic *MI) {
+static const char *getMIName(const PlainMemIntrinsic *MI) {
   switch (MI->getIntrinsicID()) {
   case Intrinsic::memcpy:
     return "memcpy";
   case Intrinsic::memmove:
     return "memmove";
   case Intrinsic::memset:
     return "memset";
   default:
static inline uint64_t getScaledCount(uint64_t Count, uint64_t Num,
                                       uint64_t Denom) {
   if (!MemOPScaleCount)
     return Count;
   bool Overflowed;
   uint64_t ScaleCount = SaturatingMultiply(Count, Num, &Overflowed);
   return ScaleCount / Denom;
 }
 
-bool MemOPSizeOpt::perform(MemIntrinsic *MI) {
+bool MemOPSizeOpt::perform(PlainMemIntrinsic *MI) {
   assert(MI);
   if (MI->getIntrinsicID() == Intrinsic::memmove)
     return false;
 
   uint32_t NumVals, MaxNumPromotions = MemOPMaxVersion + 2;
   uint64_t TotalCount;
   if (!getValueProfDataFromInst(*MI, IPVK_MemOPSize, MaxNumPromotions,
                                 ValueDataArray.get(), NumVals, TotalCount))
bool MemOPSizeOpt::perform(PlainMemIntrinsic *MI) {
 
   DEBUG(dbgs() << "\n\n== Basic Block After==\n");
 
   for (uint64_t SizeId : SizeIds) {
     BasicBlock *CaseBB = BasicBlock::Create(
         Ctx, Twine("MemOP.Case.") + Twine(SizeId), &Func, DefaultBB);
     Instruction *NewInst = MI->clone();
     // Fix the argument.
-    MemIntrinsic * MemI = dyn_cast<MemIntrinsic>(NewInst);
+    PlainMemIntrinsic * MemI = dyn_cast<PlainMemIntrinsic>(NewInst);
     IntegerType *SizeType = dyn_cast<IntegerType>(MemI->getLength()->getType());
     assert(SizeType && "Expected integer type size argument.");
     ConstantInt *CaseSizeId = ConstantInt::get(SizeType, SizeId);
     MemI->setLength(CaseSizeId);
     CaseBB->getInstList().push_back(NewInst);
     IRBuilder<> IRBCase(CaseBB);
     IRBCase.CreateBr(MergeBB);
     SI->addCase(CaseSizeId, CaseBB);

lib/Transforms/Instrumentation/ThreadSanitizer.cpp

for (auto &BB : F) {
     for (auto &Inst : BB) {
       if (isAtomic(&Inst))
         AtomicAccesses.push_back(&Inst);
       else if (isa<LoadInst>(Inst) || isa<StoreInst>(Inst))
         LocalLoadsAndStores.push_back(&Inst);
       else if (isa<CallInst>(Inst) || isa<InvokeInst>(Inst)) {
         if (CallInst *CI = dyn_cast<CallInst>(&Inst))
           maybeMarkSanitizerLibraryCallNoBuiltin(CI, TLI);
-        if (isa<MemIntrinsic>(Inst))
+        if (isa<PlainMemIntrinsic>(Inst))
           MemIntrinCalls.push_back(&Inst);
         HasCalls = true;
         chooseInstructionsToInstrument(LocalLoadsAndStores, AllLoadsAndStores,
                                        DL);
       }
     }
     chooseInstructionsToInstrument(LocalLoadsAndStores, AllLoadsAndStores, DL);
   }

 // We do not instrument memset/memmove/memcpy intrinsics (too complicated),
 // instead we simply replace them with regular function calls, which are then
 // intercepted by the run-time.
 // Since tsan is running after everyone else, the calls should not be
 // replaced back with intrinsics. If that becomes wrong at some point,
 // we will need to call e.g. __tsan_memset to avoid the intrinsics.
 bool ThreadSanitizer::instrumentMemIntrinsic(Instruction *I) {
   IRBuilder<> IRB(I);
-  if (MemSetInst *M = dyn_cast<MemSetInst>(I)) {
+  if (PlainMemSetInst *M = dyn_cast<PlainMemSetInst>(I)) {
     IRB.CreateCall(
         MemsetFn,
         {IRB.CreatePointerCast(M->getArgOperand(0), IRB.getInt8PtrTy()),
          IRB.CreateIntCast(M->getArgOperand(1), IRB.getInt32Ty(), false),
          IRB.CreateIntCast(M->getArgOperand(2), IntptrTy, false)});
     I->eraseFromParent();
-  } else if (MemTransferInst *M = dyn_cast<MemTransferInst>(I)) {
+  } else if (PlainMemTransferInst *M = dyn_cast<PlainMemTransferInst>(I)) {
     IRB.CreateCall(
-        isa<MemCpyInst>(M) ? MemcpyFn : MemmoveFn,
+        isa<PlainMemCpyInst>(M) ? MemcpyFn : MemmoveFn,
         {IRB.CreatePointerCast(M->getArgOperand(0), IRB.getInt8PtrTy()),
          IRB.CreatePointerCast(M->getArgOperand(1), IRB.getInt8PtrTy()),
          IRB.CreateIntCast(M->getArgOperand(2), IntptrTy, false)});
     I->eraseFromParent();
   }
   return false;
 }
 

lib/Transforms/Scalar/AlignmentFromAssumptions.cpp

while (!WorkList.empty()) {
     } else if (StoreInst *SI = dyn_cast<StoreInst>(J)) {
       unsigned NewAlignment = getNewAlignment(AASCEV, AlignSCEV, OffSCEV,
         SI->getPointerOperand(), SE);
 
       if (NewAlignment > SI->getAlignment()) {
         SI->setAlignment(NewAlignment);
         ++NumStoreAlignChanged;
       }
-    } else if (MemIntrinsic *MI = dyn_cast<MemIntrinsic>(J)) {
+    } else if (PlainMemIntrinsic *MI = dyn_cast<PlainMemIntrinsic>(J)) {
       unsigned NewDestAlignment = getNewAlignment(AASCEV, AlignSCEV, OffSCEV,
         MI->getDest(), SE);
 
       // For memory transfers, we need a common alignment for both the
       // source and destination. If we have a new alignment for this
       // instruction, but only for one operand, save it. If we reach the
       // other operand through another assumption later, then we may
       // change the alignment at that point.
-      if (MemTransferInst *MTI = dyn_cast<MemTransferInst>(MI)) {
+      if (PlainMemTransferInst *MTI = dyn_cast<PlainMemTransferInst>(MI)) {
         unsigned NewSrcAlignment = getNewAlignment(AASCEV, AlignSCEV, OffSCEV,
           MTI->getSource(), SE);
 
-        DenseMap<MemTransferInst *, unsigned>::iterator DI =
+        DenseMap<PlainMemTransferInst *, unsigned>::iterator DI =
           NewDestAlignments.find(MTI);
         unsigned AltDestAlignment = (DI == NewDestAlignments.end()) ?
                                     0 : DI->second;
 
-        DenseMap<MemTransferInst *, unsigned>::iterator SI =
+        DenseMap<PlainMemTransferInst *, unsigned>::iterator SI =
           NewSrcAlignments.find(MTI);
         unsigned AltSrcAlignment = (SI == NewSrcAlignments.end()) ?
                                    0 : SI->second;
 
         DEBUG(dbgs() << "\tmem trans: " << NewDestAlignment << " " <<
                         AltDestAlignment << " " << NewSrcAlignment <<
                         " " << AltSrcAlignment << "\n");
 
if (LoadInst *LI = dyn_cast<LoadInst>(J)) {
           MI->setAlignment(ConstantInt::get(Type::getInt32Ty(
             MI->getParent()->getContext()), NewAlignment));
           ++NumMemIntAlignChanged;
         }
 
         NewDestAlignments.insert(std::make_pair(MTI, NewDestAlignment));
         NewSrcAlignments.insert(std::make_pair(MTI, NewSrcAlignment));
       } else if (NewDestAlignment > MI->getAlignment()) {
-        assert((!isa<MemIntrinsic>(MI) || isa<MemSetInst>(MI)) &&
+        assert((!isa<PlainMemIntrinsic>(MI) || isa<PlainMemSetInst>(MI)) &&
                "Unknown memory intrinsic");
 
         MI->setAlignment(ConstantInt::get(Type::getInt32Ty(
           MI->getParent()->getContext()), NewDestAlignment));
         ++NumMemIntAlignChanged;
       }
     }
 

lib/Transforms/Scalar/DeadStoreElimination.cpp

 
 /// Return a Location stored to by the specified instruction. If isRemovable
 /// returns true, this function and getLocForRead completely describe the memory
 /// operations for this instruction.
 static MemoryLocation getLocForWrite(Instruction *Inst, AliasAnalysis &AA) {
   if (StoreInst *SI = dyn_cast<StoreInst>(Inst))
     return MemoryLocation::get(SI);
 
-  if (MemIntrinsic *MI = dyn_cast<MemIntrinsic>(Inst)) {
+  if (PlainMemIntrinsic *MI = dyn_cast<PlainMemIntrinsic>(Inst)) {
     // memcpy/memmove/memset.
     MemoryLocation Loc = MemoryLocation::getForDest(MI);
     return Loc;
   }
 
   IntrinsicInst *II = dyn_cast<IntrinsicInst>(Inst);
   if (!II)
     return MemoryLocation();

 /// Return the location read by the specified "hasMemoryWrite" instruction if
 /// any.
 static MemoryLocation getLocForRead(Instruction *Inst,
                                     const TargetLibraryInfo &TLI) {
   assert(hasMemoryWrite(Inst, TLI) && "Unknown instruction case");
 
   // The only instructions that both read and write are the mem transfer
   // instructions (memcpy/memmove).
-  if (MemTransferInst *MTI = dyn_cast<MemTransferInst>(Inst))
+  if (PlainMemTransferInst *MTI = dyn_cast<PlainMemTransferInst>(Inst))
     return MemoryLocation::getForSource(MTI);
   return MemoryLocation();
 }
 
 /// If the value of this instruction and the memory it writes to is unused, may
 /// we delete this instruction?
 static bool isRemovable(Instruction *I) {
   // Don't remove volatile/atomic stores.
if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(I)) {
     case Intrinsic::init_trampoline:
       // Always safe to remove init_trampoline.
       return true;
 
     case Intrinsic::memset:
     case Intrinsic::memmove:
     case Intrinsic::memcpy:
       // Don't remove volatile memory intrinsics.
-      return !cast<MemIntrinsic>(II)->isVolatile();
+      return !cast<PlainMemIntrinsic>(II)->isVolatile();
     }
   }
 
   if (auto CS = CallSite(I))
     return CS.getInstruction()->use_empty();
 
   return false;
 }
static bool isShortenableAtTheBeginning(Instruction *I) {
   IntrinsicInst *II = dyn_cast<IntrinsicInst>(I);
   return II && II->getIntrinsicID() == Intrinsic::memset;
 }
 
 /// Return the pointer that is being written to.
 static Value *getStoredPointerOperand(Instruction *I) {
   if (StoreInst *SI = dyn_cast<StoreInst>(I))
     return SI->getPointerOperand();
-  if (MemIntrinsic *MI = dyn_cast<MemIntrinsic>(I))
+  if (PlainMemIntrinsic *MI = dyn_cast<PlainMemIntrinsic>(I))
     return MI->getDest();
 
   if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(I)) {
     switch (II->getIntrinsicID()) {
     default: llvm_unreachable("Unexpected intrinsic!");
     case Intrinsic::init_trampoline:
       return II->getArgOperand(0);
     }
for (BasicBlock::iterator BBI = BB.end(); BBI != BB.begin(); ){
 
     // If we encounter a use of the pointer, it is no longer considered dead
     if (LoadInst *L = dyn_cast<LoadInst>(BBI)) {
       if (!L->isUnordered()) // Be conservative with atomic/volatile load
         break;
       LoadedLoc = MemoryLocation::get(L);
     } else if (VAArgInst *V = dyn_cast<VAArgInst>(BBI)) {
       LoadedLoc = MemoryLocation::get(V);
-    } else if (MemTransferInst *MTI = dyn_cast<MemTransferInst>(BBI)) {
+    } else if (PlainMemTransferInst *MTI = dyn_cast<PlainMemTransferInst>(BBI)) {
       LoadedLoc = MemoryLocation::getForSource(MTI);
     } else if (!BBI->mayReadFromMemory()) {
       // Instruction doesn't read memory.  Note that stores that weren't removed
       // above will hit this case.
       continue;
     } else {
       // Unknown inst; assume it clobbers everything.
       break;
static bool tryToShorten(Instruction *EarlierWrite, int64_t &EarlierOffset,
                          int64_t &EarlierSize, int64_t LaterOffset,
                          int64_t LaterSize, bool IsOverwriteEnd) {
   // TODO: base this on the target vector size so that if the earlier
   // store was too small to get vector writes anyway then its likely
   // a good idea to shorten it
   // Power of 2 vector writes are probably always a bad idea to optimize
   // as any store/memset/memcpy is likely using vector instructions so
   // shortening it to not vector size is likely to be slower
-  MemIntrinsic *EarlierIntrinsic = cast<MemIntrinsic>(EarlierWrite);
+  PlainMemIntrinsic *EarlierIntrinsic = cast<PlainMemIntrinsic>(EarlierWrite);
   unsigned EarlierWriteAlign = EarlierIntrinsic->getAlignment();
   if (!IsOverwriteEnd)
     LaterOffset = int64_t(LaterOffset + LaterSize);
 
   if (!(llvm::isPowerOf2_64(LaterOffset) && EarlierWriteAlign <= LaterOffset) &&
       !((EarlierWriteAlign != 0) && LaterOffset % EarlierWriteAlign == 0))
     return false;
 

lib/Transforms/Scalar/GVN.cpp

struct llvm::gvn::AvailableValue {
   static AvailableValue get(Value *V, unsigned Offset = 0) {
     AvailableValue Res;
     Res.Val.setPointer(V);
     Res.Val.setInt(SimpleVal);
     Res.Offset = Offset;
     return Res;
   }
 
-  static AvailableValue getMI(MemIntrinsic *MI, unsigned Offset = 0) {
+  static AvailableValue getMI(PlainMemIntrinsic *MI, unsigned Offset = 0) {
     AvailableValue Res;
     Res.Val.setPointer(MI);
     Res.Val.setInt(MemIntrin);
     Res.Offset = Offset;
     return Res;
   }
 
   static AvailableValue getLoad(LoadInst *LI, unsigned Offset = 0) {
Value *getSimpleValue() const {
     return Val.getPointer();
   }
 
   LoadInst *getCoercedLoadValue() const {
     assert(isCoercedLoadValue() && "Wrong accessor");
     return cast<LoadInst>(Val.getPointer());
   }
 
-  MemIntrinsic *getMemIntrinValue() const {
+  PlainMemIntrinsic *getMemIntrinValue() const {
     assert(isMemIntrinValue() && "Wrong accessor");
-    return cast<MemIntrinsic>(Val.getPointer());
+    return cast<PlainMemIntrinsic>(Val.getPointer());
   }
 
   /// Emit code at the specified insertion point to adjust the value defined
   /// here to the specified type. This handles various coercion cases.
   Value *MaterializeAdjustedValue(LoadInst *LI, Instruction *InsertPt,
                                   GVN &gvn) const;
 };
 
if (LoadInst *DepLI = dyn_cast<LoadInst>(DepInfo.getInst())) {
           Res = AvailableValue::getLoad(DepLI, Offset);
           return true;
         }
       }
     }
 
     // If the clobbering value is a memset/memcpy/memmove, see if we can
     // forward a value on from it.
-    if (MemIntrinsic *DepMI = dyn_cast<MemIntrinsic>(DepInfo.getInst())) {
+    if (PlainMemIntrinsic *DepMI = dyn_cast<PlainMemIntrinsic>(DepInfo.getInst())) {
       if (Address && !LI->isAtomic()) {
         int Offset = analyzeLoadFromClobberingMemInst(LI->getType(), Address,
                                                       DepMI, DL);
         if (Offset != -1) {
           Res = AvailableValue::getMI(DepMI, Offset);
           return true;
         }
       }

lib/Transforms/Scalar/InferAddressSpaces.cpp

for (Instruction &I : instructions(F)) {
     } else if (auto *LI = dyn_cast<LoadInst>(&I))
       PushPtrOperand(LI->getPointerOperand());
     else if (auto *SI = dyn_cast<StoreInst>(&I))
       PushPtrOperand(SI->getPointerOperand());
     else if (auto *RMW = dyn_cast<AtomicRMWInst>(&I))
       PushPtrOperand(RMW->getPointerOperand());
     else if (auto *CmpX = dyn_cast<AtomicCmpXchgInst>(&I))
       PushPtrOperand(CmpX->getPointerOperand());
-    else if (auto *MI = dyn_cast<MemIntrinsic>(&I)) {
+    else if (auto *MI = dyn_cast<PlainMemIntrinsic>(&I)) {
       // For memset/memcpy/memmove, any pointer operand can be replaced.
       PushPtrOperand(MI->getRawDest());
 
       // Handle 2nd operand for memcpy/memmove.
-      if (auto *MTI = dyn_cast<MemTransferInst>(MI))
+      if (auto *MTI = dyn_cast<PlainMemTransferInst>(MI))
         PushPtrOperand(MTI->getRawSource());
     } else if (auto *II = dyn_cast<IntrinsicInst>(&I))
       collectRewritableIntrinsicOperands(II, PostorderStack, Visited);
     else if (ICmpInst *Cmp = dyn_cast<ICmpInst>(&I)) {
       // FIXME: Handle vectors of pointers
       if (Cmp->getOperand(0)->getType()->isPointerTy()) {
         PushPtrOperand(Cmp->getOperand(0));
         PushPtrOperand(Cmp->getOperand(1));
static bool isSimplePointerUseValidToReplace(Use &U) {
   }
 
   return false;
 }
 
 /// Update memory intrinsic uses that require more complex processing than
 /// simple memory instructions. Thse require re-mangling and may have multiple
 /// pointer operands.
-static bool handleMemIntrinsicPtrUse(MemIntrinsic *MI, Value *OldV,
+static bool handleMemIntrinsicPtrUse(PlainMemIntrinsic *MI, Value *OldV,
                                      Value *NewV) {
   IRBuilder<> B(MI);
   MDNode *TBAA = MI->getMetadata(LLVMContext::MD_tbaa);
   MDNode *ScopeMD = MI->getMetadata(LLVMContext::MD_alias_scope);
   MDNode *NoAliasMD = MI->getMetadata(LLVMContext::MD_noalias);
 
-  if (auto *MSI = dyn_cast<MemSetInst>(MI)) {
+  if (auto *MSI = dyn_cast<PlainMemSetInst>(MI)) {
     B.CreateMemSet(NewV, MSI->getValue(),
                    MSI->getLength(), MSI->getAlignment(),
                    false, // isVolatile
                    TBAA, ScopeMD, NoAliasMD);
-  } else if (auto *MTI = dyn_cast<MemTransferInst>(MI)) {
+  } else if (auto *MTI = dyn_cast<PlainMemTransferInst>(MI)) {
     Value *Src = MTI->getRawSource();
     Value *Dest = MTI->getRawDest();
 
     // Be careful in case this is a self-to-self copy.
     if (Src == OldV)
       Src = NewV;
 
     if (Dest == OldV)
       Dest = NewV;
 
-    if (isa<MemCpyInst>(MTI)) {
+    if (isa<PlainMemCpyInst>(MTI)) {
       MDNode *TBAAStruct = MTI->getMetadata(LLVMContext::MD_tbaa_struct);
       B.CreateMemCpy(Dest, Src, MTI->getLength(),
                      MTI->getAlignment(),
                      false, // isVolatile
                      TBAA, TBAAStruct, ScopeMD, NoAliasMD);
     } else {
-      assert(isa<MemMoveInst>(MTI));
+      assert(isa<PlainMemMoveInst>(MTI));
       B.CreateMemMove(Dest, Src, MTI->getLength(),
                       MTI->getAlignment(),
                       false, // isVolatile
                       TBAA, ScopeMD, NoAliasMD);
     }
   } else
     llvm_unreachable("unhandled MemIntrinsic");
 
for (I = V->use_begin(), E = V->use_end(); I != E; ) {
         // sets the pointer operand to NewV. This replacement does not change
         // the element type, so the resultant load/store is still valid.
         U.set(NewV);
         continue;
       }
 
       User *CurUser = U.getUser();
       // Handle more complex cases like intrinsic that need to be remangled.
-      if (auto *MI = dyn_cast<MemIntrinsic>(CurUser)) {
+      if (auto *MI = dyn_cast<PlainMemIntrinsic>(CurUser)) {
         if (!MI->isVolatile() && handleMemIntrinsicPtrUse(MI, V, NewV))
           continue;
       }
 
       if (auto *II = dyn_cast<IntrinsicInst>(CurUser)) {
         if (rewriteIntrinsicOperands(II, V, NewV))
           continue;
       }

lib/Transforms/Scalar/LoopIdiomRecognize.cpp

private:
   bool runOnCountableLoop();
   bool runOnLoopBlock(BasicBlock *BB, const SCEV *BECount,
                       SmallVectorImpl<BasicBlock *> &ExitBlocks);
 
   void collectStores(BasicBlock *BB);
   LegalStoreKind isLegalStore(StoreInst *SI);
   bool processLoopStores(SmallVectorImpl<StoreInst *> &SL, const SCEV *BECount,
                          bool ForMemset);
-  bool processLoopMemSet(MemSetInst *MSI, const SCEV *BECount);
+  bool processLoopMemSet(PlainMemSetInst *MSI, const SCEV *BECount);
 
   bool processLoopStridedStore(Value *DestPtr, unsigned StoreSize,
                                unsigned StoreAlignment, Value *StoredVal,
                                Instruction *TheStore,
                                SmallPtrSetImpl<Instruction *> &Stores,
                                const SCEVAddRecExpr *Ev, const SCEV *BECount,
                                bool NegStride, bool IsLoopMemset = false);
   bool processLoopStoreOfLoopLoad(StoreInst *SI, const SCEV *BECount);
bool LoopIdiomRecognize::runOnLoopBlock(
 
   // Optimize the store into a memcpy, if it feeds an similarly strided load.
   for (auto &SI : StoreRefsForMemcpy)
     MadeChange |= processLoopStoreOfLoopLoad(SI, BECount);
 
   for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E;) {
     Instruction *Inst = &*I++;
     // Look for memset instructions, which may be optimized to a larger memset.
-    if (MemSetInst *MSI = dyn_cast<MemSetInst>(Inst)) {
+    if (PlainMemSetInst *MSI = dyn_cast<PlainMemSetInst>(Inst)) {
       WeakTrackingVH InstPtr(&*I);
       if (!processLoopMemSet(MSI, BECount))
         continue;
       MadeChange = true;
 
       // If processing the memset invalidated our iterator, start over from the
       // top of the block.
       if (!InstPtr)
if (processLoopStridedStore(StorePtr, StoreSize, HeadStore->getAlignment(),
       Changed = true;
     }
   }
 
   return Changed;
 }
 
 /// processLoopMemSet - See if this memset can be promoted to a large memset.
-bool LoopIdiomRecognize::processLoopMemSet(MemSetInst *MSI,
+bool LoopIdiomRecognize::processLoopMemSet(PlainMemSetInst *MSI,
                                            const SCEV *BECount) {
   // We can only handle non-volatile memsets with a constant size.
   if (MSI->isVolatile() || !isa<ConstantInt>(MSI->getLength()))
     return false;
 
   // If we're not allowed to hack on memset, we fail.
   if (!HasMemset)
     return false;

lib/Transforms/Scalar/LoopRerollPass.cpp

for (Instruction *Root : Roots)
     collectInLoopUserSet(Root, Exclude, Final, Users);
 }
 
 static bool isUnorderedLoadStore(Instruction *I) {
   if (LoadInst *LI = dyn_cast<LoadInst>(I))
     return LI->isUnordered();
   if (StoreInst *SI = dyn_cast<StoreInst>(I))
     return SI->isUnordered();
-  if (MemIntrinsic *MI = dyn_cast<MemIntrinsic>(I))
+  if (PlainMemIntrinsic *MI = dyn_cast<PlainMemIntrinsic>(I))
     return !MI->isVolatile();
   return false;
 }
 
 /// Return true if IVU is a "simple" arithmetic operation.
 /// This is used for narrowing the search space for DAGRoots; only arithmetic
 /// and GEPs can be part of a DAGRoot.
 static bool isSimpleArithmeticOp(User *IVU) {

lib/Transforms/Scalar/MemCpyOptimizer.cpp

public:
   const_iterator begin() const { return Ranges.begin(); }
   const_iterator end() const { return Ranges.end(); }
   bool empty() const { return Ranges.empty(); }
 
   void addInst(int64_t OffsetFromFirst, Instruction *Inst) {
     if (StoreInst *SI = dyn_cast<StoreInst>(Inst))
       addStore(OffsetFromFirst, SI);
     else
-      addMemSet(OffsetFromFirst, cast<MemSetInst>(Inst));
+      addMemSet(OffsetFromFirst, cast<PlainMemSetInst>(Inst));
   }
 
   void addStore(int64_t OffsetFromFirst, StoreInst *SI) {
     int64_t StoreSize = DL.getTypeStoreSize(SI->getOperand(0)->getType());
 
     addRange(OffsetFromFirst, StoreSize,
              SI->getPointerOperand(), SI->getAlignment(), SI);
   }
 
-  void addMemSet(int64_t OffsetFromFirst, MemSetInst *MSI) {
+  void addMemSet(int64_t OffsetFromFirst, PlainMemSetInst *MSI) {
     int64_t Size = cast<ConstantInt>(MSI->getLength())->getZExtValue();
     addRange(OffsetFromFirst, Size, MSI->getDest(), MSI->getAlignment(), MSI);
   }
 
   void addRange(int64_t Start, int64_t Size, Value *Ptr,
                 unsigned Alignment, Instruction *Inst);
 
 };
Instruction *MemCpyOptPass::tryMergingIntoMemset(Instruction *StartInst,
   // Okay, so we now have a single store that can be splatable.  Scan to find
   // all subsequent stores of the same value to offset from the same pointer.
   // Join these together into ranges, so we can decide whether contiguous blocks
   // are stored.
   MemsetRanges Ranges(DL);
 
   BasicBlock::iterator BI(StartInst);
   for (++BI; !isa<TerminatorInst>(BI); ++BI) {
-    if (!isa<StoreInst>(BI) && !isa<MemSetInst>(BI)) {
+    if (!isa<StoreInst>(BI) && !isa<PlainMemSetInst>(BI)) {
       // If the instruction is readnone, ignore it, otherwise bail out.  We
       // don't even allow readonly here because we don't want something like:
       // A[1] = 2; strlen(A); A[2] = 2; -> memcpy(A, ...); strlen(A).
       if (BI->mayWriteToMemory() || BI->mayReadFromMemory())
         break;
       continue;
     }
 
     if (StoreInst *NextStore = dyn_cast<StoreInst>(BI)) {
       // If this is a store, see if we can merge it in.
       if (!NextStore->isSimple()) break;
 
       // Check to see if this stored value is of the same byte-splattable value.
       if (ByteVal != isBytewiseValue(NextStore->getOperand(0)))
         break;
 
       // Check to see if this store is to a constant offset from the start ptr.
       int64_t Offset;
       if (!IsPointerOffset(StartPtr, NextStore->getPointerOperand(), Offset,
                            DL))
         break;
 
       Ranges.addStore(Offset, NextStore);
     } else {
-      MemSetInst *MSI = cast<MemSetInst>(BI);
+      PlainMemSetInst *MSI = cast<PlainMemSetInst>(BI);
 
       if (MSI->isVolatile() || ByteVal != MSI->getValue() ||
           !isa<ConstantInt>(MSI->getLength()))
         break;
 
       // Check to see if this store is to a constant offset from the start ptr.
       int64_t Offset;
       if (!IsPointerOffset(StartPtr, MSI->getDest(), Offset, DL))
if (LI->isSimple() && LI->hasOneUse() &&
         }
       }
 
       // Detect cases where we're performing call slot forwarding, but
       // happen to be using a load-store pair to implement it, rather than
       // a memcpy.
       MemDepResult ldep = MD->getDependency(LI);
       CallInst *C = nullptr;
-      if (ldep.isClobber() && !isa<MemCpyInst>(ldep.getInst()))
+      if (ldep.isClobber() && !isa<PlainMemCpyInst>(ldep.getInst()))
         C = dyn_cast<CallInst>(ldep.getInst());
 
       if (C) {
         // Check that nothing touches the dest of the "copy" between
         // the call and the store.
         Value *CpyDest = SI->getPointerOperand()->stripPointerCasts();
         bool CpyDestIsLocal = isa<AllocaInst>(CpyDest);
         AliasAnalysis &AA = LookupAliasAnalysis();
if (T->isAggregateType()) {
       BBI = M->getIterator();
       return true;
     }
   }
 
   return false;
 }
 
-bool MemCpyOptPass::processMemSet(MemSetInst *MSI, BasicBlock::iterator &BBI) {
+bool MemCpyOptPass::processMemSet(PlainMemSetInst *MSI, BasicBlock::iterator &BBI) {
   // See if there is another memset or store neighboring this memset which
   // allows us to widen out the memset to do a single larger store.
   if (isa<ConstantInt>(MSI->getLength()) && !MSI->isVolatile())
     if (Instruction *I = tryMergingIntoMemset(MSI, MSI->getDest(),
                                               MSI->getValue())) {
       BBI = I->getIterator(); // Don't invalidate iterator.
       return true;
     }
bool MemCpyOptPass::performCallSlotOptzn(Instruction *cpy, Value *cpyDest,
   MD->removeInstruction(cpy);
   ++NumMemCpyInstr;
 
   return true;
 }
 
 /// We've found that the (upward scanning) memory dependence of memcpy 'M' is
 /// the memcpy 'MDep'. Try to simplify M to copy from MDep's input if we can.
-bool MemCpyOptPass::processMemCpyMemCpyDependence(MemCpyInst *M,
-                                                  MemCpyInst *MDep) {
+bool MemCpyOptPass::processMemCpyMemCpyDependence(PlainMemCpyInst *M,
+                                                  PlainMemCpyInst *MDep) {
   // We can only transforms memcpy's where the dest of one is the source of the
   // other.
   if (M->getSource() != MDep->getDest() || MDep->isVolatile())
     return false;
 
   // If dep instruction is reading from our current input, then it is a noop
   // transfer and substituting the input won't change this instruction.  Just
   // ignore the input and let someone else zap MDep.  This handles cases like:

 ///   memset(dst, c, dst_size);
 ///   memcpy(dst, src, src_size);
 /// \endcode
 /// into:
 /// \code
 ///   memcpy(dst, src, src_size);
 ///   memset(dst + src_size, c, dst_size <= src_size ? 0 : dst_size - src_size);
 /// \endcode
-bool MemCpyOptPass::processMemSetMemCpyDependence(MemCpyInst *MemCpy,
-                                                  MemSetInst *MemSet) {
+bool MemCpyOptPass::processMemSetMemCpyDependence(PlainMemCpyInst *MemCpy,
+                                                  PlainMemSetInst *MemSet) {
   // We can only transform memset/memcpy with the same destination.
   if (MemSet->getDest() != MemCpy->getDest())
     return false;
 
   // Check that there are no other dependencies on the memset destination.
   MemDepResult DstDepInfo =
       MD->getPointerDependencyFrom(MemoryLocation::getForDest(MemSet), false,
                                    MemCpy->getIterator(), MemCpy->getParent());

 /// into:
 /// \code
 ///   memset(dst1, c, dst1_size);
 ///   memset(dst2, c, dst2_size);
 /// \endcode
 /// When dst2_size <= dst1_size.
 ///
 /// The \p MemCpy must have a Constant length.
-bool MemCpyOptPass::performMemCpyToMemSetOptzn(MemCpyInst *MemCpy,
-                                               MemSetInst *MemSet) {
+bool MemCpyOptPass::performMemCpyToMemSetOptzn(PlainMemCpyInst *MemCpy,
+                                               PlainMemSetInst *MemSet) {
   AliasAnalysis &AA = LookupAliasAnalysis();
 
   // Make sure that memcpy(..., memset(...), ...), that is we are memsetting and
   // memcpying from the same address. Otherwise it is hard to reason about.
   if (!AA.isMustAlias(MemSet->getRawDest(), MemCpy->getRawSource()))
     return false;
 
   ConstantInt *CopySize = cast<ConstantInt>(MemCpy->getLength());
bool MemCpyOptPass::performMemCpyToMemSetOptzn(PlainMemCpyInst *MemCpy,
   return true;
 }
 
 /// Perform simplification of memcpy's.  If we have memcpy A
 /// which copies X to Y, and memcpy B which copies Y to Z, then we can rewrite
 /// B to be a memcpy from X to Z (or potentially a memmove, depending on
 /// circumstances). This allows later passes to remove the first memcpy
 /// altogether.
-bool MemCpyOptPass::processMemCpy(MemCpyInst *M) {
+bool MemCpyOptPass::processMemCpy(PlainMemCpyInst *M) {
   // We can only optimize non-volatile memcpy's.
   if (M->isVolatile()) return false;
 
   // If the source and destination of the memcpy are the same, then zap it.
   if (M->getSource() == M->getDest()) {
     MD->removeInstruction(M);
     M->eraseFromParent();
     return false;
if (GV->isConstant() && GV->hasDefinitiveInitializer())
         return true;
       }
 
   MemDepResult DepInfo = MD->getDependency(M);
 
   // Try to turn a partially redundant memset + memcpy into
   // memcpy + smaller memset.  We don't need the memcpy size for this.
   if (DepInfo.isClobber())
-    if (MemSetInst *MDep = dyn_cast<MemSetInst>(DepInfo.getInst()))
+    if (PlainMemSetInst *MDep = dyn_cast<PlainMemSetInst>(DepInfo.getInst()))
       if (processMemSetMemCpyDependence(M, MDep))
         return true;
 
   // The optimizations after this point require the memcpy size.
   ConstantInt *CopySize = dyn_cast<ConstantInt>(M->getLength());
   if (!CopySize) return false;
 
   // There are four possible optimizations we can do for memcpy:
if (DepInfo.isClobber()) {
     }
   }
 
   MemoryLocation SrcLoc = MemoryLocation::getForSource(M);
   MemDepResult SrcDepInfo = MD->getPointerDependencyFrom(
       SrcLoc, true, M->getIterator(), M->getParent());
 
   if (SrcDepInfo.isClobber()) {
-    if (MemCpyInst *MDep = dyn_cast<MemCpyInst>(SrcDepInfo.getInst()))
+    if (PlainMemCpyInst *MDep = dyn_cast<PlainMemCpyInst>(SrcDepInfo.getInst()))
       return processMemCpyMemCpyDependence(M, MDep);
   } else if (SrcDepInfo.isDef()) {
     Instruction *I = SrcDepInfo.getInst();
     bool hasUndefContents = false;
 
     if (isa<AllocaInst>(I)) {
       hasUndefContents = true;
     } else if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(I)) {
       if (II->getIntrinsicID() == Intrinsic::lifetime_start)
         if (ConstantInt *LTSize = dyn_cast<ConstantInt>(II->getArgOperand(0)))
           if (LTSize->getZExtValue() >= CopySize->getZExtValue())
             hasUndefContents = true;
     }
 
     if (hasUndefContents) {
       MD->removeInstruction(M);
       M->eraseFromParent();
       ++NumMemCpyInstr;
       return true;
     }
   }
 
   if (SrcDepInfo.isClobber())
-    if (MemSetInst *MDep = dyn_cast<MemSetInst>(SrcDepInfo.getInst()))
+    if (PlainMemSetInst *MDep = dyn_cast<PlainMemSetInst>(SrcDepInfo.getInst()))
       if (performMemCpyToMemSetOptzn(M, MDep)) {
         MD->removeInstruction(M);
         M->eraseFromParent();
         ++NumCpyToSet;
         return true;
       }
 
   return false;
 }
 
 /// Transforms memmove calls to memcpy calls when the src/dst are guaranteed
 /// not to alias.
-bool MemCpyOptPass::processMemMove(MemMoveInst *M) {
+bool MemCpyOptPass::processMemMove(PlainMemMoveInst *M) {
   AliasAnalysis &AA = LookupAliasAnalysis();
 
   if (!TLI->has(LibFunc_memmove))
     return false;
 
   // See if the pointers alias.
   if (!AA.isNoAlias(MemoryLocation::getForDest(M),
                     MemoryLocation::getForSource(M)))
MemDepResult DepInfo = MD->getPointerDependencyFrom(
       MemoryLocation(ByValArg, ByValSize), true,
       CS.getInstruction()->getIterator(), CS.getInstruction()->getParent());
   if (!DepInfo.isClobber())
     return false;
 
   // If the byval argument isn't fed by a memcpy, ignore it.  If it is fed by
   // a memcpy, see if we can byval from the source of the memcpy instead of the
   // result.
-  MemCpyInst *MDep = dyn_cast<MemCpyInst>(DepInfo.getInst());
+  PlainMemCpyInst *MDep = dyn_cast<PlainMemCpyInst>(DepInfo.getInst());
   if (!MDep || MDep->isVolatile() ||
       ByValArg->stripPointerCasts() != MDep->getDest())
     return false;
 
   // The length of the memcpy must be larger or equal to the size of the byval.
   ConstantInt *C1 = dyn_cast<ConstantInt>(MDep->getLength());
   if (!C1 || C1->getValue().getZExtValue() < ByValSize)
     return false;
for (BasicBlock &BB : F) {
     for (BasicBlock::iterator BI = BB.begin(), BE = BB.end(); BI != BE;) {
       // Avoid invalidating the iterator.
       Instruction *I = &*BI++;
 
       bool RepeatInstruction = false;
 
       if (StoreInst *SI = dyn_cast<StoreInst>(I))
         MadeChange |= processStore(SI, BI);
-      else if (MemSetInst *M = dyn_cast<MemSetInst>(I))
+      else if (PlainMemSetInst *M = dyn_cast<PlainMemSetInst>(I))
         RepeatInstruction = processMemSet(M, BI);
-      else if (MemCpyInst *M = dyn_cast<MemCpyInst>(I))
+      else if (PlainMemCpyInst *M = dyn_cast<PlainMemCpyInst>(I))
         RepeatInstruction = processMemCpy(M);
-      else if (MemMoveInst *M = dyn_cast<MemMoveInst>(I))
+      else if (PlainMemMoveInst *M = dyn_cast<PlainMemMoveInst>(I))
         RepeatInstruction = processMemMove(M);
       else if (auto CS = CallSite(I)) {
         for (unsigned i = 0, e = CS.arg_size(); i != e; ++i)
           if (CS.isByValArgument(i))
             MadeChange |= processByValArgument(CS, i);
       }
 
       // Reprocess the instruction if desired.

lib/Transforms/Scalar/NewGVN.cpp

if (Offset >= 0) {
         if (auto *PossibleConstant =
                 getConstantLoadValueForLoad(C, Offset, LoadType, DL)) {
           DEBUG(dbgs() << "Coercing load from load " << *LI << " to constant "
                        << *PossibleConstant << "\n");
           return createConstantExpression(PossibleConstant);
         }
     }
 
-  } else if (auto *DepMI = dyn_cast<MemIntrinsic>(DepInst)) {
+  } else if (auto *DepMI = dyn_cast<PlainMemIntrinsic>(DepInst)) {
     int Offset = analyzeLoadFromClobberingMemInst(LoadType, LoadPtr, DepMI, DL);
     if (Offset >= 0) {
       if (auto *PossibleConstant =
               getConstantMemInstValueForLoad(DepMI, Offset, LoadType, DL)) {
         DEBUG(dbgs() << "Coercing load from meminst " << *DepMI
                      << " to constant " << *PossibleConstant << "\n");
         return createConstantExpression(PossibleConstant);
       }

lib/Transforms/Scalar/SROA.cpp

if (Size > AllocSize || Offset.ugt(AllocSize - Size)) {
       return markAsDead(SI);
     }
 
     assert((!SI.isSimple() || ValOp->getType()->isSingleValueType()) &&
            "All simple FCA stores should have been pre-split");
     handleLoadOrStore(ValOp->getType(), SI, Offset, Size, SI.isVolatile());
   }
 
-  void visitMemSetInst(MemSetInst &II) {
+  void visitPlainMemSetInst(PlainMemSetInst &II) {
     assert(II.getRawDest() == *U && "Pointer use is not the destination?");
     ConstantInt *Length = dyn_cast<ConstantInt>(II.getLength());
     if ((Length && Length->getValue() == 0) ||
         (IsOffsetKnown && Offset.uge(AllocSize)))
       // Zero-length mem transfer intrinsics can be ignored entirely.
       return markAsDead(II);
 
     if (!IsOffsetKnown)
       return PI.setAborted(&II);
 
     insertUse(II, Offset, Length ? Length->getLimitedValue()
                                  : AllocSize - Offset.getLimitedValue(),
               (bool)Length);
   }
 
-  void visitMemTransferInst(MemTransferInst &II) {
+  void visitPlainMemTransferInst(PlainMemTransferInst &II) {
     ConstantInt *Length = dyn_cast<ConstantInt>(II.getLength());
     if (Length && Length->getValue() == 0)
       // Zero-length mem transfer intrinsics can be ignored entirely.
       return markAsDead(II);
 
     // Because we can visit these intrinsics twice, also check to see if the
     // first time marked this instruction as dead. If so, skip it.
     if (VisitedDeadInsts.count(&II))
Type *SliceTy = (NumElements == 1)
                       ? Ty->getElementType()
                       : VectorType::get(Ty->getElementType(), NumElements);
 
   Type *SplitIntTy =
       Type::getIntNTy(Ty->getContext(), NumElements * ElementSize * 8);
 
   Use *U = S.getUse();
 
-  if (MemIntrinsic *MI = dyn_cast<MemIntrinsic>(U->getUser())) {
+  if (PlainMemIntrinsic *MI = dyn_cast<PlainMemIntrinsic>(U->getUser())) {
     if (MI->isVolatile())
       return false;
     if (!S.isSplittable())
       return false; // Skip any unsplittable intrinsics.
   } else if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(U->getUser())) {
     if (II->getIntrinsicID() != Intrinsic::lifetime_start &&
         II->getIntrinsicID() != Intrinsic::lifetime_end)
       return false;
if (IntegerType *ITy = dyn_cast<IntegerType>(ValueTy)) {
       if (ITy->getBitWidth() < DL.getTypeStoreSizeInBits(ITy))
         return false;
     } else if (RelBegin != 0 || RelEnd != Size ||
                !canConvertValue(DL, ValueTy, AllocaTy)) {
       // Non-integer stores need to be convertible to the alloca type so that
       // they are promotable.
       return false;
     }
-  } else if (MemIntrinsic *MI = dyn_cast<MemIntrinsic>(U->getUser())) {
+  } else if (PlainMemIntrinsic *MI = dyn_cast<PlainMemIntrinsic>(U->getUser())) {
     if (MI->isVolatile() || !isa<Constant>(MI->getLength()))
       return false;
     if (!S.isSplittable())
       return false; // Skip any unsplittable intrinsics.
   } else if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(U->getUser())) {
     if (II->getIntrinsicID() != Intrinsic::lifetime_start &&
         II->getIntrinsicID() != Intrinsic::lifetime_end)
       return false;
#endif
 
   /// \brief Compute a vector splat for a given element value.
   Value *getVectorSplat(Value *V, unsigned NumElements) {
     V = IRB.CreateVectorSplat(NumElements, V, "vsplat");
     DEBUG(dbgs() << "       splat: " << *V << "\n");
     return V;
   }
 
-  bool visitMemSetInst(MemSetInst &II) {
+  bool visitPlainMemSetInst(PlainMemSetInst &II) {
     DEBUG(dbgs() << "    original: " << II << "\n");
     assert(II.getRawDest() == OldPtr);
 
     // If the memset has a variable size, it cannot be split, just adjust the
     // pointer to the new alloca.
     if (!isa<Constant>(II.getLength())) {
       assert(!IsSplit);
       assert(NewBeginOffset == BeginOffset);
bool visitPlainMemSetInst(PlainMemSetInst &II) {
 
     Value *New = IRB.CreateAlignedStore(V, &NewAI, NewAI.getAlignment(),
                                         II.isVolatile());
     (void)New;
     DEBUG(dbgs() << "          to: " << *New << "\n");
     return !II.isVolatile();
   }
 
-  bool visitMemTransferInst(MemTransferInst &II) {
+  bool visitPlainMemTransferInst(PlainMemTransferInst &II) {
     // Rewriting of memory transfer instructions can be a bit tricky. We break
     // them into two categories: split intrinsics and unsplit intrinsics.
 
     DEBUG(dbgs() << "    original: " << II << "\n");
 
     bool IsDest = &II.getRawDestUse() == OldUse;
     assert((IsDest && II.getRawDest() == OldPtr) ||
            (!IsDest && II.getRawSource() == OldPtr));

lib/Transforms/Utils/AddDiscriminators.cpp

static cl::opt<bool> NoDiscriminators(
     cl::desc("Disable generation of discriminator information."));
 
 // Create the legacy AddDiscriminatorsPass.
 FunctionPass *llvm::createAddDiscriminatorsPass() {
   return new AddDiscriminatorsLegacyPass();
 }
 
 static bool shouldHaveDiscriminator(const Instruction *I) {
-  return !isa<IntrinsicInst>(I) || isa<MemIntrinsic>(I);
+  return !isa<IntrinsicInst>(I) || isa<PlainMemIntrinsic>(I);
 }
 
 /// \brief Assign DWARF discriminators.
 ///
 /// To assign discriminators, we examine the boundaries of every
 /// basic block and its successors. Suppose there is a basic block B1
 /// with successor B2. The last instruction I1 in B1 and the first
 /// instruction I2 in B2 are located at the same file and line number.

lib/Transforms/Utils/Evaluator.cpp

if (StoreInst *SI = dyn_cast<StoreInst>(CurInst)) {
 
       // Cannot handle inline asm.
       if (isa<InlineAsm>(CS.getCalledValue())) {
         DEBUG(dbgs() << "Found inline asm, can not evaluate.\n");
         return false;
       }
 
       if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(CS.getInstruction())) {
-        if (MemSetInst *MSI = dyn_cast<MemSetInst>(II)) {
+        if (PlainMemSetInst *MSI = dyn_cast<PlainMemSetInst>(II)) {
           if (MSI->isVolatile()) {
             DEBUG(dbgs() << "Can not optimize a volatile memset " <<
                   "intrinsic.\n");
             return false;
           }
           Constant *Ptr = getVal(MSI->getDest());
           Constant *Val = getVal(MSI->getValue());
           Constant *DestVal = ComputeLoadResult(getVal(Ptr));

lib/Transforms/Utils/GlobalStatus.cpp

if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(UR)) {
       } else if (const PHINode *PN = dyn_cast<PHINode>(I)) {
         // PHI nodes we can check just like select or GEP instructions, but we
         // have to be careful about infinite recursion.
         if (PhiUsers.insert(PN).second) // Not already visited.
           if (analyzeGlobalAux(I, GS, PhiUsers))
             return true;
       } else if (isa<CmpInst>(I)) {
         GS.IsCompared = true;
-      } else if (const MemTransferInst *MTI = dyn_cast<MemTransferInst>(I)) {
+      } else if (const PlainMemTransferInst *MTI = dyn_cast<PlainMemTransferInst>(I)) {
         if (MTI->isVolatile())
           return true;
         if (MTI->getArgOperand(0) == V)
           GS.StoredType = GlobalStatus::Stored;
         if (MTI->getArgOperand(1) == V)
           GS.IsLoaded = true;
-      } else if (const MemSetInst *MSI = dyn_cast<MemSetInst>(I)) {
+      } else if (const PlainMemSetInst *MSI = dyn_cast<PlainMemSetInst>(I)) {
         assert(MSI->getArgOperand(0) == V && "Memset only takes one pointer!");
         if (MSI->isVolatile())
           return true;
         GS.StoredType = GlobalStatus::Stored;
       } else if (auto C = ImmutableCallSite(I)) {
         if (!C.isCallee(&U))
           return true;
         GS.IsLoaded = true;

lib/Transforms/Utils/LowerMemIntrinsics.cpp

static void createMemSetLoop(Instruction *InsertBefore,
   Value *NewIndex =
       LoopBuilder.CreateAdd(LoopIndex, ConstantInt::get(TypeOfCopyLen, 1));
   LoopIndex->addIncoming(NewIndex, LoopBB);
 
   LoopBuilder.CreateCondBr(LoopBuilder.CreateICmpULT(NewIndex, CopyLen), LoopBB,
                            NewBB);
 }
 
-void llvm::expandMemCpyAsLoop(MemCpyInst *Memcpy,
+void llvm::expandMemCpyAsLoop(PlainMemCpyInst *Memcpy,
                               const TargetTransformInfo &TTI) {
   // Original implementation
   if (!TTI.useWideIRMemcpyLoopLowering()) {
     createMemCpyLoop(/* InsertBefore */ Memcpy,
                      /* SrcAddr */ Memcpy->getRawSource(),
                      /* DstAddr */ Memcpy->getRawDest(),
                      /* CopyLen */ Memcpy->getLength(),
                      /* SrcAlign */ Memcpy->getAlignment(),
if (ConstantInt *CI = dyn_cast<ConstantInt>(Memcpy->getLength())) {
                                   /* DestAlign */ Memcpy->getAlignment(),
                                   /* SrcIsVolatile */ Memcpy->isVolatile(),
                                   /* DstIsVolatile */ Memcpy->isVolatile(),
                                   /* TargetTransfomrInfo */ TTI);
     }
   }
 }
 
-void llvm::expandMemMoveAsLoop(MemMoveInst *Memmove) {
+void llvm::expandMemMoveAsLoop(PlainMemMoveInst *Memmove) {
   createMemMoveLoop(/* InsertBefore */ Memmove,
                     /* SrcAddr */ Memmove->getRawSource(),
                     /* DstAddr */ Memmove->getRawDest(),
                     /* CopyLen */ Memmove->getLength(),
                     /* SrcAlign */ Memmove->getAlignment(),
                     /* DestAlign */ Memmove->getAlignment(),
                     /* SrcIsVolatile */ Memmove->isVolatile(),
                     /* DstIsVolatile */ Memmove->isVolatile());
 }
 
-void llvm::expandMemSetAsLoop(MemSetInst *Memset) {
+void llvm::expandMemSetAsLoop(PlainMemSetInst *Memset) {
   createMemSetLoop(/* InsertBefore */ Memset,
                    /* DstAddr */ Memset->getRawDest(),
                    /* CopyLen */ Memset->getLength(),
                    /* SetValue */ Memset->getValue(),
                    /* Alignment */ Memset->getAlignment(),
                    Memset->isVolatile());
 }

lib/Transforms/Utils/VNCoercion.cpp

int analyzeLoadFromClobberingLoad(Type *LoadTy, Value *LoadPtr, LoadInst *DepLI,
   // able to materialize this potentially available value
   assert(DepLI->isSimple() && "Cannot widen volatile/atomic load!");
   assert(DepLI->getType()->isIntegerTy() && "Can't widen non-integer load");
 
   return analyzeLoadFromClobberingWrite(LoadTy, LoadPtr, DepPtr, Size * 8, DL);
 }
 
 int analyzeLoadFromClobberingMemInst(Type *LoadTy, Value *LoadPtr,
-                                     MemIntrinsic *MI, const DataLayout &DL) {
+                                     PlainMemIntrinsic *MI, const DataLayout &DL) {
   // If the mem operation is a non-constant size, we can't handle it.
   ConstantInt *SizeCst = dyn_cast<ConstantInt>(MI->getLength());
   if (!SizeCst)
     return -1;
   uint64_t MemSizeInBits = SizeCst->getZExtValue() * 8;
 
   // If this is memset, we just need to see if the offset is valid in the size
   // of the memset..
   if (MI->getIntrinsicID() == Intrinsic::memset)
     return analyzeLoadFromClobberingWrite(LoadTy, LoadPtr, MI->getDest(),
                                           MemSizeInBits, DL);
 
   // If we have a memcpy/memmove, the only case we can handle is if this is a
   // copy from constant memory.  In that case, we can read directly from the
   // constant memory.
-  MemTransferInst *MTI = cast<MemTransferInst>(MI);
+  PlainMemTransferInst *MTI = cast<PlainMemTransferInst>(MI);
 
   Constant *Src = dyn_cast<Constant>(MTI->getSource());
   if (!Src)
     return -1;
 
   GlobalVariable *GV = dyn_cast<GlobalVariable>(GetUnderlyingObject(Src, DL));
   if (!GV || !GV->isConstant())
     return -1;
Constant *getConstantLoadValueForLoad(Constant *SrcVal, unsigned Offset,
   unsigned SrcValStoreSize = DL.getTypeStoreSize(SrcVal->getType());
   unsigned LoadSize = DL.getTypeStoreSize(LoadTy);
   if (Offset + LoadSize > SrcValStoreSize)
     return nullptr;
   return getConstantStoreValueForLoad(SrcVal, Offset, LoadTy, DL);
 }
 
 template <class T, class HelperClass>
-T *getMemInstValueForLoadHelper(MemIntrinsic *SrcInst, unsigned Offset,
+T *getMemInstValueForLoadHelper(PlainMemIntrinsic *SrcInst, unsigned Offset,
                                 Type *LoadTy, HelperClass &Helper,
                                 const DataLayout &DL) {
   LLVMContext &Ctx = LoadTy->getContext();
   uint64_t LoadSize = DL.getTypeSizeInBits(LoadTy) / 8;
 
   // We know that this method is only called when the mem transfer fully
   // provides the bits for the load.
-  if (MemSetInst *MSI = dyn_cast<MemSetInst>(SrcInst)) {
+  if (PlainMemSetInst *MSI = dyn_cast<PlainMemSetInst>(SrcInst)) {
     // memset(P, 'x', 1234) -> splat('x'), even if x is a variable, and
     // independently of what the offset is.
     T *Val = cast<T>(MSI->getValue());
     if (LoadSize != 1)
       Val =
           Helper.CreateZExtOrBitCast(Val, IntegerType::get(Ctx, LoadSize * 8));
     T *OneElt = Val;
 
for (unsigned NumBytesSet = 1; NumBytesSet != LoadSize;) {
       Val = Helper.CreateOr(OneElt, ShVal);
       ++NumBytesSet;
     }
 
     return coerceAvailableValueToLoadTypeHelper(Val, LoadTy, Helper, DL);
   }
 
   // Otherwise, this is a memcpy/memmove from a constant global.
-  MemTransferInst *MTI = cast<MemTransferInst>(SrcInst);
+  PlainMemTransferInst *MTI = cast<PlainMemTransferInst>(SrcInst);
   Constant *Src = cast<Constant>(MTI->getSource());
   unsigned AS = Src->getType()->getPointerAddressSpace();
 
   // Otherwise, see if we can constant fold a load from the constant with the
   // offset applied as appropriate.
   Src =
       ConstantExpr::getBitCast(Src, Type::getInt8PtrTy(Src->getContext(), AS));
   Constant *OffsetCst =
       ConstantInt::get(Type::getInt64Ty(Src->getContext()), (unsigned)Offset);
   Src = ConstantExpr::getGetElementPtr(Type::getInt8Ty(Src->getContext()), Src,
                                        OffsetCst);
   Src = ConstantExpr::getBitCast(Src, PointerType::get(LoadTy, AS));
   return ConstantFoldLoadFromConstPtr(Src, LoadTy, DL);
 }
 
 /// This function is called when we have a
 /// memdep query of a load that ends up being a clobbering mem intrinsic.
-Value *getMemInstValueForLoad(MemIntrinsic *SrcInst, unsigned Offset,
+Value *getMemInstValueForLoad(PlainMemIntrinsic *SrcInst, unsigned Offset,
                               Type *LoadTy, Instruction *InsertPt,
                               const DataLayout &DL) {
   IRBuilder<> Builder(InsertPt);
   return getMemInstValueForLoadHelper<Value, IRBuilder<>>(SrcInst, Offset,
                                                           LoadTy, Builder, DL);
 }
 
-Constant *getConstantMemInstValueForLoad(MemIntrinsic *SrcInst, unsigned Offset,
+Constant *getConstantMemInstValueForLoad(PlainMemIntrinsic *SrcInst, unsigned Offset,
                                          Type *LoadTy, const DataLayout &DL) {
   // The only case analyzeLoadFromClobberingMemInst cannot be converted to a
   // constant is when it's a memset of a non-constant.
-  if (auto *MSI = dyn_cast<MemSetInst>(SrcInst))
+  if (auto *MSI = dyn_cast<PlainMemSetInst>(SrcInst))
     if (!isa<Constant>(MSI->getValue()))
       return nullptr;
   ConstantFolder F;
   return getMemInstValueForLoadHelper<Constant, ConstantFolder>(SrcInst, Offset,
                                                                 LoadTy, F, DL);
 }
 } // namespace VNCoercion
 } // namespace llvm

lib/Transforms/Vectorize/SLPVectorizer.cpp

 }
 
 /// \returns True if the instruction is not a volatile or atomic load/store.
 static bool isSimple(Instruction *I) {
   if (LoadInst *LI = dyn_cast<LoadInst>(I))
     return LI->isSimple();
   if (StoreInst *SI = dyn_cast<StoreInst>(I))
     return SI->isSimple();
-  if (MemIntrinsic *MI = dyn_cast<MemIntrinsic>(I))
+  if (PlainMemIntrinsic *MI = dyn_cast<PlainMemIntrinsic>(I))
     return !MI->isVolatile();
   return true;
 }
 
 namespace llvm {
 
 namespace slpvectorizer {
 

test/Instrumentation/DataFlowSanitizer/unordered_atomic_mem_intrins.ll

 ; RUN: opt < %s -dfsan -dfsan-args-abi -S | FileCheck %s
 
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 ;; Placeholder tests that will fail once element atomic @llvm.mem[move|set] instrinsics have
-;; been added to the MemIntrinsic class hierarchy. These will act as a reminder to
+;; been added to the PlainMemIntrinsic class hierarchy. These will act as a reminder to
 ;; verify that dfsan handles these intrinsics properly once they have been
 ;; added to that class hierarchy.
 
 declare void @llvm.memset.element.unordered.atomic.p0i8.i64(i8* nocapture writeonly, i8, i64, i32) nounwind
 declare void @llvm.memmove.element.unordered.atomic.p0i8.p0i8.i64(i8* nocapture writeonly, i8* nocapture readonly, i64, i32) nounwind
 declare void @llvm.memcpy.element.unordered.atomic.p0i8.p0i8.i64(i8* nocapture writeonly, i8* nocapture readonly, i64, i32) nounwind
 
 define void @test_memcpy(i8* nocapture, i8* nocapture) {

test/Instrumentation/MemorySanitizer/msan_basic.ll

 declare void @llvm.memmove.p0i8.p0i8.i64(i8* nocapture, i8* nocapture, i64, i32, i1) nounwind
 
 ; CHECK-LABEL: @MemMove
 ; CHECK: call i8* @__msan_memmove
 ; CHECK: ret void
 
 ;; ------------
 ;; Placeholder tests that will fail once element atomic @llvm.mem[cpy|move|set] instrinsics have
-;; been added to the MemIntrinsic class hierarchy. These will act as a reminder to
+;; been added to the PlainMemIntrinsic class hierarchy. These will act as a reminder to
 ;; verify that MSAN handles these intrinsics properly once they have been
 ;; added to that class hierarchy.
 declare void @llvm.memset.element.unordered.atomic.p0i8.i64(i8* nocapture writeonly, i8, i64, i32) nounwind
 declare void @llvm.memmove.element.unordered.atomic.p0i8.p0i8.i64(i8* nocapture writeonly, i8* nocapture readonly, i64, i32) nounwind
 declare void @llvm.memcpy.element.unordered.atomic.p0i8.p0i8.i64(i8* nocapture writeonly, i8* nocapture readonly, i64, i32) nounwind
 
 define void @atomic_memcpy(i8* nocapture %x, i8* nocapture %y) nounwind {
   ; CHECK-LABEL: atomic_memcpy

test/Transforms/InstCombine/element-atomic-memintrins.ll

 ;; Placeholder tests that will fail once element atomic @llvm.mem[move|set] instrinsics have
-;; been added to the MemIntrinsic class hierarchy. These will act as a reminder to
+;; been added to the PlainMemIntrinsic class hierarchy. These will act as a reminder to
 ;; verify that inst combine handles these intrinsics properly once they have been
 ;; added to that class hierarchy.
 
 ; RUN: opt -instcombine -S < %s | FileCheck %s
 
 ;; ---- memset -----
 
 ; Ensure 0-length memset isn't removed