[InstCombine] Preserve !annotation on newly created instructions.

[fhahn]

Summary

If the source instruction has !annotation metadata, all instructions
created during combining should also have it. Tell the builder to
add it.

The !annotation system was discussed on llvm-dev as part of
'RFC: Combining Annotation Metadata and Remarks'
(http://lists.llvm.org/pipermail/llvm-dev/2020-November/146393.html)

This patch is based on an earlier patch by Francis Visoiu Mistrih.

[lebedev.ri]

Can you please add a link to the patches/maillist disscussions about said annotation?
What about teaching IRBuilder to deal with it like it deals with debugloc?

[fhahn]

In D91444#2394512, @lebedev.ri wrote:

Can you please add a link to the patches/maillist disscussions about said annotation?
What about teaching IRBuilder to deal with it like it deals with debugloc?

Sure, I updated the description.

The !annotation system was discussed on llvm-dev as part of 'RFC: Combining Annotation Metadata and Remarks' (http://lists.llvm.org/pipermail/llvm-dev/2020-November/146393.html)

[thegameg]

llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp

1105

Why not copyMetadata here?

[fhahn]

In D91444#2394512, @lebedev.ri wrote:

What about teaching IRBuilder to deal with it like it deals with debugloc?

Done! Together with D93400 this patch now boils down to requesting !annotation to be preserved for instructions created by IRBuilder.

[thegameg]

LGTM, nice!

[lebedev.ri]

In D91444#2458024, @fhahn wrote:

In D91444#2394512, @lebedev.ri wrote:

What about teaching IRBuilder to deal with it like it deals with debugloc?

Done! Together with D93400 this patch now boils down to requesting !annotation to be preserved for instructions created by IRBuilder.

Yay, now this does look good to me.
Thanks.

llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp

if (M->getNumOperands() == 3 && M->getOperand(0) &&
       CopyMD = cast<MDNode>(M->getOperand(2));
   }
 
   Value *Src = Builder.CreateBitCast(MI->getArgOperand(1), NewSrcPtrTy);
   Value *Dest = Builder.CreateBitCast(MI->getArgOperand(0), NewDstPtrTy);
   LoadInst *L = Builder.CreateLoad(IntType, Src);
   // Alignment from the mem intrinsic will be better, so use it.
   L->setAlignment(*CopySrcAlign);
+  L->copyMetadata(*MI,
+                  {LLVMContext::MD_access_group, LLVMContext::MD_annotation,
+                   LLVMContext::MD_mem_parallel_loop_access});
   if (CopyMD)
     L->setMetadata(LLVMContext::MD_tbaa, CopyMD);
-  MDNode *LoopMemParallelMD =
-    MI->getMetadata(LLVMContext::MD_mem_parallel_loop_access);
-  if (LoopMemParallelMD)
-    L->setMetadata(LLVMContext::MD_mem_parallel_loop_access, LoopMemParallelMD);
-  MDNode *AccessGroupMD = MI->getMetadata(LLVMContext::MD_access_group);
-  if (AccessGroupMD)
-    L->setMetadata(LLVMContext::MD_access_group, AccessGroupMD);
 
   StoreInst *S = Builder.CreateStore(L, Dest);
   // Alignment from the mem intrinsic will be better, so use it.
   S->setAlignment(*CopyDstAlign);
+
+  S->copyMetadata(*MI,
+                  {LLVMContext::MD_access_group, LLVMContext::MD_annotation,
+                   LLVMContext::MD_mem_parallel_loop_access});
   if (CopyMD)
     S->setMetadata(LLVMContext::MD_tbaa, CopyMD);
-  if (LoopMemParallelMD)
-    S->setMetadata(LLVMContext::MD_mem_parallel_loop_access, LoopMemParallelMD);
-  if (AccessGroupMD)
-    S->setMetadata(LLVMContext::MD_access_group, AccessGroupMD);
 
   if (auto *MT = dyn_cast<MemTransferInst>(MI)) {
     // non-atomics can be volatile
     L->setVolatile(MT->isVolatile());
     S->setVolatile(MT->isVolatile());
   }
   if (isa<AtomicMemTransferInst>(MI)) {
     // atomics have to be unordered
if (Len <= 8 && isPowerOf2_32((uint32_t)Len)) {
 
     // Extract the fill value and store.
     uint64_t Fill = FillC->getZExtValue()*0x0101010101010101ULL;
     StoreInst *S = Builder.CreateStore(ConstantInt::get(ITy, Fill), Dest,
                                        MI->isVolatile());
     S->setAlignment(Alignment);
     if (isa<AtomicMemSetInst>(MI))
       S->setOrdering(AtomicOrdering::Unordered);
+    S->copyMetadata(*MI, {LLVMContext::MD_annotation});
 
     // Set the size of the copy to 0, it will be deleted on the next iteration.
     MI->setLength(Constant::getNullValue(LenC->getType()));
     return MI;
   }
 
   return nullptr;
 }

llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp

Value *LibCallSimplifier::optimizeMemCpy(CallInst *CI, IRBuilderBase &B) {
   annotateNonNullAndDereferenceable(CI, {0, 1}, Size, DL);
   if (isa<IntrinsicInst>(CI))
     return nullptr;
 
   // memcpy(x, y, n) -> llvm.memcpy(align 1 x, align 1 y, n)
   CallInst *NewCI = B.CreateMemCpy(CI->getArgOperand(0), Align(1),
                                    CI->getArgOperand(1), Align(1), Size);
   NewCI->setAttributes(CI->getAttributes());
+  if (MDNode *AnnotationMD = CI->getMetadata(LLVMContext::MD_annotation))
+    NewCI->setMetadata(LLVMContext::MD_annotation, AnnotationMD);
   return CI->getArgOperand(0);
 }
 
 Value *LibCallSimplifier::optimizeMemCCpy(CallInst *CI, IRBuilderBase &B) {
   Value *Dst = CI->getArgOperand(0);
   Value *Src = CI->getArgOperand(1);
   ConstantInt *StopChar = dyn_cast<ConstantInt>(CI->getArgOperand(2));
   ConstantInt *N = dyn_cast<ConstantInt>(CI->getArgOperand(3));
Value *LibCallSimplifier::optimizeMemMove(CallInst *CI, IRBuilderBase &B) {
   annotateNonNullAndDereferenceable(CI, {0, 1}, Size, DL);
   if (isa<IntrinsicInst>(CI))
     return nullptr;
 
   // memmove(x, y, n) -> llvm.memmove(align 1 x, align 1 y, n)
   CallInst *NewCI = B.CreateMemMove(CI->getArgOperand(0), Align(1),
                                     CI->getArgOperand(1), Align(1), Size);
   NewCI->setAttributes(CI->getAttributes());
+  if (MDNode *AnnotationMD = CI->getMetadata(LLVMContext::MD_annotation))
+    NewCI->setMetadata(LLVMContext::MD_annotation, AnnotationMD);
   return CI->getArgOperand(0);
 }
 
 /// Fold memset[_chk](malloc(n), 0, n) --> calloc(1, n).
 Value *LibCallSimplifier::foldMallocMemset(CallInst *Memset, IRBuilderBase &B) {
   // This has to be a memset of zeros (bzero).
   auto *FillValue = dyn_cast<ConstantInt>(Memset->getArgOperand(1));
   if (!FillValue || FillValue->getZExtValue() != 0)
Value *LibCallSimplifier::optimizeMemSet(CallInst *CI, IRBuilderBase &B) {
 
   if (auto *Calloc = foldMallocMemset(CI, B))
     return Calloc;
 
   // memset(p, v, n) -> llvm.memset(align 1 p, v, n)
   Value *Val = B.CreateIntCast(CI->getArgOperand(1), B.getInt8Ty(), false);
   CallInst *NewCI = B.CreateMemSet(CI->getArgOperand(0), Val, Size, Align(1));
   NewCI->setAttributes(CI->getAttributes());
+  if (MDNode *AnnotationMD = CI->getMetadata(LLVMContext::MD_annotation))
+    NewCI->setMetadata(LLVMContext::MD_annotation, AnnotationMD);
   return CI->getArgOperand(0);
 }
 
 Value *LibCallSimplifier::optimizeRealloc(CallInst *CI, IRBuilderBase &B) {
   if (isa<ConstantPointerNull>(CI->getArgOperand(0)))
     return emitMalloc(CI->getArgOperand(1), B, DL, TLI);
 
   return nullptr;

 
 Value *FortifiedLibCallSimplifier::optimizeMemCpyChk(CallInst *CI,
                                                      IRBuilderBase &B) {
   if (isFortifiedCallFoldable(CI, 3, 2)) {
     CallInst *NewCI =
         B.CreateMemCpy(CI->getArgOperand(0), Align(1), CI->getArgOperand(1),
                        Align(1), CI->getArgOperand(2));
     NewCI->setAttributes(CI->getAttributes());
+    if (MDNode *AnnotationMD = CI->getMetadata(LLVMContext::MD_annotation))
+      NewCI->setMetadata(LLVMContext::MD_annotation, AnnotationMD);
     return CI->getArgOperand(0);
   }
   return nullptr;
 }
 
 Value *FortifiedLibCallSimplifier::optimizeMemMoveChk(CallInst *CI,
                                                       IRBuilderBase &B) {
   if (isFortifiedCallFoldable(CI, 3, 2)) {
     CallInst *NewCI =
         B.CreateMemMove(CI->getArgOperand(0), Align(1), CI->getArgOperand(1),
                         Align(1), CI->getArgOperand(2));
     NewCI->setAttributes(CI->getAttributes());
+    if (MDNode *AnnotationMD = CI->getMetadata(LLVMContext::MD_annotation))
+      NewCI->setMetadata(LLVMContext::MD_annotation, AnnotationMD);
     return CI->getArgOperand(0);
   }
   return nullptr;
 }
 
 Value *FortifiedLibCallSimplifier::optimizeMemSetChk(CallInst *CI,
                                                      IRBuilderBase &B) {
   // TODO: Try foldMallocMemset() here.
 
   if (isFortifiedCallFoldable(CI, 3, 2)) {
     Value *Val = B.CreateIntCast(CI->getArgOperand(1), B.getInt8Ty(), false);
     CallInst *NewCI = B.CreateMemSet(CI->getArgOperand(0), Val,
                                      CI->getArgOperand(2), Align(1));
     NewCI->setAttributes(CI->getAttributes());
+    if (MDNode *AnnotationMD = CI->getMetadata(LLVMContext::MD_annotation))
+      NewCI->setMetadata(LLVMContext::MD_annotation, AnnotationMD);
     return CI->getArgOperand(0);
   }
   return nullptr;
 }
 
 Value *FortifiedLibCallSimplifier::optimizeMemPCpyChk(CallInst *CI,
                                                       IRBuilderBase &B) {
   const DataLayout &DL = CI->getModule()->getDataLayout();

llvm/test/Transforms/InstCombine/annotations.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -instcombine -S | FileCheck %s
 
 ; memcpy can be expanded inline with load/store. Verify that we keep the
 ; !annotation metadata.
 
 declare void @llvm.memcpy.p0i8.p0i8.i32(i8* nocapture, i8* nocapture, i32, i1) nounwind
 
 define void @copy_1_byte(i8* %d, i8* %s) {
 ; CHECK-LABEL: @copy_1_byte(
-; CHECK-NEXT:    [[TMP1:%.*]] = load i8, i8* [[S:%.*]], align 1
-; CHECK-NEXT:    store i8 [[TMP1]], i8* [[D:%.*]], align 1
+; CHECK-NEXT:    [[TMP1:%.*]] = load i8, i8* [[S:%.*]], align 1, !annotation !0
+; CHECK-NEXT:    store i8 [[TMP1]], i8* [[D:%.*]], align 1, !annotation !0
 ; CHECK-NEXT:    ret void
 ;
   call void @llvm.memcpy.p0i8.p0i8.i32(i8* %d, i8* %s, i32 1, i1 false), !annotation !0
   ret void
 }
 
 declare i8* @memcpy(i8* noalias returned, i8* noalias nocapture readonly, i64) nofree nounwind
 
 define void @libcallcopy_1_byte(i8* %d, i8* %s) {
 ; CHECK-LABEL: @libcallcopy_1_byte(
-; CHECK-NEXT:    [[TMP1:%.*]] = load i8, i8* [[S:%.*]], align 1
-; CHECK-NEXT:    store i8 [[TMP1]], i8* [[D:%.*]], align 1
+; CHECK-NEXT:    [[TMP1:%.*]] = load i8, i8* [[S:%.*]], align 1, !annotation !0
+; CHECK-NEXT:    store i8 [[TMP1]], i8* [[D:%.*]], align 1, !annotation !0
 ; CHECK-NEXT:    ret void
 ;
   call i8* @memcpy(i8* %d, i8* %s, i64 1), !annotation !0
   ret void
 }
 
 declare i8* @__memcpy_chk(i8*, i8*, i64, i64) nofree nounwind
 
 define void @libcallcopy_1_byte_chk(i8* %d, i8* %s) {
 ; CHECK-LABEL: @libcallcopy_1_byte_chk(
-; CHECK-NEXT:    [[TMP1:%.*]] = load i8, i8* [[S:%.*]], align 1
-; CHECK-NEXT:    store i8 [[TMP1]], i8* [[D:%.*]], align 1
+; CHECK-NEXT:    [[TMP1:%.*]] = load i8, i8* [[S:%.*]], align 1, !annotation !0
+; CHECK-NEXT:    store i8 [[TMP1]], i8* [[D:%.*]], align 1, !annotation !0
 ; CHECK-NEXT:    ret void
 ;
   call i8* @__memcpy_chk(i8* %d, i8* %s, i64 1, i64 1), !annotation !0
   ret void
 }
 
 declare void @llvm.memmove.p0i8.p0i8.i32(i8* nocapture, i8* nocapture readonly, i32, i1) nounwind
 
 define void @move_1_byte(i8* %d, i8* %s) {
 ; CHECK-LABEL: @move_1_byte(
-; CHECK-NEXT:    [[TMP1:%.*]] = load i8, i8* [[S:%.*]], align 1
-; CHECK-NEXT:    store i8 [[TMP1]], i8* [[D:%.*]], align 1
+; CHECK-NEXT:    [[TMP1:%.*]] = load i8, i8* [[S:%.*]], align 1, !annotation !0
+; CHECK-NEXT:    store i8 [[TMP1]], i8* [[D:%.*]], align 1, !annotation !0
 ; CHECK-NEXT:    ret void
 ;
   call void @llvm.memmove.p0i8.p0i8.i32(i8* %d, i8* %s, i32 1, i1 false), !annotation !0
   ret void
 }
 
 declare i8* @memmove(i8* returned, i8* nocapture readonly, i64) nofree nounwind
 
 define void @libcallmove_1_byte(i8* %d, i8* %s) {
 ; CHECK-LABEL: @libcallmove_1_byte(
-; CHECK-NEXT:    [[TMP1:%.*]] = load i8, i8* [[S:%.*]], align 1
-; CHECK-NEXT:    store i8 [[TMP1]], i8* [[D:%.*]], align 1
+; CHECK-NEXT:    [[TMP1:%.*]] = load i8, i8* [[S:%.*]], align 1, !annotation !0
+; CHECK-NEXT:    store i8 [[TMP1]], i8* [[D:%.*]], align 1, !annotation !0
 ; CHECK-NEXT:    ret void
 ;
   call i8* @memmove(i8* %d, i8* %s, i64 1), !annotation !0
   ret void
 }
 
 declare i8* @__memmove_chk(i8*, i8*, i64, i64) nofree nounwind
 
 define void @libcallmove_1_byte_chk(i8* %d, i8* %s) {
 ; CHECK-LABEL: @libcallmove_1_byte_chk(
-; CHECK-NEXT:    [[TMP1:%.*]] = load i8, i8* [[S:%.*]], align 1
-; CHECK-NEXT:    store i8 [[TMP1]], i8* [[D:%.*]], align 1
+; CHECK-NEXT:    [[TMP1:%.*]] = load i8, i8* [[S:%.*]], align 1, !annotation !0
+; CHECK-NEXT:    store i8 [[TMP1]], i8* [[D:%.*]], align 1, !annotation !0
 ; CHECK-NEXT:    ret void
 ;
   call i8* @__memmove_chk(i8* %d, i8* %s, i64 1, i64 1), !annotation !0
   ret void
 }
 
 declare void @llvm.memset.p0i8.i32(i8* nocapture writeonly, i8, i32, i1) argmemonly nounwind
 
 define void @set_1_byte(i8* %d) {
 ; CHECK-LABEL: @set_1_byte(
-; CHECK-NEXT:    store i8 1, i8* [[D:%.*]], align 1
+; CHECK-NEXT:    store i8 1, i8* [[D:%.*]], align 1, !annotation !0
 ; CHECK-NEXT:    ret void
 ;
   call void @llvm.memset.p0i8.i32(i8* %d, i8 1, i32 1, i1 false), !annotation !0
   ret void
 }
 
 declare i8* @memset(i8*, i32, i64) nofree
 
 define void @libcall_set_1_byte(i8* %d) {
 ; CHECK-LABEL: @libcall_set_1_byte(
-; CHECK-NEXT:    store i8 1, i8* [[D:%.*]], align 1
+; CHECK-NEXT:    store i8 1, i8* [[D:%.*]], align 1, !annotation !0
 ; CHECK-NEXT:    ret void
 ;
   call i8* @memset(i8* %d, i32 1, i64 1), !annotation !0
   ret void
 }
 
 declare i8* @__memset_chk(i8*, i32, i64, i64) nofree
 
 define void @libcall_set_1_byte_chk(i8* %d) {
 ; CHECK-LABEL: @libcall_set_1_byte_chk(
-; CHECK-NEXT:    store i8 1, i8* [[D:%.*]], align 1
+; CHECK-NEXT:    store i8 1, i8* [[D:%.*]], align 1, !annotation !0
 ; CHECK-NEXT:    ret void
 ;
   call i8* @__memset_chk(i8* %d, i32 1, i64 1, i64 1), !annotation !0
   ret void
 }
 
 !0 = !{ !"auto-init" }