[Inliner] Propagate more attributes to params when inlining by goldsteinn · Pull Request #91101 · llvm/llvm-project (original) (raw)

@llvm/pr-subscribers-clang
@llvm/pr-subscribers-llvm-transforms

@llvm/pr-subscribers-llvm-ir

Author: None (goldsteinn)

Changes

Patch is 21.10 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/91101.diff

10 Files Affected:

diff --git a/clang/test/CodeGen/attr-counted-by-pr88931.cpp b/clang/test/CodeGen/attr-counted-by-pr88931.cpp index 2a8cc1d07e50d9..6d0c46bbbe8f9c 100644 --- a/clang/test/CodeGen/attr-counted-by-pr88931.cpp +++ b/clang/test/CodeGen/attr-counted-by-pr88931.cpp @@ -13,7 +13,7 @@ void init(void * attribute((pass_dynamic_object_size(0)))); // CHECK-LABEL: define dso_local void @_ZN3foo3barC1Ev( // CHECK-SAME: ptr noundef nonnull align 4 dereferenceable(1) [[THIS:%.]]) unnamed_addr #[[ATTR0:[0-9]+]] align 2 { // CHECK-NEXT: entry: -// CHECK-NEXT: tail call void @_Z4initPvU25pass_dynamic_object_size0(ptr noundef nonnull [[THIS]], i64 noundef -1) #[[ATTR2:[0-9]+]] +// CHECK-NEXT: tail call void @_Z4initPvU25pass_dynamic_object_size0(ptr noundef nonnull align 4 dereferenceable(1) [[THIS]], i64 noundef -1) #[[ATTR2:[0-9]+]] // CHECK-NEXT: ret void // foo::bar::bar() { diff --git a/clang/test/OpenMP/bug57757.cpp b/clang/test/OpenMP/bug57757.cpp index e1f646e2b141a0..c4e309d7f566b5 100644 --- a/clang/test/OpenMP/bug57757.cpp +++ b/clang/test/OpenMP/bug57757.cpp @@ -39,7 +39,7 @@ void foo() { // CHECK-NEXT: ] // CHECK: .untied.jmp..i: // CHECK-NEXT: store i32 1, ptr [[TMP2]], align 4, !tbaa [[TBAA16]], !alias.scope [[META13]], !noalias [[META17]] -// CHECK-NEXT: [[TMP4:%.]] = tail call i32 @__kmpc_omp_task(ptr nonnull @[[GLOB1]], i32 [[TMP0]], ptr [[TMP1]]), !noalias [[META13]] +// CHECK-NEXT: [[TMP4:%.]] = tail call i32 @__kmpc_omp_task(ptr nonnull @[[GLOB1]], i32 [[TMP0]], ptr nonnull [[TMP1]]), !noalias [[META13]] // CHECK-NEXT: br label [[DOTOMP_OUTLINED__EXIT]] // CHECK: .untied.next..i: // CHECK-NEXT: [[TMP5:%.]] = getelementptr inbounds i8, ptr [[TMP1]], i64 40 diff --git a/llvm/include/llvm/IR/Attributes.h b/llvm/include/llvm/IR/Attributes.h index dd11955714895e..337254906db885 100644 --- a/llvm/include/llvm/IR/Attributes.h +++ b/llvm/include/llvm/IR/Attributes.h @@ -752,6 +752,11 @@ class AttributeList { [[nodiscard]] AttributeList addRangeRetAttr(LLVMContext &C, const ConstantRange &CR) const; + /// Add the range attribute to the attribute set at the given arg index. + /// Returns a new list because attribute lists are immutable. + [[nodiscard]] AttributeList addRangeParamAttr(LLVMContext &C, unsigned Index, + const ConstantRange &CR) const; + /// Add the allocsize attribute to the attribute set at the given arg index. /// Returns a new list because attribute lists are immutable. [[nodiscard]] AttributeList @@ -906,6 +911,9 @@ class AttributeList { /// arg. uint64_t getParamDereferenceableOrNullBytes(unsigned ArgNo) const; + /// Get range (or std::nullopt if unknown) of an arg. + std::optional getParamRange(unsigned ArgNo) const; + /// Get the disallowed floating-point classes of the return value. FPClassTest getRetNoFPClass() const; @@ -1082,6 +1090,10 @@ class AttrBuilder { /// invalid if the Kind is not present in the builder. Attribute getAttribute(StringRef Kind) const; + /// Retrieve the range if the attribute exists (std::nullopt is returned + /// otherwise). + std::optional getRange() const; + /// Return raw (possibly packed/encoded) value of integer attribute or /// std::nullopt if not set. std::optional getRawIntAttr(Attribute::AttrKind Kind) const; diff --git a/llvm/include/llvm/IR/InstrTypes.h b/llvm/include/llvm/IR/InstrTypes.h index b9af3a6ca42c06..87335f0b28c6b4 100644 --- a/llvm/include/llvm/IR/InstrTypes.h +++ b/llvm/include/llvm/IR/InstrTypes.h @@ -2198,6 +2198,10 @@ class CallBase : public Instruction { /// parameter. FPClassTest getParamNoFPClass(unsigned i) const; + /// If arg ArgNo has a range attribute, return the value range of the + /// argument. Otherwise, std::nullopt is returned. + std::optional getParamRange(unsigned ArgNo) const; + /// If this return value has a range attribute, return the value range of the /// argument. Otherwise, std::nullopt is returned. std::optional getRange() const; diff --git a/llvm/lib/IR/Attributes.cpp b/llvm/lib/IR/Attributes.cpp index c8d6bdd423878b..0cbfe923032c86 100644 --- a/llvm/lib/IR/Attributes.cpp +++ b/llvm/lib/IR/Attributes.cpp @@ -1530,6 +1530,13 @@ AttributeList::addDereferenceableOrNullParamAttr(LLVMContext &C, unsigned Index, return addParamAttributes(C, Index, B); } +AttributeList AttributeList::addRangeParamAttr(LLVMContext &C, unsigned Index, + const ConstantRange &CR) const { + AttrBuilder B(C); + B.addRangeAttr(CR); + return addParamAttributes(C, Index, B); +} + AttributeList AttributeList::addRangeRetAttr(LLVMContext &C, const ConstantRange &CR) const { AttrBuilder B(C); @@ -1658,6 +1665,14 @@ AttributeList::getParamDereferenceableOrNullBytes(unsigned Index) const { return getParamAttrs(Index).getDereferenceableOrNullBytes(); } +std::optional +AttributeList::getParamRange(unsigned Index) const { + auto RangeAttr = getParamAttrs(Index).getAttribute(Attribute::Range); + if (RangeAttr.isValid()) + return RangeAttr.getRange(); + return std::nullopt; +} + FPClassTest AttributeList::getRetNoFPClass() const { return getRetAttrs().getNoFPClass(); } @@ -1991,6 +2006,13 @@ Attribute AttrBuilder::getAttribute(StringRef A) const { return {}; } +std::optional AttrBuilder::getRange() const { + const Attribute RangeAttr = getAttribute(Attribute::Range); + if (RangeAttr.isValid()) + return RangeAttr.getRange(); + return std::nullopt; +} + bool AttrBuilder::contains(Attribute::AttrKind A) const { return getAttribute(A).isValid(); } diff --git a/llvm/lib/IR/Instructions.cpp b/llvm/lib/IR/Instructions.cpp index 7ad1ad4cddb703..ee832d2093a132 100644 --- a/llvm/lib/IR/Instructions.cpp +++ b/llvm/lib/IR/Instructions.cpp @@ -396,6 +396,13 @@ FPClassTest CallBase::getParamNoFPClass(unsigned i) const { return Mask; } +std::optional CallBase::getParamRange(unsigned ArgNo) const { + const Attribute RangeAttr = getParamAttr(ArgNo, llvm::Attribute::Range); + if (RangeAttr.isValid()) + return RangeAttr.getRange(); + return std::nullopt; +} + std::optional CallBase::getRange() const { const Attribute RangeAttr = getRetAttr(llvm::Attribute::Range); if (RangeAttr.isValid()) diff --git a/llvm/lib/Transforms/Utils/InlineFunction.cpp b/llvm/lib/Transforms/Utils/InlineFunction.cpp index 1aae561d8817b5..41f899fe120f63 100644 --- a/llvm/lib/Transforms/Utils/InlineFunction.cpp +++ b/llvm/lib/Transforms/Utils/InlineFunction.cpp @@ -1352,20 +1352,43 @@ static void AddParamAndFnBasicAttributes(const CallBase &CB, auto &Context = CalledFunction->getContext(); // Collect valid attributes for all params. - SmallVector ValidParamAttrs; + SmallVector ValidObjParamAttrs, ValidExactParamAttrs; bool HasAttrToPropagate = false; for (unsigned I = 0, E = CB.arg_size(); I < E; ++I) { - ValidParamAttrs.emplace_back(AttrBuilder{CB.getContext()}); + ValidObjParamAttrs.emplace_back(AttrBuilder{CB.getContext()}); + ValidExactParamAttrs.emplace_back(AttrBuilder{CB.getContext()}); // Access attributes can be propagated to any param with the same underlying // object as the argument. if (CB.paramHasAttr(I, Attribute::ReadNone)) - ValidParamAttrs.back().addAttribute(Attribute::ReadNone); + ValidObjParamAttrs.back().addAttribute(Attribute::ReadNone); if (CB.paramHasAttr(I, Attribute::ReadOnly)) - ValidParamAttrs.back().addAttribute(Attribute::ReadOnly); + ValidObjParamAttrs.back().addAttribute(Attribute::ReadOnly); if (CB.paramHasAttr(I, Attribute::WriteOnly)) - ValidParamAttrs.back().addAttribute(Attribute::WriteOnly); - HasAttrToPropagate |= ValidParamAttrs.back().hasAttributes(); + ValidObjParamAttrs.back().addAttribute(Attribute::WriteOnly); + + // Attributes we can only propagate if the exact parameter is forwarded. + + // We can propagate both poison generating an UB generating attributes + // without any extra checks. The only attribute that is tricky to propagate + // is noundef (skipped for now) as that can create new UB where previous + // behavior was just using a poison value. + if (auto DerefBytes = CB.getParamDereferenceableBytes(I)) + ValidExactParamAttrs.back().addDereferenceableAttr(DerefBytes); + if (auto DerefOrNullBytes = CB.getParamDereferenceableOrNullBytes(I)) + ValidExactParamAttrs.back().addDereferenceableOrNullAttr( + DerefOrNullBytes); + if (CB.paramHasAttr(I, Attribute::NoFree)) + ValidExactParamAttrs.back().addAttribute(Attribute::NoFree); + if (CB.paramHasAttr(I, Attribute::NonNull)) + ValidExactParamAttrs.back().addAttribute(Attribute::NonNull); + if (auto Align = CB.getParamAlign(I)) + ValidExactParamAttrs.back().addAlignmentAttr(Align); + if (auto Range = CB.getParamRange(I)) + ValidExactParamAttrs.back().addRangeAttr(*Range); + + HasAttrToPropagate |= ValidObjParamAttrs.back().hasAttributes(); + HasAttrToPropagate |= ValidExactParamAttrs.back().hasAttributes(); } // Won't be able to propagate anything. @@ -1383,15 +1406,54 @@ static void AddParamAndFnBasicAttributes(const CallBase &CB, AttributeList AL = NewInnerCB->getAttributes(); for (unsigned I = 0, E = InnerCB->arg_size(); I < E; ++I) { // Check if the underlying value for the parameter is an argument. - const Value *UnderlyingV = - getUnderlyingObject(InnerCB->getArgOperand(I)); - const Argument *Arg = dyn_cast(UnderlyingV); - if (!Arg) - continue; + const Argument *Arg = dyn_cast(InnerCB->getArgOperand(I)); + unsigned ArgNo; + if (Arg) { + ArgNo = Arg->getArgNo(); + // For dereferenceable, dereferenceable_or_null, align, etc... + // we don't want to propagate if the existing param has the same + // attribute with "better" constraints. So, only remove from the + // existing AL if the region of the existing param is smaller than + // what we can propagate. AttributeList's merge API honours the + // already existing attribute value so we choose the "better" + // attribute by removing if the existing one is worse. + if (AL.getParamDereferenceableBytes(I) < + ValidExactParamAttrs[ArgNo].getDereferenceableBytes()) + AL = + AL.removeParamAttribute(Context, I, Attribute::Dereferenceable); + if (AL.getParamDereferenceableOrNullBytes(I) < + ValidExactParamAttrs[ArgNo].getDereferenceableOrNullBytes()) + AL = + AL.removeParamAttribute(Context, I, Attribute::Dereferenceable); + if (AL.getParamAlignment(I).valueOrOne() < + ValidExactParamAttrs[ArgNo].getAlignment().valueOrOne()) + AL = AL.removeParamAttribute(Context, I, Attribute::Alignment); + + auto ExistingRange = AL.getParamRange(I); + AL = AL.addParamAttributes(Context, I, ValidExactParamAttrs[ArgNo]); + + // For range we use the exact intersection. + if (ExistingRange.has_value()) { + if (auto NewRange = ValidExactParamAttrs[ArgNo].getRange()) { + auto CombinedRange = ExistingRange->exactIntersectWith(*NewRange); + if (!CombinedRange.has_value()) + CombinedRange = + ConstantRange::getEmpty(NewRange->getBitWidth()); + AL = AL.removeParamAttribute(Context, I, Attribute::Range); + AL = AL.addRangeParamAttr(Context, I, *CombinedRange); + } + } + } else { + const Value *UnderlyingV = + getUnderlyingObject(InnerCB->getArgOperand(I)); + Arg = dyn_cast(UnderlyingV); + if (!Arg) + continue; + ArgNo = Arg->getArgNo(); + } - unsigned ArgNo = Arg->getArgNo(); // If so, propagate its access attributes. - AL = AL.addParamAttributes(Context, I, ValidParamAttrs[ArgNo]); + AL = AL.addParamAttributes(Context, I, ValidObjParamAttrs[ArgNo]); // We can have conflicting attributes from the inner callsite and // to-be-inlined callsite. In that case, choose the most // restrictive. diff --git a/llvm/test/Transforms/Inline/access-attributes-prop.ll b/llvm/test/Transforms/Inline/access-attributes-prop.ll index ffd31fbe8ae107..e25023da6ed5ff 100644 --- a/llvm/test/Transforms/Inline/access-attributes-prop.ll +++ b/llvm/test/Transforms/Inline/access-attributes-prop.ll @@ -46,7 +46,6 @@ define dso_local void @foo3_writable(ptr %p) { ret void }

define dso_local void @foo1_bar_aligned64_deref512(ptr %p) { ; CHECK-LABEL: define {{[^@]+}}@foo1_bar_aligned64_deref512 ; CHECK-SAME: (ptr [[P:%.]]) { @@ -295,7 +294,7 @@ define void @prop_param_callbase_def_1x_partial_3(ptr %p, ptr %p2) { define void @prop_deref(ptr %p) { ; CHECK-LABEL: define {{[^@]+}}@prop_deref ; CHECK-SAME: (ptr [[P:%.]]) { -; CHECK-NEXT: call void @bar1(ptr [[P]]) +; CHECK-NEXT: call void @bar1(ptr dereferenceable(16) [[P]]) ; CHECK-NEXT: ret void ; call void @foo1(ptr dereferenceable(16) %p) @@ -305,7 +304,7 @@ define void @prop_deref(ptr %p) { define void @prop_deref_or_null(ptr %p) { ; CHECK-LABEL: define {{[^@]+}}@prop_deref_or_null ; CHECK-SAME: (ptr [[P:%.]]) { -; CHECK-NEXT: call void @bar1(ptr [[P]]) +; CHECK-NEXT: call void @bar1(ptr dereferenceable_or_null(256) [[P]]) ; CHECK-NEXT: ret void ; call void @foo1(ptr dereferenceable_or_null(256) %p) @@ -315,17 +314,27 @@ define void @prop_deref_or_null(ptr %p) { define void @prop_param_nonnull_and_align(ptr %p) { ; CHECK-LABEL: define {{[^@]+}}@prop_param_nonnull_and_align ; CHECK-SAME: (ptr [[P:%.]]) { -; CHECK-NEXT: call void @bar1(ptr [[P]]) +; CHECK-NEXT: call void @bar1(ptr nonnull align 32 [[P]]) ; CHECK-NEXT: ret void ; call void @foo1(ptr nonnull align 32 %p) ret void } +define void @prop_param_nofree_and_align(ptr %p) { +; CHECK-LABEL: define {{[^@]+}}@prop_param_nofree_and_align +; CHECK-SAME: (ptr [[P:%.]]) { +; CHECK-NEXT: call void @bar1(ptr nofree align 32 [[P]]) +; CHECK-NEXT: ret void +; + call void @foo1(ptr nofree align 32 %p) + ret void +} + define void @prop_param_deref_align_no_update(ptr %p) { ; CHECK-LABEL: define {{[^@]+}}@prop_param_deref_align_no_update ; CHECK-SAME: (ptr [[P:%.]]) { -; CHECK-NEXT: call void @bar1(ptr align 64 dereferenceable(512) [[P]]) +; CHECK-NEXT: call void @bar1(ptr align 4 dereferenceable(64) [[P]]) ; CHECK-NEXT: ret void ; call void @foo1_bar_aligned64_deref512(ptr align 4 dereferenceable(64) %p) @@ -335,7 +344,7 @@ define void @prop_param_deref_align_no_update(ptr %p) { define void @prop_param_deref_align_update(ptr %p) { ; CHECK-LABEL: define {{[^@]+}}@prop_param_deref_align_update ; CHECK-SAME: (ptr [[P:%.]]) { -; CHECK-NEXT: call void @bar1(ptr align 64 dereferenceable(512) [[P]]) +; CHECK-NEXT: call void @bar1(ptr align 128 dereferenceable(1024) [[P]]) ; CHECK-NEXT: ret void ; call void @foo1_bar_aligned64_deref512(ptr align 128 dereferenceable(1024) %p) @@ -345,7 +354,7 @@ define void @prop_param_deref_align_update(ptr %p) { define void @prop_param_deref_or_null_update(ptr %p) { ; CHECK-LABEL: define {{[^@]+}}@prop_param_deref_or_null_update ; CHECK-SAME: (ptr [[P:%.]]) { -; CHECK-NEXT: call void @bar1(ptr align 512 dereferenceable_or_null(512) [[P]]) +; CHECK-NEXT: call void @bar1(ptr align 512 dereferenceable_or_null(1024) [[P]]) ; CHECK-NEXT: ret void ; call void @foo1_bar_aligned512_deref_or_null512(ptr dereferenceable_or_null(1024) %p) @@ -355,7 +364,7 @@ define void @prop_param_deref_or_null_update(ptr %p) { define void @prop_param_deref_or_null_no_update(ptr %p) { ; CHECK-LABEL: define {{[^@]+}}@prop_param_deref_or_null_no_update ; CHECK-SAME: (ptr [[P:%.*]]) { -; CHECK-NEXT: call void @bar1(ptr align 512 dereferenceable_or_null(512) [[P]]) +; CHECK-NEXT: call void @bar1(ptr align 512 dereferenceable_or_null(32) [[P]]) ; CHECK-NEXT: ret void ; call void @foo1_bar_aligned512_deref_or_null512(ptr dereferenceable_or_null(32) %p) @@ -528,7 +537,6 @@ define void @prop_no_conflict_writable(ptr %p) { ret void }

define void @prop_no_conflict_writable2(ptr %p) { ; CHECK-LABEL: define {{[^@]+}}@prop_no_conflict_writable2 ; CHECK-SAME: (ptr [[P:%.*]]) { @@ -539,3 +547,107 @@ define void @prop_no_conflict_writable2(ptr %p) { ret void }

+declare void @bar4(i32) + +define dso_local void @foo4_range_0_10(i32 %v) { +; CHECK-LABEL: define {{[^@]+}}@foo4_range_0_10 +; CHECK-SAME: (i32 [[V:%.*]]) { +; CHECK-NEXT: call void @bar4(i32 range(i32 0, 10) [[V]]) +; CHECK-NEXT: ret void +;