From 7caefab1703facdeb00b63f5d93f528ff7fa90c0 Mon Sep 17 00:00:00 2001 From: Keno Fischer Date: Wed, 28 Jun 2017 23:36:40 +0000 Subject: [PATCH] [InstCombine] Retain TBAA when narrowing memory accesses Summary: As discussed on the mailing list it is legal to propagate TBAA to loads/stores from/to smaller regions of a larger load tagged with TBAA. Do so for (load->extractvalue)=>(gep->load) and similar foldings. Reviewed By: sanjoy Differential Revision: https://reviews.llvm.org/D31954 git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@306615 91177308-0d34-0410-b5e6-96231b3b80d8 --- .../InstCombineLoadStoreAlloca.cpp | 24 +++++++++- .../InstCombine/InstructionCombining.cpp | 8 +++- .../InstCombine/extractinsert-tbaa.ll | 45 +++++++++++++++++++ 3 files changed, 74 insertions(+), 3 deletions(-) create mode 100644 test/Transforms/InstCombine/extractinsert-tbaa.ll diff --git a/lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp b/lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp index ca370c73fca..26bee204e5a 100644 --- a/lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp +++ b/lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp @@ -661,6 +661,9 @@ static Instruction *unpackLoadToAggregate(InstCombiner &IC, LoadInst &LI) { if (NumElements == 1) { LoadInst *NewLoad = combineLoadToNewType(IC, LI, ST->getTypeAtIndex(0U), ".unpack"); + AAMDNodes AAMD; + LI.getAAMetadata(AAMD); + NewLoad->setAAMetadata(AAMD); return IC.replaceInstUsesWith(LI, IC.Builder->CreateInsertValue( UndefValue::get(T), NewLoad, 0, Name)); } @@ -690,6 +693,10 @@ static Instruction *unpackLoadToAggregate(InstCombiner &IC, LoadInst &LI) { Name + ".elt"); auto EltAlign = MinAlign(Align, SL->getElementOffset(i)); auto *L = IC.Builder->CreateAlignedLoad(Ptr, EltAlign, Name + ".unpack"); + // Propagate AA metadata. It'll still be valid on the narrowed load. + AAMDNodes AAMD; + LI.getAAMetadata(AAMD); + L->setAAMetadata(AAMD); V = IC.Builder->CreateInsertValue(V, L, i); } @@ -702,6 +709,9 @@ static Instruction *unpackLoadToAggregate(InstCombiner &IC, LoadInst &LI) { auto NumElements = AT->getNumElements(); if (NumElements == 1) { LoadInst *NewLoad = combineLoadToNewType(IC, LI, ET, ".unpack"); + AAMDNodes AAMD; + LI.getAAMetadata(AAMD); + NewLoad->setAAMetadata(AAMD); return IC.replaceInstUsesWith(LI, IC.Builder->CreateInsertValue( UndefValue::get(T), NewLoad, 0, Name)); } @@ -734,6 +744,9 @@ static Instruction *unpackLoadToAggregate(InstCombiner &IC, LoadInst &LI) { Name + ".elt"); auto *L = IC.Builder->CreateAlignedLoad(Ptr, MinAlign(Align, Offset), Name + ".unpack"); + AAMDNodes AAMD; + LI.getAAMetadata(AAMD); + L->setAAMetadata(AAMD); V = IC.Builder->CreateInsertValue(V, L, i); Offset += EltSize; } @@ -1192,7 +1205,11 @@ static bool unpackStoreToAggregate(InstCombiner &IC, StoreInst &SI) { AddrName); auto *Val = IC.Builder->CreateExtractValue(V, i, EltName); auto EltAlign = MinAlign(Align, SL->getElementOffset(i)); - IC.Builder->CreateAlignedStore(Val, Ptr, EltAlign); + llvm::Instruction *NS = + IC.Builder->CreateAlignedStore(Val, Ptr, EltAlign); + AAMDNodes AAMD; + SI.getAAMetadata(AAMD); + NS->setAAMetadata(AAMD); } return true; @@ -1239,7 +1256,10 @@ static bool unpackStoreToAggregate(InstCombiner &IC, StoreInst &SI) { AddrName); auto *Val = IC.Builder->CreateExtractValue(V, i, EltName); auto EltAlign = MinAlign(Align, Offset); - IC.Builder->CreateAlignedStore(Val, Ptr, EltAlign); + Instruction *NS = IC.Builder->CreateAlignedStore(Val, Ptr, EltAlign); + AAMDNodes AAMD; + SI.getAAMetadata(AAMD); + NS->setAAMetadata(AAMD); Offset += EltSize; } diff --git a/lib/Transforms/InstCombine/InstructionCombining.cpp b/lib/Transforms/InstCombine/InstructionCombining.cpp index 02fac4fb37a..723414635d6 100644 --- a/lib/Transforms/InstCombine/InstructionCombining.cpp +++ b/lib/Transforms/InstCombine/InstructionCombining.cpp @@ -2425,9 +2425,15 @@ Instruction *InstCombiner::visitExtractValueInst(ExtractValueInst &EV) { Builder->SetInsertPoint(L); Value *GEP = Builder->CreateInBoundsGEP(L->getType(), L->getPointerOperand(), Indices); + Instruction *NL = Builder->CreateLoad(GEP); + // Whatever aliasing information we had for the orignal load must also + // hold for the smaller load, so propagate the annotations. + AAMDNodes Nodes; + L->getAAMetadata(Nodes); + NL->setAAMetadata(Nodes); // Returning the load directly will cause the main loop to insert it in // the wrong spot, so use replaceInstUsesWith(). - return replaceInstUsesWith(EV, Builder->CreateLoad(GEP)); + return replaceInstUsesWith(EV, NL); } // We could simplify extracts from other values. Note that nested extracts may // already be simplified implicitly by the above: extract (extract (insert) ) diff --git a/test/Transforms/InstCombine/extractinsert-tbaa.ll b/test/Transforms/InstCombine/extractinsert-tbaa.ll new file mode 100644 index 00000000000..b2a3a1a1bf9 --- /dev/null +++ b/test/Transforms/InstCombine/extractinsert-tbaa.ll @@ -0,0 +1,45 @@ +; RUN: opt -S -instcombine %s -o - | FileCheck %s + +%Complex = type { double, double } + +; Check that instcombine preserves TBAA when narrowing loads +define double @teststructextract(%Complex *%val) { +; CHECK: load double, {{.*}}, !tbaa +; CHECK-NOT: load %Complex + %loaded = load %Complex, %Complex *%val, !tbaa !1 + %real = extractvalue %Complex %loaded, 0 + ret double %real +} + +define double @testarrayextract([2 x double] *%val) { +; CHECK: load double, {{.*}}, !tbaa +; CHECK-NOT: load [2 x double] + %loaded = load [2 x double], [2 x double] *%val, !tbaa !1 + %real = extractvalue [2 x double] %loaded, 0 + ret double %real +} + +; Check that inscombine preserves TBAA when breaking up stores +define void @teststructinsert(%Complex *%loc, double %a, double %b) { +; CHECK: store double %a, {{.*}}, !tbaa +; CHECK: store double %b, {{.*}}, !tbaa +; CHECK-NOT: store %Complex + %inserted = insertvalue %Complex undef, double %a, 0 + %inserted2 = insertvalue %Complex %inserted, double %b, 1 + store %Complex %inserted2, %Complex *%loc, !tbaa !1 + ret void +} + +define void @testarrayinsert([2 x double] *%loc, double %a, double %b) { +; CHECK: store double %a, {{.*}}, !tbaa +; CHECK: store double %b, {{.*}}, !tbaa +; CHECK-NOT: store [2 x double] + %inserted = insertvalue [2 x double] undef, double %a, 0 + %inserted2 = insertvalue [2 x double] %inserted, double %b, 1 + store [2 x double] %inserted2, [2 x double] *%loc, !tbaa !1 + ret void +} + +!0 = !{!"tbaa_root"} +!1 = !{!2, !2, i64 0} +!2 = !{!"Complex", !0, i64 0} -- 2.40.0