[AMDGPU] [IndirectCalls] Don't propagate attributes to address taken functions and their callees

[madhur13490]

Summary

Don't propagate launch bound related attributes to
address taken functions and their callees. The idea
is to do a traversal over the call graph starting at
address taken functions and erase the attributes
set by previous logic i.e. process().

This two phase approach makes sure that we don't
miss out on deep nested callees from address taken
functions as a function might be called directly as
well as indirectly.

This patch is also reattempt to D94585 as latent issues
are fixed in hasAddressTaken function in the recent
past.

[arsenm]

Going back to remove the attributes feels more confusing than just not setting them in the first place

llvm/lib/Target/AMDGPU/AMDGPUPropagateAttributes.cpp

235–238

Just assert, the return is dead

llvm/test/CodeGen/AMDGPU/propagate-attributes-launch-bounds.ll

8

Add a comment that there should be no attribute set

[rampitec]

llvm/lib/Target/AMDGPU/AMDGPUPropagateAttributes.cpp

41

Restore blank line here.

223

\n in single quotes.

[madhur13490]

address review comments

[madhur13490]

llvm/lib/Target/AMDGPU/AMDGPUPropagateAttributes.cpp

235–238

I'd say its a style choice. Preferring llvm_unreachable over assert.

[foad]

llvm/lib/Target/AMDGPU/AMDGPUPropagateAttributes.cpp

118

Add the nullptr initializion here instead of in the constructor?

235–238

Then it's a bad choice :) I agree with Matt. assert(CG) or assert(CG && "message") are shorter and simpler and more familiar because they're already ubiquitous throughout llvm.

248

It's more common to use a SmallVector for this, with push_back and pop_back_val.

[madhur13490]

llvm/lib/Target/AMDGPU/AMDGPUPropagateAttributes.cpp

118

May I know why?

235–238

As per coding standards, llvm_unreachable seems more preferred.
https://llvm.org/docs/CodingStandards.html#assert-liberally

@rampitec What do you think? Internally, I changed this from assert.

248

I need a queue. This is implementing BFS.

[foad]

llvm/lib/Target/AMDGPU/AMDGPUPropagateAttributes.cpp

118

It's slightly better style because if you have more than one constructor, you don't have to repeat the same initialization value for every constructor. It doesn't really matter if you only have one constructor.

[madhur13490]

use NSDMI for ModuleCG

[rampitec]

Generally LGTM. Please wait other reviewers too.

llvm/lib/Target/AMDGPU/AMDGPUPropagateAttributes.cpp

235–238

Internally if was "if() assert(false ...)". assert(false) shall never be used, that's why I suggested llvm_unreachange() instead. But "assert(ModuleCG);" is a more common thing.

[madhur13490]

llvm/lib/Target/AMDGPU/AMDGPUPropagateAttributes.cpp

235–238

There are ways to implement this:
A.

if (!ModuleCG) { 
   assert(false, "ModuleCG not present"); 
   return; 
} 
<rest code>

B. Just

assert(ModuleCG && "Module CG not present"); 
< rest code>

C.

 if (!ModuleCG) { 
      llvm_unreachable("ModuleCG"); 
      return; 
 } 
<rest code>

Matt suggests B but in release builds the code would just crash because it would end up accessing nullptr.
I had A initially because it asserts as well as returns gracefully so it does not crash. C is similar to A just llvm_unreachable replaces assert.

I prefer but C because it follows coding standard and also returns gracefully returns in release builds.

Which one we agree the best here?

[madhur13490]

llvm/lib/Target/AMDGPU/AMDGPUPropagateAttributes.cpp

235–238

Typo: I prefer C

[foad]

You cannot recover after an "unreachable" or a failed assertion.

C [...] returns gracefully returns in release builds.

No it doesn't. In a release build llvm_unreachable will usually expand to __builtin_unreachable() or __assume(false) and the optimising compiler will remove any code after that point because it is allowed to assume that it is not reachable.

[madhur13490]

In D103138#2787055, @foad wrote:

You cannot recover after an "unreachable" or a failed assertion.

C [...] returns gracefully returns in release builds.

No it doesn't. In a release build llvm_unreachable will usually expand to __builtin_unreachable() or __assume(false) and the optimising compiler will remove any code after that point because it is allowed to assume that it is not reachable.

Ok,, B seems common in code base too.

[madhur13490]

use assert

[madhur13490]

Fixed one more test after rebase.

[madhur13490]

add comment about keeping indirect calls handling separate

[arsenm]

llvm/lib/Target/AMDGPU/AMDGPUPropagateAttributes.cpp

221

I don't think null F can reach here

235–238

C doesn't follow the coding standard and adds dead code. You also should NOT be attempting to gracefully handle invalid cases in a release build. The optimizer will happily delete this null check anyway

[madhur13490]

llvm/lib/Target/AMDGPU/AMDGPUPropagateAttributes.cpp

221

One of the test cases from AOMP reached here with null F.

[JonChesterfield]

This patch causes the amdgpu-propagate-attributes-late pass to loop forever when the input IR has a recursive function call (and a couple of other minor things). Reduced test case:

target triple = "amdgcn-amd-amdhsa"

define i64 @f(i64 %x)  {
entry:
  br i1 undef, label %return, label %if.end

if.end:
  %call = call i64 @f(i64 undef) 
  unreachable

return:
  ret i64 1
}

define i8* @unrelated() {
entry:
  ret i8* bitcast (i64 (i64)* @f to i8*)
}

declare amdgpu_kernel void @has_a_kernel(i32)

Reverting this patch fixes that - compilation proceeds correctly, instead of looping forever.

I believe this patch is an optimisation. Tests don't cover functional changes, there is no reference to a bug report and I can't think of anything this might be fixing. The commit message doesn't say what motivates the change. I'm therefore going to revert it on the basis that it is broken.

The attributor framework was written to factor out code very like this, and it won't fall over on a recursive function call, so my preference remains to change over to that instead of doing amdgpu-only callgraph walking stuff.

llvm/test/CodeGen/AMDGPU/propagate-attributes-common-callees.ll

1

I can't tell what this test is looking for. What do you mean by common callees here?

llvm/lib/Target/AMDGPU/AMDGPUPropagateAttributes.cpp

 /// library folding opportunities.
 //
 //===----------------------------------------------------------------------===//
 
 #include "AMDGPU.h"
 #include "MCTargetDesc/AMDGPUMCTargetDesc.h"
 #include "Utils/AMDGPUBaseInfo.h"
 #include "llvm/ADT/SmallSet.h"
+#include "llvm/Analysis/CallGraph.h"
 #include "llvm/CodeGen/TargetPassConfig.h"
 #include "llvm/CodeGen/TargetSubtargetInfo.h"
 #include "llvm/IR/InstrTypes.h"
 #include "llvm/Target/TargetMachine.h"
 #include "llvm/Transforms/Utils/Cloning.h"
+#include <queue>
 
 #define DEBUG_TYPE "amdgpu-propagate-attributes"
 
 using namespace llvm;
 
 namespace llvm {
 extern const SubtargetFeatureKV AMDGPUFeatureKV[AMDGPU::NumSubtargetFeatures-1];
 }
 
 namespace {
public:
     Function *NewF;
   };
 
   const TargetMachine *TM;
 
   // Clone functions as needed or just set attributes.
   bool AllowClone;
 
+  CallGraph *ModuleCG = nullptr;
+
   // Option propagation roots.
   SmallSet<Function *, 32> Roots;
 
   // Clones of functions with their attributes.
   SmallVector<Clone, 32> Clones;
 
+  // To memoize address taken functions.
+  SmallSet<Function *, 32> AddressTakenFunctions;
+
   // Find a clone with required features.
   Function *findFunction(const FnProperties &PropsNeeded,
                          Function *OrigF);
 
   // Clone function \p F and set \p NewProps on the clone.
   // Cole takes the name of original function.
   Function *cloneWithProperties(Function &F, const FnProperties &NewProps);
 
   // Set new function's features in place.
   void setFeatures(Function &F, const FeatureBitset &NewFeatures);
 
   // Set new function's attributes in place.
   void setAttributes(Function &F, const ArrayRef<Optional<Attribute>> NewAttrs);
 
   std::string getFeatureString(const FeatureBitset &Features) const;
 
   // Propagate attributes from Roots.
   bool process();
 
 public:
-  AMDGPUPropagateAttributes(const TargetMachine *TM, bool AllowClone) :
-    TM(TM), AllowClone(AllowClone) {}
+  AMDGPUPropagateAttributes(const TargetMachine *TM, bool AllowClone)
+      : TM(TM), AllowClone(AllowClone) {}
 
   // Use F as a root and propagate its attributes.
   bool process(Function &F);
 
   // Propagate attributes starting from kernel functions.
-  bool process(Module &M);
+  bool process(Module &M, CallGraph *CG);
+
+  // Remove attributes from F.
+  // This is used in presence of address taken functions.
+  bool removeAttributes(Function *F);
+
+  // Handle call graph rooted at address taken functions.
+  // This function will erase all attributes present
+  // on all functions called from address taken functions transitively.
+  bool handleAddressTakenFunctions(CallGraph *CG);
 };
 
 // Allows to propagate attributes early, but no clonning is allowed as it must
 // be a function pass to run before any optimizations.
 // TODO: We shall only need a one instance of module pass, but that needs to be
 // in the linker pipeline which is currently not possible.
 class AMDGPUPropagateAttributesEarly : public FunctionPass {
   const TargetMachine *TM;
public:
   static char ID; // Pass identification
 
   AMDGPUPropagateAttributesLate(const TargetMachine *TM = nullptr) :
     ModulePass(ID), TM(TM) {
     initializeAMDGPUPropagateAttributesLatePass(
       *PassRegistry::getPassRegistry());
   }
 
+  void getAnalysisUsage(AnalysisUsage &AU) const override;
   bool runOnModule(Module &M) override;
 };
 
 }  // end anonymous namespace.
 
 char AMDGPUPropagateAttributesEarly::ID = 0;
 char AMDGPUPropagateAttributesLate::ID = 0;
 
 INITIALIZE_PASS(AMDGPUPropagateAttributesEarly,
                 "amdgpu-propagate-attributes-early",
                 "Early propagate attributes from kernels to functions",
                 false, false)
 INITIALIZE_PASS(AMDGPUPropagateAttributesLate,
                 "amdgpu-propagate-attributes-late",
                 "Late propagate attributes from kernels to functions",
                 false, false)
 
+bool AMDGPUPropagateAttributes::removeAttributes(Function *F) {
+  bool Changed = false;
+  if (!F)
+    return Changed;
+  LLVM_DEBUG(dbgs() << "Removing attributes from " << F->getName() << '\n');
+  for (unsigned I = 0; I < NumAttr; ++I) {
+    if (F->hasFnAttribute(AttributeNames[I])) {
+      F->removeFnAttr(AttributeNames[I]);
+      Changed = true;
+    }
+  }
+  return Changed;
+}
+
+bool AMDGPUPropagateAttributes::handleAddressTakenFunctions(CallGraph *CG) {
+  assert(ModuleCG && "Call graph not present");
+
+  bool Changed = false;
+  SmallSet<CallGraphNode *, 32> Visited;
+
+  for (Function *F : AddressTakenFunctions) {
+    CallGraphNode *CGN = (*CG)[F];
+    if (!Visited.count(CGN)) {
+      Changed |= removeAttributes(F);
+      Visited.insert(CGN);
+    }
+
+    std::queue<CallGraphNode *> SubGraph;
+    SubGraph.push(CGN);
+    while (!SubGraph.empty()) {
+      CallGraphNode *CGN = SubGraph.front();
+      SubGraph.pop();
+      if (!Visited.count(CGN)) {
+        Changed |= removeAttributes(CGN->getFunction());
+        Visited.insert(CGN);
+      }
+      for (auto N : *CGN)
+        SubGraph.push(N.second);
+    }
+  }
+  return Changed;
+}
+
 Function *
 AMDGPUPropagateAttributes::findFunction(const FnProperties &PropsNeeded,
                                         Function *OrigF) {
   // TODO: search for clone's clones.
   for (Clone &C : Clones)
     if (C.OrigF == OrigF && PropsNeeded == C.Properties)
       return C.NewF;
 
   return nullptr;
 }
 
-bool AMDGPUPropagateAttributes::process(Module &M) {
+bool AMDGPUPropagateAttributes::process(Module &M, CallGraph *CG) {
   for (auto &F : M.functions())
     if (AMDGPU::isEntryFunctionCC(F.getCallingConv()))
       Roots.insert(&F);
 
+  ModuleCG = CG;
   return process();
 }
 
 bool AMDGPUPropagateAttributes::process(Function &F) {
   Roots.insert(&F);
   return process();
 }
 
bool AMDGPUPropagateAttributes::process() {
   do {
     Roots.insert(NewRoots.begin(), NewRoots.end());
     NewRoots.clear();
 
     for (auto &F : M.functions()) {
       if (F.isDeclaration())
         continue;
 
+      if (F.hasAddressTaken(nullptr, true, true, true))
+        AddressTakenFunctions.insert(&F);
+
       const FnProperties CalleeProps(*TM, F);
       SmallVector<std::pair<CallBase *, Function *>, 32> ToReplace;
       SmallSet<CallBase *, 32> Visited;
 
       for (User *U : F.users()) {
         Instruction *I = dyn_cast<Instruction>(U);
         if (!I)
           continue;
bool AMDGPUPropagateAttributes::process() {
   for (Function *F : Replaced) {
     if (F->use_empty())
       F->eraseFromParent();
   }
 
   Roots.clear();
   Clones.clear();
 
+  // Keep the post processing related to indirect
+  // calls separate to handle them gracefully.
+  // The core traversal need not be affected by this.
+  if (AllowClone)
+    Changed |= handleAddressTakenFunctions(ModuleCG);
+
   return Changed;
 }
 
 Function *
 AMDGPUPropagateAttributes::cloneWithProperties(Function &F,
                                                const FnProperties &NewProps) {
   LLVM_DEBUG(dbgs() << "Cloning " << F.getName() << '\n');
 
bool AMDGPUPropagateAttributesEarly::runOnFunction(Function &F) {
   }
 
   if (!AMDGPU::isEntryFunctionCC(F.getCallingConv()))
     return false;
 
   return AMDGPUPropagateAttributes(TM, false).process(F);
 }
 
+void AMDGPUPropagateAttributesLate::getAnalysisUsage(AnalysisUsage &AU) const {
+  AU.addRequired<CallGraphWrapperPass>();
+}
+
 bool AMDGPUPropagateAttributesLate::runOnModule(Module &M) {
   if (!TM) {
     auto *TPC = getAnalysisIfAvailable<TargetPassConfig>();
     if (!TPC)
       return false;
 
     TM = &TPC->getTM<TargetMachine>();
   }
-
-  return AMDGPUPropagateAttributes(TM, true).process(M);
+  CallGraph &CG = getAnalysis<CallGraphWrapperPass>().getCallGraph();
+  return AMDGPUPropagateAttributes(TM, true).process(M, &CG);
 }
 
 FunctionPass
 *llvm::createAMDGPUPropagateAttributesEarlyPass(const TargetMachine *TM) {
   return new AMDGPUPropagateAttributesEarly(TM);
 }
 
 ModulePass
 *llvm::createAMDGPUPropagateAttributesLatePass(const TargetMachine *TM) {
   return new AMDGPUPropagateAttributesLate(TM);
 }
 
 PreservedAnalyses
 AMDGPUPropagateAttributesEarlyPass::run(Function &F,
                                         FunctionAnalysisManager &AM) {
   if (!AMDGPU::isEntryFunctionCC(F.getCallingConv()))
     return PreservedAnalyses::all();
 
   return AMDGPUPropagateAttributes(&TM, false).process(F)
              ? PreservedAnalyses::none()
              : PreservedAnalyses::all();
 }
 
 PreservedAnalyses
-AMDGPUPropagateAttributesLatePass::run(Module &M, ModuleAnalysisManager &AM) {
-  return AMDGPUPropagateAttributes(&TM, true).process(M)
-             ? PreservedAnalyses::none()
-             : PreservedAnalyses::all();
+AMDGPUPropagateAttributesLatePass::run(Module &M, ModuleAnalysisManager &MAM) {
+  AMDGPUPropagateAttributes APA(&TM, true);
+  CallGraph &CG = MAM.getResult<CallGraphAnalysis>(M);
+  const bool Changed = APA.process(M, &CG);
+  return Changed ? PreservedAnalyses::none() : PreservedAnalyses::all();
 }

llvm/test/CodeGen/AMDGPU/opt-pipeline.ll

 ; GCN-O1-NEXT:   ModulePass Manager
 ; GCN-O1-NEXT:     Annotation2Metadata
 ; GCN-O1-NEXT:     Force set function attributes
 ; GCN-O1-NEXT:     Infer set function attributes
 ; GCN-O1-NEXT:     Unify multiple OpenCL metadata due to linking
 ; GCN-O1-NEXT:     AMDGPU Printf lowering
 ; GCN-O1-NEXT:       FunctionPass Manager
 ; GCN-O1-NEXT:         Dominator Tree Construction
+; GCN-O1-NEXT:     CallGraph Construction
 ; GCN-O1-NEXT:     Late propagate attributes from kernels to functions
 ; GCN-O1-NEXT:     Interprocedural Sparse Conditional Constant Propagation
 ; GCN-O1-NEXT:       FunctionPass Manager
 ; GCN-O1-NEXT:         Dominator Tree Construction
 ; GCN-O1-NEXT:     Called Value Propagation
 ; GCN-O1-NEXT:     Global Variable Optimizer
 ; GCN-O1-NEXT:       FunctionPass Manager
 ; GCN-O1-NEXT:         Dominator Tree Construction

 ; GCN-O2-NEXT:   ModulePass Manager
 ; GCN-O2-NEXT:     Annotation2Metadata
 ; GCN-O2-NEXT:     Force set function attributes
 ; GCN-O2-NEXT:     Infer set function attributes
 ; GCN-O2-NEXT:     Unify multiple OpenCL metadata due to linking
 ; GCN-O2-NEXT:     AMDGPU Printf lowering
 ; GCN-O2-NEXT:       FunctionPass Manager
 ; GCN-O2-NEXT:         Dominator Tree Construction
+; GCN-O2-NEXT:     CallGraph Construction
 ; GCN-O2-NEXT:     Late propagate attributes from kernels to functions
 ; GCN-O2-NEXT:     Interprocedural Sparse Conditional Constant Propagation
 ; GCN-O2-NEXT:       FunctionPass Manager
 ; GCN-O2-NEXT:         Dominator Tree Construction
 ; GCN-O2-NEXT:     Called Value Propagation
 ; GCN-O2-NEXT:     Global Variable Optimizer
 ; GCN-O2-NEXT:       FunctionPass Manager
 ; GCN-O2-NEXT:         Dominator Tree Construction

 ; GCN-O3-NEXT:   ModulePass Manager
 ; GCN-O3-NEXT:     Annotation2Metadata
 ; GCN-O3-NEXT:     Force set function attributes
 ; GCN-O3-NEXT:     Infer set function attributes
 ; GCN-O3-NEXT:     Unify multiple OpenCL metadata due to linking
 ; GCN-O3-NEXT:     AMDGPU Printf lowering
 ; GCN-O3-NEXT:       FunctionPass Manager
 ; GCN-O3-NEXT:         Dominator Tree Construction
+; GCN-O3-NEXT:     CallGraph Construction
 ; GCN-O3-NEXT:     Late propagate attributes from kernels to functions
 ; GCN-O3-NEXT:     FunctionPass Manager
 ; GCN-O3-NEXT:       Dominator Tree Construction
 ; GCN-O3-NEXT:       Call-site splitting
 ; GCN-O3-NEXT:     Interprocedural Sparse Conditional Constant Propagation
 ; GCN-O3-NEXT:       FunctionPass Manager
 ; GCN-O3-NEXT:         Dominator Tree Construction
 ; GCN-O3-NEXT:     Called Value Propagation

llvm/test/CodeGen/AMDGPU/propagate-attributes-common-callees.ll

+; RUN: opt -S -mtriple=amdgcn-amd-amdhsa -amdgpu-propagate-attributes-late  %s | FileCheck %s
+
+; CHECK-LABEL: define float @common() {
+define float @common() {
+   ret float 0.0
+}
+
+; CHECK-LABEL: define float @foo() {
+define float @foo() {
+  %direct_call = call contract float @common()
+  ret float %direct_call
+}
+
+; CHECK-LABEL: define float @bar() {
+define float @bar() {
+   ret float 0.0
+}
+
+; CHECK-LABEL: define float @baz() {
+define float @baz() {
+   ret float 0.0
+}
+
+define amdgpu_kernel void @switch_indirect_kernel(float *%result, i32 %type) #1 {
+  %fn = alloca float ()*
+  switch i32 %type, label %sw.default [
+    i32 1, label %sw.bb
+    i32 2, label %sw.bb2
+    i32 3, label %sw.bb3
+  ]
+
+sw.bb:
+  store float ()* @foo, float ()** %fn
+  br label %sw.epilog
+
+sw.bb2:
+  store float ()* @bar, float ()** %fn
+  br label %sw.epilog
+
+sw.bb3:
+  store float ()* @baz, float ()** %fn
+  br label %sw.epilog
+
+sw.default:
+  br label %sw.epilog
+
+sw.epilog:
+  %fp = load float ()*, float ()** %fn
+  %direct_call = call contract float @common()
+  %indirect_call = call contract float %fp()
+  store float %indirect_call, float* %result
+  ret void
+}
+
+attributes #1 = { "amdgpu-flat-work-group-size"="1,256" }

llvm/test/CodeGen/AMDGPU/propagate-attributes-direct-indirect-common-callee.ll

+; RUN: opt -S -mtriple=amdgcn-amd-amdhsa -amdgpu-propagate-attributes-late  %s | FileCheck %s
+
+; Test to check if we skip propgating attributes even if
+; a function is called directly as well as
+; indirectly. "baz" is called directly as well indirectly.
+
+; CHECK-LABEL: define float @foo()
+define float @foo() #1 {
+  ret float 0.0
+}
+
+; CHECK-LABEL: define float @bar()
+define float @bar() #1 {
+ ret float 0.0
+}
+
+; CHECK-LABEL: define float @baz()
+define float @baz() #1 {
+ ret float 0.0
+}
+
+define amdgpu_kernel void @switch_indirect_kernel(float *%result, i32 %type) #1 {
+  %fn = alloca float ()*
+  switch i32 %type, label %sw.default [
+    i32 1, label %sw.bb
+    i32 2, label %sw.bb2
+    i32 3, label %sw.bb3
+  ]
+
+sw.bb:
+  store float ()* @foo, float ()** %fn
+  br label %sw.epilog
+
+sw.bb2:
+  store float ()* @bar, float ()** %fn
+  br label %sw.epilog
+
+sw.bb3:
+  store float ()* @baz, float ()** %fn
+  br label %sw.epilog
+
+sw.default:
+  br label %sw.epilog
+
+sw.epilog:
+  %fp = load float ()*, float ()** %fn
+  %direct_call = call contract float @baz()
+  %indirect_call = call contract float %fp()
+  store float %indirect_call, float* %result
+  ret void
+}
+
+attributes #1 = { "amdgpu-flat-work-group-size"="1,256" }

llvm/test/CodeGen/AMDGPU/propagate-attributes-function-pointer-argument.ll

 
 define private void @f(void ()* nocapture %0) #0 {
     ret void
 }
 
 ; In order to expose this bug, it is necessary that `g` have one of the
 ; propagated attributes, so that a clone and substitution would take place if g
 ; were actually the function being called.
-; CHECK-DAG: define private void @g.1() #1
-; CHECK-DAG: define internal void @g() #2
+; CHECK-DAG: define private void @g.1() #0
+; CHECK-DAG: define internal void @g() #1
 define private void @g() #1 {
     ret void
 }
 
 attributes #0 = { noinline }
 attributes #1 = { noinline "amdgpu-waves-per-eu"="1,10" }
+
+; CHECK: attributes #0 = { noinline }
+; CHECK-NEXT: attributes #1 = { noinline "target-features"="+enable-ds128,+enable-prt-strict-null,+flat-address-space,+flat-for-global,+load-store-opt,+promote-alloca,+trap-handler,+unaligned-access-mode,-wavefrontsize16,-wavefrontsize32,+wavefrontsize64" }

llvm/test/CodeGen/AMDGPU/propagate-attributes-indirect.ll

+; RUN: opt -S -mtriple=amdgcn-amd-amdhsa -amdgpu-propagate-attributes-late  %s | FileCheck %s
+
+; Test to check if we skip attributes on address
+; taken functions and its callees.
+
+; CHECK-LABEL: define float @bar() {
+define float @bar() {
+  ret float 0.0
+}
+
+; CHECK-LABEL: define float @baz() {
+define float @baz() {
+  ret float 0.0
+}
+
+; CHECK-LABEL: define float @foo() {
+define float @foo() {
+  %v1 = call contract float @bar()
+  %v2 = call contract float @baz()
+  %v3 = fadd float %v1, %v2
+  ret float %v3
+}
+
+; CHECK-LABEL: define amdgpu_kernel void @kernel(float* %result, i32 %type) #0 {
+define amdgpu_kernel void @kernel(float *%result, i32 %type) #1 {
+  %fn = alloca float ()*
+  store float ()* @foo, float ()** %fn
+  %fp = load float ()*, float ()** %fn
+  %indirect_call = call contract float %fp()
+  store float %indirect_call, float* %result
+  ret void
+}
+
+attributes #1 = { "amdgpu-flat-work-group-size"="1,256" }

llvm/test/CodeGen/AMDGPU/propagate-attributes-launch-bounds.ll

+; RUN: opt -S -mtriple=amdgcn-amd-amdhsa -amdgpu-propagate-attributes-late  %s | FileCheck %s
+
+; Test attributes on a function which
+; is called indirectly from two kernels
+; having different launch bounds.
+
+; This function should not have any attributes on it.
+; CHECK-LABEL: define float @foo() {
+define float @foo() {
+   ret float 0.0
+}
+
+define amdgpu_kernel void @kernel1(float *%result, i32 %type) #1 {
+  %fn = alloca float ()*
+  store float ()* @foo, float ()** %fn
+  %fp = load float ()*, float ()** %fn
+  %indirect_call = call contract float %fp()
+  store float %indirect_call, float* %result
+  ret void
+}
+
+define amdgpu_kernel void @kernel2(float *%result, i32 %type) #2 {
+  %fn = alloca float ()*
+  store float ()* @foo, float ()** %fn
+  %fp = load float ()*, float ()** %fn
+  %indirect_call = call contract float %fp()
+  store float %indirect_call, float* %result
+  ret void
+}
+
+attributes #1 = { "amdgpu-flat-work-group-size"="1,256" }
+attributes #2 = { "amdgpu-flat-work-group-size"="1,512" }