[Remarks] Make memsize remarks report as an analysis, not a missed opportunity.

[thegameg]

LGTM

llvm/include/llvm/Transforms/Utils/MemoryOpRemark.h

60

Can we reuse enum DiagnosticKind from DiagnosticInfo.h?

DK_OptimizationRemarkMissed,
DK_OptimizationRemarkAnalysis,

llvm/include/llvm/Transforms/Utils/MemoryOpRemark.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TRANSFORMS_UTILS_MEMORYOPREMARK_H
 #define LLVM_TRANSFORMS_UTILS_MEMORYOPREMARK_H
 
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Analysis/TargetLibraryInfo.h"
+#include "llvm/IR/DiagnosticInfo.h"
 
 namespace llvm {
 
 class CallInst;
 class DataLayout;
 class DiagnosticInfoIROptimization;
 class Instruction;
 class IntrinsicInst;
 class Value;
 class OptimizationRemarkEmitter;
 class OptimizationRemarkMissed;
+class OptimizationRemarkAnalysis;
 class StoreInst;
 
 // FIXME: Once we get to more remarks like this one, we need to re-evaluate how
 // much of this logic should actually go into the remark emitter.
 struct MemoryOpRemark {
   OptimizationRemarkEmitter &ORE;
   StringRef RemarkPass;
   const DataLayout &DL;
   const TargetLibraryInfo &TLI;
 
   MemoryOpRemark(OptimizationRemarkEmitter &ORE, StringRef RemarkPass,
                  const DataLayout &DL, const TargetLibraryInfo &TLI)
       : ORE(ORE), RemarkPass(RemarkPass), DL(DL), TLI(TLI) {}
 
   virtual ~MemoryOpRemark();
 
   /// \return true iff the instruction is understood by MemoryOpRemark.
   static bool canHandle(const Instruction *I, const TargetLibraryInfo &TLI);
 
   void visit(const Instruction *I);
 
 protected:
-  virtual std::string explainSource(StringRef Type);
+  virtual std::string explainSource(StringRef Type) const;
 
   enum RemarkKind { RK_Store, RK_Unknown, RK_IntrinsicCall, RK_Call };
-  virtual StringRef remarkName(RemarkKind RK);
+  virtual StringRef remarkName(RemarkKind RK) const;
+
+  virtual DiagnosticKind diagnosticKind() const { return DK_OptimizationRemarkAnalysis; }
 
 private:
+  template<typename ...Ts>
+  std::unique_ptr<DiagnosticInfoIROptimization> makeRemark(Ts... Args);
+
   /// Emit a remark using information from the store's destination, size, etc.
   void visitStore(const StoreInst &SI);
   /// Emit a generic auto-init remark.
   void visitUnknown(const Instruction &I);
   /// Emit a remark using information from known intrinsic calls.
   void visitIntrinsicCall(const IntrinsicInst &II);
   /// Emit a remark using information from known function calls.
   void visitCall(const CallInst &CI);
 
   /// Add callee information to a remark: whether it's known, the function name,
   /// etc.
   template <typename FTy>
-  void visitCallee(FTy F, bool KnownLibCall, OptimizationRemarkMissed &R);
+  void visitCallee(FTy F, bool KnownLibCall, DiagnosticInfoIROptimization &R);
   /// Add operand information to a remark based on knowledge we have for known
   /// libcalls.
   void visitKnownLibCall(const CallInst &CI, LibFunc LF,
-                         OptimizationRemarkMissed &R);
+                         DiagnosticInfoIROptimization &R);
   /// Add the memory operation size to a remark.
-  void visitSizeOperand(Value *V, OptimizationRemarkMissed &R);
+  void visitSizeOperand(Value *V, DiagnosticInfoIROptimization &R);
 
   struct VariableInfo {
     Optional<StringRef> Name;
     Optional<uint64_t> Size;
     bool isEmpty() const { return !Name && !Size; }
   };
   /// Gather more information about \p V as a variable. This can be debug info,
   /// information from the alloca, etc. Since \p V can represent more than a
   /// single variable, they will all be added to the remark.
-  void visitPtr(Value *V, bool IsSrc, OptimizationRemarkMissed &R);
+  void visitPtr(Value *V, bool IsSrc, DiagnosticInfoIROptimization &R);
   void visitVariable(const Value *V, SmallVectorImpl<VariableInfo> &Result);
 };
 
 /// Special case for -ftrivial-auto-var-init remarks.
 struct AutoInitRemark : public MemoryOpRemark {
   AutoInitRemark(OptimizationRemarkEmitter &ORE, StringRef RemarkPass,
                  const DataLayout &DL, const TargetLibraryInfo &TLI)
       : MemoryOpRemark(ORE, RemarkPass, DL, TLI) {}
 
   /// \return true iff the instruction is understood by AutoInitRemark.
   static bool canHandle(const Instruction *I);
 
 protected:
-  virtual std::string explainSource(StringRef Type) override;
-  virtual StringRef remarkName(RemarkKind RK) override;
+  virtual std::string explainSource(StringRef Type) const override;
+  virtual StringRef remarkName(RemarkKind RK) const override;
+  virtual DiagnosticKind diagnosticKind() const override {
+    return DK_OptimizationRemarkMissed;
+  }
 };
 
 } // namespace llvm
 
 #endif

llvm/lib/CodeGen/GlobalISel/IRTranslator.cpp

 
 bool IRTranslator::translateKnownIntrinsic(const CallInst &CI, Intrinsic::ID ID,
                                            MachineIRBuilder &MIRBuilder) {
   if (auto *MI = dyn_cast<AnyMemIntrinsic>(&CI)) {
     if (ORE->enabled()) {
       const Function &F = *MI->getParent()->getParent();
       auto &TLI = getAnalysis<TargetLibraryInfoWrapperPass>().getTLI(F);
       if (MemoryOpRemark::canHandle(MI, TLI)) {
-        MemoryOpRemark R(*ORE, "memsize", *DL, TLI);
+        MemoryOpRemark R(*ORE, "gisel-irtranslator-memsize", *DL, TLI);
         R.visit(MI);
       }
     }
   }
 
   // If this is a simple intrinsic (that is, we just need to add a def of
   // a vreg, and uses for each arg operand, then translate it.
   if (translateSimpleIntrinsic(CI, ID, MIRBuilder))
for (auto &Arg : CB.args()) {
     Args.push_back(getOrCreateVRegs(*Arg));
   }
 
   if (auto *CI = dyn_cast<CallInst>(&CB)) {
     if (ORE->enabled()) {
       const Function &F = *CI->getParent()->getParent();
       auto &TLI = getAnalysis<TargetLibraryInfoWrapperPass>().getTLI(F);
       if (MemoryOpRemark::canHandle(CI, TLI)) {
-        MemoryOpRemark R(*ORE, "memsize", *DL, TLI);
+        MemoryOpRemark R(*ORE, "gisel-irtranslator-memsize", *DL, TLI);
         R.visit(CI);
       }
     }
   }
 
   // We don't set HasCalls on MFI here yet because call lowering may decide to
   // optimize into tail calls. Instead, we defer that to selection where a final
   // scan is done to check if any instructions are calls.

llvm/lib/Transforms/Utils/MemoryOpRemark.cpp

void MemoryOpRemark::visit(const Instruction *I) {
   if (auto *CI = dyn_cast<CallInst>(I)) {
     visitCall(*CI);
     return;
   }
 
   visitUnknown(*I);
 }
 
-std::string MemoryOpRemark::explainSource(StringRef Type) {
+std::string MemoryOpRemark::explainSource(StringRef Type) const {
   return (Type + ".").str();
 }
 
-StringRef MemoryOpRemark::remarkName(RemarkKind RK) {
+StringRef MemoryOpRemark::remarkName(RemarkKind RK) const {
   switch (RK) {
   case RK_Store:
     return "MemoryOpStore";
   case RK_Unknown:
     return "MemoryOpUnknown";
   case RK_IntrinsicCall:
     return "MemoryOpIntrinsicCall";
   case RK_Call:
     return "MemoryOpCall";
   }
   llvm_unreachable("missing RemarkKind case");
 }
 
 static void inlineVolatileOrAtomicWithExtraArgs(bool *Inline, bool Volatile,
                                                 bool Atomic,
-                                                OptimizationRemarkMissed &R) {
+                                                DiagnosticInfoIROptimization &R) {
   if (Inline && *Inline)
     R << " Inlined: " << NV("StoreInlined", true) << ".";
   if (Volatile)
     R << " Volatile: " << NV("StoreVolatile", true) << ".";
   if (Atomic)
     R << " Atomic: " << NV("StoreAtomic", true) << ".";
   // Emit the false cases under ExtraArgs. This won't show them in the remark
   // message but will end up in the serialized remarks.
   if ((Inline && !*Inline) || !Volatile || !Atomic)
     R << setExtraArgs();
   if (Inline && !*Inline)
     R << " Inlined: " << NV("StoreInlined", false) << ".";
   if (!Volatile)
     R << " Volatile: " << NV("StoreVolatile", false) << ".";
   if (!Atomic)
     R << " Atomic: " << NV("StoreAtomic", false) << ".";
 }
 
 static Optional<uint64_t> getSizeInBytes(Optional<uint64_t> SizeInBits) {
   if (!SizeInBits || *SizeInBits % 8 != 0)
     return None;
   return *SizeInBits / 8;
 }
 
+template<typename ...Ts>
+std::unique_ptr<DiagnosticInfoIROptimization>
+MemoryOpRemark::makeRemark(Ts... Args) {
+  switch (diagnosticKind()) {
+  case DK_OptimizationRemarkAnalysis:
+    return std::make_unique<OptimizationRemarkAnalysis>(Args...);
+  case DK_OptimizationRemarkMissed:
+    return std::make_unique<OptimizationRemarkMissed>(Args...);
+  default:
+    llvm_unreachable("unexpected DiagnosticKind");
+  }
+}
+
 void MemoryOpRemark::visitStore(const StoreInst &SI) {
   bool Volatile = SI.isVolatile();
   bool Atomic = SI.isAtomic();
   int64_t Size = DL.getTypeStoreSize(SI.getOperand(0)->getType());
 
-  OptimizationRemarkMissed R(RemarkPass.data(), remarkName(RK_Store), &SI);
-  R << explainSource("Store") << "\nStore size: " << NV("StoreSize", Size)
+  auto R = makeRemark(RemarkPass.data(), remarkName(RK_Store), &SI);
+  *R << explainSource("Store") << "\nStore size: " << NV("StoreSize", Size)
      << " bytes.";
-  visitPtr(SI.getOperand(1), /*IsRead=*/false, R);
-  inlineVolatileOrAtomicWithExtraArgs(nullptr, Volatile, Atomic, R);
-  ORE.emit(R);
+  visitPtr(SI.getOperand(1), /*IsRead=*/false, *R);
+  inlineVolatileOrAtomicWithExtraArgs(nullptr, Volatile, Atomic, *R);
+  ORE.emit(*R);
 }
 
 void MemoryOpRemark::visitUnknown(const Instruction &I) {
-  OptimizationRemarkMissed R(RemarkPass.data(), remarkName(RK_Unknown), &I);
-  R << explainSource("Initialization");
-  ORE.emit(R);
+  auto R = makeRemark(RemarkPass.data(), remarkName(RK_Unknown), &I);
+  *R << explainSource("Initialization");
+  ORE.emit(*R);
 }
 
 void MemoryOpRemark::visitIntrinsicCall(const IntrinsicInst &II) {
   SmallString<32> CallTo;
   bool Atomic = false;
   bool Inline = false;
   switch (II.getIntrinsicID()) {
   case Intrinsic::memcpy_inline:
void MemoryOpRemark::visitIntrinsicCall(const IntrinsicInst &II) {
   case Intrinsic::memset_element_unordered_atomic:
     CallTo = "memset";
     Atomic = true;
     break;
   default:
     return visitUnknown(II);
   }
 
-  OptimizationRemarkMissed R(RemarkPass.data(), remarkName(RK_IntrinsicCall),
-                             &II);
-  visitCallee(StringRef(CallTo), /*KnownLibCall=*/true, R);
-  visitSizeOperand(II.getOperand(2), R);
+  auto R = makeRemark(RemarkPass.data(), remarkName(RK_IntrinsicCall), &II);
+  visitCallee(StringRef(CallTo), /*KnownLibCall=*/true, *R);
+  visitSizeOperand(II.getOperand(2), *R);
 
   auto *CIVolatile = dyn_cast<ConstantInt>(II.getOperand(3));
   // No such thing as a memory intrinsic that is both atomic and volatile.
   bool Volatile = !Atomic && CIVolatile && CIVolatile->getZExtValue();
   switch (II.getIntrinsicID()) {
   case Intrinsic::memcpy_inline:
   case Intrinsic::memcpy:
   case Intrinsic::memmove:
   case Intrinsic::memcpy_element_unordered_atomic:
-    visitPtr(II.getOperand(1), /*IsRead=*/true, R);
-    visitPtr(II.getOperand(0), /*IsRead=*/false, R);
+    visitPtr(II.getOperand(1), /*IsRead=*/true, *R);
+    visitPtr(II.getOperand(0), /*IsRead=*/false, *R);
     break;
   case Intrinsic::memset:
   case Intrinsic::memset_element_unordered_atomic:
-    visitPtr(II.getOperand(0), /*IsRead=*/false, R);
+    visitPtr(II.getOperand(0), /*IsRead=*/false, *R);
     break;
   }
-  inlineVolatileOrAtomicWithExtraArgs(&Inline, Volatile, Atomic, R);
-  ORE.emit(R);
+  inlineVolatileOrAtomicWithExtraArgs(&Inline, Volatile, Atomic, *R);
+  ORE.emit(*R);
 }
 
 void MemoryOpRemark::visitCall(const CallInst &CI) {
   Function *F = CI.getCalledFunction();
   if (!F)
     return visitUnknown(CI);
 
   LibFunc LF;
   bool KnownLibCall = TLI.getLibFunc(*F, LF) && TLI.has(LF);
-  OptimizationRemarkMissed R(RemarkPass.data(), remarkName(RK_Call), &CI);
-  visitCallee(F, KnownLibCall, R);
-  visitKnownLibCall(CI, LF, R);
-  ORE.emit(R);
+  auto R = makeRemark(RemarkPass.data(), remarkName(RK_Call), &CI);
+  visitCallee(F, KnownLibCall, *R);
+  visitKnownLibCall(CI, LF, *R);
+  ORE.emit(*R);
 }
 
 template <typename FTy>
 void MemoryOpRemark::visitCallee(FTy F, bool KnownLibCall,
-                                 OptimizationRemarkMissed &R) {
+                                 DiagnosticInfoIROptimization &R) {
   R << "Call to ";
   if (!KnownLibCall)
     R << NV("UnknownLibCall", "unknown") << " function ";
   R << NV("Callee", F) << explainSource("");
 }
 
 void MemoryOpRemark::visitKnownLibCall(const CallInst &CI, LibFunc LF,
-                                       OptimizationRemarkMissed &R) {
+                                       DiagnosticInfoIROptimization &R) {
   switch (LF) {
   default:
     return;
   case LibFunc_memset_chk:
   case LibFunc_memset:
     visitSizeOperand(CI.getOperand(2), R);
     visitPtr(CI.getOperand(0), /*IsRead=*/false, R);
     break;
void MemoryOpRemark::visitKnownLibCall(const CallInst &CI, LibFunc LF,
   case LibFunc_bcopy:
     visitSizeOperand(CI.getOperand(2), R);
     visitPtr(CI.getOperand(1), /*IsRead=*/true, R);
     visitPtr(CI.getOperand(0), /*IsRead=*/false, R);
     break;
   }
 }
 
-void MemoryOpRemark::visitSizeOperand(Value *V, OptimizationRemarkMissed &R) {
+void MemoryOpRemark::visitSizeOperand(Value *V, DiagnosticInfoIROptimization &R) {
   if (auto *Len = dyn_cast<ConstantInt>(V)) {
     uint64_t Size = Len->getZExtValue();
     R << " Memory operation size: " << NV("StoreSize", Size) << " bytes.";
   }
 }
 
 static Optional<StringRef> nameOrNone(const Value *V) {
   if (V->hasName())
void MemoryOpRemark::visitVariable(const Value *V,
   Optional<TypeSize> TySize = AI->getAllocationSizeInBits(DL);
   Optional<uint64_t> Size =
       TySize ? getSizeInBytes(TySize->getFixedSize()) : None;
   VariableInfo Var{nameOrNone(AI), Size};
   if (!Var.isEmpty())
     Result.push_back(std::move(Var));
 }
 
-void MemoryOpRemark::visitPtr(Value *Ptr, bool IsRead, OptimizationRemarkMissed &R) {
+void MemoryOpRemark::visitPtr(Value *Ptr, bool IsRead, DiagnosticInfoIROptimization &R) {
   // Find if Ptr is a known variable we can give more information on.
   SmallVector<Value *, 2> Objects;
   getUnderlyingObjectsForCodeGen(Ptr, Objects);
   SmallVector<VariableInfo, 2> VIs;
   for (const Value *V : Objects)
     visitVariable(V, VIs);
 
   if (VIs.empty()) {
bool AutoInitRemark::canHandle(const Instruction *I) {
   if (!I->hasMetadata(LLVMContext::MD_annotation))
     return false;
   return any_of(I->getMetadata(LLVMContext::MD_annotation)->operands(),
                 [](const MDOperand &Op) {
                   return cast<MDString>(Op.get())->getString() == "auto-init";
                 });
 }
 
-std::string AutoInitRemark::explainSource(StringRef Type) {
+std::string AutoInitRemark::explainSource(StringRef Type) const {
   return (Type + " inserted by -ftrivial-auto-var-init.").str();
 }
 
-StringRef AutoInitRemark::remarkName(RemarkKind RK) {
+StringRef AutoInitRemark::remarkName(RemarkKind RK) const {
   switch (RK) {
   case RK_Store:
     return "AutoInitStore";
   case RK_Unknown:
     return "AutoInitUnknownInstruction";
   case RK_IntrinsicCall:
     return "AutoInitIntrinsicCall";
   case RK_Call:
     return "AutoInitCall";
   }
   llvm_unreachable("missing RemarkKind case");
 }

llvm/test/CodeGen/AArch64/memsize-remarks.ll

-; RUN: llc %s -pass-remarks-missed=memsize -pass-remarks-output=%t.opt.yaml -pass-remarks-filter=memsize -global-isel -o /dev/null 2>&1 | FileCheck %s --check-prefix=GISEL --implicit-check-not=GISEL
+; RUN: llc %s -pass-remarks-analysis=gisel-irtranslator-memsize -pass-remarks-output=%t.opt.yaml -pass-remarks-filter=gisel-irtranslator-memsize -global-isel -o /dev/null 2>&1 | FileCheck %s --check-prefix=GISEL --implicit-check-not=GISEL
 ; RUN: cat %t.opt.yaml | FileCheck -check-prefix=YAML %s
 
 source_filename = "memsize.c"
 target datalayout = "e-m:o-i64:64-i128:128-n32:64-S128"
 target triple = "arm64-apple-ios7.0.0"
 
 declare i8* @__memmove_chk(i8*, i8*, i64, i64) #1
 declare i8* @__memcpy_chk(i8*, i8*, i64, i64) #1

 }
 
 ; Emit remarks for memcpy, memmove, memset, bzero, bcopy with known constant
 ; sizes to an object of known size.
 define void @known_call_with_dereferenceable_bytes(i8* dereferenceable(42) %dst, i8* dereferenceable(314) %src) {
 ; GISEL: Call to memset. Memory operation size: 1 bytes.
 ; GISEL-NOT:  Read Variables:
 ; GISEL-NEXT:  Written Variables: <unknown> (42 bytes).
-; YAML:       --- !Missed
-; YAML:       Pass:            memsize
+; YAML:       --- !Analysis
+; YAML:       gisel-irtranslator-memsize
 ; YAML:       Name:            MemoryOpIntrinsicCall
 ; YAML-LABEL: Function:        known_call_with_dereferenceable_bytes
 ; YAML-NEXT:  Args:
 ; YAML-NEXT:    - String:          'Call to '
 ; YAML-NEXT:    - Callee:          memset
 ; YAML-NEXT:    - String:          .
 ; YAML-NEXT:    - String:          ' Memory operation size: '
 ; YAML-NEXT:    - StoreSize:       '1'

 ; YAML-NEXT:    - StoreAtomic:     'false'
 ; YAML-NEXT:    - String:          .
 ; YAML-NEXT:  ...
   call void @llvm.memset.p0i8.i64(i8* %dst, i8 0, i64 1, i1 false)
 
 ; GISEL: Call to memcpy. Memory operation size: 1 bytes.
 ; GISEL-NEXT:  Read Variables: <unknown> (314 bytes).
 ; GISEL-NEXT:  Written Variables: <unknown> (42 bytes).
-; YAML:       --- !Missed
-; YAML:       Pass:            memsize
+; YAML:       --- !Analysis
+; YAML:       gisel-irtranslator-memsize
 ; YAML:       Name:            MemoryOpIntrinsicCall
 ; YAML-LABEL: Function:        known_call_with_dereferenceable_bytes
 ; YAML-NEXT:  Args:
 ; YAML-NEXT:    - String:          'Call to '
 ; YAML-NEXT:    - Callee:          memcpy
 ; YAML-NEXT:    - String:          .
 ; YAML-NEXT:    - String:          ' Memory operation size: '
 ; YAML-NEXT:    - StoreSize:       '1'

 ; YAML-NEXT:    - StoreAtomic:     'false'
 ; YAML-NEXT:    - String:          .
 ; YAML-NEXT:  ...
   call void @llvm.memcpy.p0i8.p0i8.i64(i8* %dst, i8* %src, i64 1, i1 false)
 
 ; GISEL: Call to memmove. Memory operation size: 1 bytes.
 ; GISEL-NEXT:  Read Variables: <unknown> (314 bytes).
 ; GISEL-NEXT:  Written Variables: <unknown> (42 bytes).
-; YAML:       --- !Missed
-; YAML:       Pass:            memsize
+; YAML:       --- !Analysis
+; YAML:       gisel-irtranslator-memsize
 ; YAML:       Name:            MemoryOpIntrinsicCall
 ; YAML-LABEL: Function:        known_call_with_dereferenceable_bytes
 ; YAML-NEXT:  Args:
 ; YAML-NEXT:    - String:          'Call to '
 ; YAML-NEXT:    - Callee:          memmove
 ; YAML-NEXT:    - String:          .
 ; YAML-NEXT:    - String:          ' Memory operation size: '
 ; YAML-NEXT:    - StoreSize:       '1'

 ; YAML-NEXT:    - StoreAtomic:     'false'
 ; YAML-NEXT:    - String:          .
 ; YAML-NEXT:  ...
   call void @llvm.memmove.p0i8.p0i8.i64(i8* %dst, i8* %src, i64 1, i1 false)
 
 ; GISEL: Call to bzero. Memory operation size: 1 bytes.
 ; GISEL-NOT:  Read Variables:
 ; GISEL-NEXT:  Written Variables: <unknown> (42 bytes).
-; YAML:       --- !Missed
-; YAML:       Pass:            memsize
+; YAML:       --- !Analysis
+; YAML:       gisel-irtranslator-memsize
 ; YAML:       Name:            MemoryOpCall
 ; YAML-LABEL: Function:        known_call_with_dereferenceable_bytes
 ; YAML-NEXT:  Args:
 ; YAML-NEXT:    - String:          'Call to '
 ; YAML-NEXT:    - Callee:          bzero
 ; YAML-NEXT:    - String:          .
 ; YAML-NEXT:    - String:          ' Memory operation size: '
 ; YAML-NEXT:    - StoreSize:       '1'
 ; YAML-NEXT:    - String:          ' bytes.'
 ; YAML-NEXT:    - String:          "\n Written Variables: "
 ; YAML-NEXT:    - WVarName:        '<unknown>'
 ; YAML-NEXT:    - String:          ' ('
 ; YAML-NEXT:    - WVarSize:        '42'
 ; YAML-NEXT:    - String:          ' bytes)'
 ; YAML-NEXT:    - String:          .
 ; YAML-NEXT:  ...
   call void @bzero(i8* %dst, i64 1)
 
 ; GISEL: Call to bcopy. Memory operation size: 1 bytes.
 ; GISEL-NEXT:  Read Variables: <unknown> (314 bytes).
 ; GISEL-NEXT:  Written Variables: <unknown> (42 bytes).
-; YAML:       --- !Missed
-; YAML:       Pass:            memsize
+; YAML:       --- !Analysis
+; YAML:       gisel-irtranslator-memsize
 ; YAML:       Name:            MemoryOpCall
 ; YAML-LABEL: Function:        known_call_with_dereferenceable_bytes
 ; YAML-NEXT:  Args:
 ; YAML-NEXT:    - String:          'Call to '
 ; YAML-NEXT:    - Callee:          bcopy
 ; YAML-NEXT:    - String:          .
 ; YAML-NEXT:    - String:          ' Memory operation size: '
 ; YAML-NEXT:    - StoreSize:       '1'