[PowerPC] Fix missing nop after call to weak callee.

[stefanp]

Summary

Weak functions can be replaced by other functions at link time. Previously it
was assumed that no matter what the weak callee function was replaced with it
would still share the same TOC as the caller. This is no longer true as a weak
callee with a TOC setup can be replaced by another function that was compiled
with PC Relative and does not have a TOC at all.

This patch makes sure that all calls to functions defined as weak from a caller
that has a valid TOC have a nop after the call to allow a place for the linker
to restore the TOC.

[NeHuang]

llvm/test/CodeGen/PowerPC/ppc64-calls.ll

26

nit code models

33

Should we put a CHECK-NEXT here

llvm/test/CodeGen/PowerPC/preemption.ll

231

should we put a CHECK-NEXT here?

[stefanp]

Updated test cases according to review.

[amyk]

llvm/test/CodeGen/PowerPC/preemption.ll

247

CHECK-NEXT here, too?

[stefanp]

Added CHECK-NEXT that was missed.

[NeHuang]

LGTM.

llvm/lib/Target/PowerPC/PPCISelLowering.cpp

#endif
 
   // If the callee uses PC Relative we cannot guarantee that the callee won't
   // clobber the TOC of the caller and so we must assume that the two
   // functions do not share a TOC base.
   const PPCSubtarget *STICallee = &TM.getSubtarget<PPCSubtarget>(*F);
   if (STICallee->isUsingPCRelativeCalls())
     return false;
 
+  // If the GV is not a strong definition then we need to assume it can be
+  // replaced by another function at link time. The function that replaces
+  // it may not share the same TOC as the caller since the callee may be
+  // replaced by a PC Relative version of the same function.
+  if (!GV->isStrongDefinitionForLinker())
+    return false;
+
   // The medium and large code models are expected to provide a sufficiently
   // large TOC to provide all data addressing needs of a module with a
   // single TOC.
   if (CodeModel::Medium == TM.getCodeModel() ||
       CodeModel::Large == TM.getCodeModel())
     return true;
 
-  // Otherwise we need to ensure callee and caller are in the same section,
-  // since the linker may allocate multiple TOCs, and we don't know which
-  // sections will belong to the same TOC base.
-  if (!GV->isStrongDefinitionForLinker())
-    return false;
-
   // Any explicitly-specified sections and section prefixes must also match.
   // Also, if we're using -ffunction-sections, then each function is always in
   // a different section (the same is true for COMDAT functions).
   if (TM.getFunctionSections() || GV->hasComdat() || Caller->hasComdat() ||
       GV->getSection() != Caller->getSection())
     return false;
   if (const auto *F = dyn_cast<Function>(GV)) {
     if (F->getSectionPrefix() != Caller->getSectionPrefix())

llvm/test/CodeGen/PowerPC/ppc64-blnop.ll

 
 define weak_odr hidden void @wo_hcallee(%class.T* %this, i8* %c) { ret void }
 define void @wo_hcaller(%class.T* %this, i8* %c) {
   call void @wo_hcallee(%class.T* %this, i8* %c)
   ret void
 
 ; CHECK-LABEL: wo_hcaller:
 ; CHECK: bl wo_hcallee
-; CHECK-NOT: nop
+; CHECK-NEXT: nop
 
 ; SCM-LABEL: wo_hcaller:
 ; SCM:       bl wo_hcallee
 ; SCM-NEXT:  nop
 }
 
 define weak_odr protected void @wo_pcallee(%class.T* %this, i8* %c) { ret void }
 define void @wo_pcaller(%class.T* %this, i8* %c) {
   call void @wo_pcallee(%class.T* %this, i8* %c)
   ret void
 
 ; CHECK-LABEL: wo_pcaller:
 ; CHECK: bl wo_pcallee
-; CHECK-NOT: nop
+; CHECK-NEXT: nop
 
 ; SCM-LABEL:   wo_pcaller:
 ; SCM:         bl wo_pcallee
 ; SCM-NEXT:    nop
 }
 
 define weak_odr void @wo_callee(%class.T* %this, i8* %c) { ret void }
 define void @wo_caller(%class.T* %this, i8* %c) {
   call void @wo_callee(%class.T* %this, i8* %c)
   ret void
 
 ; CHECK-LABEL: wo_caller:
 ; CHECK: bl wo_callee
 ; CHECK-NEXT: nop
 }
 
 define weak protected void @w_pcallee(i8* %ptr) { ret void }
 define void @w_pcaller(i8* %ptr) {
   call void @w_pcallee(i8* %ptr)
   ret void
 
 ; CHECK-LABEL: w_pcaller:
 ; CHECK: bl w_pcallee
-; CHECK-NOT: nop
+; CHECK-NEXT: nop
 
 ; SCM-LABEL: w_pcaller:
 ; SCM:       bl w_pcallee
 ; SCM-NEXT:  nop
 }
 
 define weak hidden void @w_hcallee(i8* %ptr) { ret void }
 define void @w_hcaller(i8* %ptr) {
   call void @w_hcallee(i8* %ptr)
   ret void
 
 ; CHECK-LABEL: w_hcaller:
 ; CHECK: bl w_hcallee
-; CHECK-NOT: nop
+; CHECK-NEXT: nop
 
 ; SCM-LABEL: w_hcaller:
 ; SCM:       bl w_hcallee
 ; SCM-NEXT:  nop
 }
 
 define weak void @w_callee(i8* %ptr) { ret void }
 define void @w_caller(i8* %ptr) {
   call void @w_callee(i8* %ptr)
   ret void
 
 ; CHECK-LABEL: w_caller:
 ; CHECK: bl w_callee
 ; CHECK-NEXT: nop
 }
 

llvm/test/CodeGen/PowerPC/ppc64-calls.ll

 ; CHECK-LABEL: test_direct:
   tail call void @foo() nounwind
 ; Because of tail call optimization, it can be 'b' instruction.
 ; CHECK: [[BR:b[l]?]] foo
 ; CHECK-NOT: nop
   ret void
 }
 
-; Calls to weak function requires a TOC restore 'nop' with the small codemodel
+; Calls to weak function requires a TOC restore 'nop' with all code models
 ; because the definition that gets choosen at link time may come from a
-; different section even though we have seen a weak definition in the same
-; section at compile time.
-; With large and medium codemodels no TOC restore is needed, since we know
-; whichever definition is choosen it resides within the same DSO boundaries and
-; therefore shares the same TOC.
+; different compilation unit that was compiled with PC Relative and has no TOC.
 define void @test_weak() nounwind readnone {
   tail call void @foo_weak() nounwind
 ; CHECK-LABEL: test_weak:
-; CHECK: b foo_weak
-; CHECK-NOT: nop
+; CHECK:       bl foo_weak
+; CHECK-NEXT:  nop
 
 ; SCM-LABEL: test_weak:
 ; SCM:       bl foo_weak
 ; SCM-NEXT:  nop
   ret void
 }
 
 ; Indirect calls requires a full stub creation

llvm/test/CodeGen/PowerPC/ppc64-sibcall.ll

 %class.T = type { [2 x i8] }
 
 define weak_odr hidden void @wo_hcallee(%class.T* %this, i8* %c) { ret void }
 define void @wo_hcaller(%class.T* %this, i8* %c) {
   tail call void @wo_hcallee(%class.T* %this, i8* %c)
   ret void
 
 ; CHECK-SCO-LABEL: wo_hcaller:
-; CHECK-SCO: b wo_hcallee
+; CHECK-SCO: bl wo_hcallee
 
 ; SCM-LABEL: wo_hcaller:
 ; SCM:       bl wo_hcallee
 }
 
 define weak_odr protected void @wo_pcallee(%class.T* %this, i8* %c) { ret void }
 define void @wo_pcaller(%class.T* %this, i8* %c) {
   tail call void @wo_pcallee(%class.T* %this, i8* %c)
   ret void
 
 ; CHECK-SCO-LABEL: wo_pcaller:
-; CHECK-SCO: b wo_pcallee
+; CHECK-SCO: bl wo_pcallee
 
 ; SCM-LABEL: wo_pcaller:
 ; SCM:       bl wo_pcallee
 }
 
 define weak_odr void @wo_callee(%class.T* %this, i8* %c) { ret void }
 define void @wo_caller(%class.T* %this, i8* %c) {
   tail call void @wo_callee(%class.T* %this, i8* %c)
   ret void
 
 ; CHECK-SCO-LABEL: wo_caller:
-; CHECK-SCO: b wo_callee
+; CHECK-SCO: bl wo_callee
 
 ; SCM-LABEL: wo_caller:
 ; SCM:       bl wo_callee
 }
 
 define weak protected void @w_pcallee(i8* %ptr) { ret void }
 define void @w_pcaller(i8* %ptr) {
   tail call void @w_pcallee(i8* %ptr)
   ret void
 
 ; CHECK-SCO-LABEL: w_pcaller:
-; CHECK-SCO: b w_pcallee
+; CHECK-SCO: bl w_pcallee
 
 ; SCM-LABEL: w_pcaller:
 ; SCM:       bl w_pcallee
 }
 
 define weak hidden void @w_hcallee(i8* %ptr) { ret void }
 define void @w_hcaller(i8* %ptr) {
   tail call void @w_hcallee(i8* %ptr)
   ret void
 
 ; CHECK-SCO-LABEL: w_hcaller:
-; CHECK-SCO: b w_hcallee
+; CHECK-SCO: bl w_hcallee
 
 ; SCM-LABEL: w_hcaller:
 ; SCM:       bl w_hcallee
 }
 
 define weak void @w_callee(i8* %ptr) { ret void }
 define void @w_caller(i8* %ptr) {
   tail call void @w_callee(i8* %ptr)
   ret void
 
 ; CHECK-SCO-LABEL: w_caller:
-; CHECK-SCO: b w_callee
+; CHECK-SCO: bl w_callee
 
 ; SCM-LABEL: w_caller:
 ; SCM:       bl w_callee
 }
 
 %struct.byvalTest = type { [8 x i8] }
 @byval = common global %struct.byvalTest zeroinitializer
 
 define void @byval_callee(%struct.byvalTest* byval(%struct.byvalTest) %ptr) { ret void }
 define void @byval_caller() {
   tail call void @byval_callee(%struct.byvalTest* byval(%struct.byvalTest) @byval)
   ret void
 
 ; CHECK-SCO-LABEL: bl byval_callee
 ; CHECK-SCO: bl byval_callee
 }

llvm/test/CodeGen/PowerPC/pr41088.ll

 ; CHECK-NEXT:    li r3, 0
 ; CHECK-NEXT:  # %bb.1: # %bb9
 ; CHECK-NEXT:    bl test5
 ; CHECK-NEXT:    nop
 ; CHECK-NEXT:    rlwinm r3, r3, 8, 16, 23
 ; CHECK-NEXT:  # %bb.2: # %bb12
 ; CHECK-NEXT:    clrldi r4, r3, 32
 ; CHECK-NEXT:    bl test3
+; CHECK-NEXT:    nop
 ; CHECK-NEXT:    addi r1, r1, 32
 ; CHECK-NEXT:    ld r0, 16(r1)
 ; CHECK-NEXT:    mtlr r0
 ; CHECK-NEXT:    blr
 bb:
   switch i64 undef, label %bb21 [
     i64 3, label %bb3
   ]

llvm/test/CodeGen/PowerPC/preemption.ll

define weak signext i32 @weak_default_function(i32 %i) {
   ret i32 %i
 }
 define signext i32 @weak_default_function_caller(i32 %i) {
   %call = notail call signext i32 @weak_default_function(i32 signext %i)
   ret i32 %call
 
 ; STATIC-LABEL: @weak_default_function_caller
 ; STATIC:       bl weak_default_function
-; STATIC-NOT:   nop
+; STATIC-NEXT:  nop
 ; STATIC:       blr
 
 ; CHECK-LABEL:  @weak_default_function_caller
 ; CHECK:        bl weak_default_function
 ; CHECK-NEXT:   nop
 ; CHECK:        blr
 }
 
define weak dso_local signext i32 @weak_local_function(i32 %i) {
   ret i32 %i
 }
 define signext i32 @weak_local_function_caller(i32 %i) {
   %call = notail call signext i32 @weak_local_function(i32 signext %i)
   ret i32 %call
 
 ; STATIC-LABEL: @weak_local_function_caller
 ; STATIC:       bl weak_local_function
-; STATIC-NOT:   nop
+; STATIC-NEXT:  nop
 ; STATIC:       blr
 
 ; CHECK-LABEL:  @weak_local_function_caller
 ; CHECK:        bl weak_local_function
-; CHECK-NOT:    nop
+; CHECK-NEXT:   nop
 ; CHECK:        blr
 }
 
 declare dso_local i32 @external_local_function(i32 %i)
 define i32 @external_local_function_caller(i32 %i) {
   %call = notail call signext i32  @external_local_function(i32 signext %i)
   ret i32 %call
 
 ; STATIC-LABEL: @external_local_function_caller
 ; STATIC:       bl external_local_function
-; STATIC-NOT:  nop
+; STATIC-NEXT:  nop
 ; STATIC:       blr
 
 ; CHECK-LABEL:  @external_local_function_caller
 ; CHECK:        bl external_local_function
-; CHECK-NOT:    nop
+; CHECK-NEXT:   nop
 ; CHECK:        blr
 }
 
 define dso_preemptable signext i32 @strong_preemptable_function(i32 %i) {
   ret i32 %i
 }
 define signext i32 @strong_preemptable_function_caller(i32 %i) {
   %call = notail call signext i32 @strong_preemptable_function(i32 signext %i)
define weak dso_preemptable signext i32 @weak_preemptable_function(i32 %i) {
   ret i32 %i
 }
 define signext i32 @weak_preemptable_function_caller(i32 %i) {
   %call = notail call signext i32 @weak_preemptable_function(i32 signext %i)
   ret i32 %call
 
 ; STATIC-LABEL: @weak_preemptable_function_caller
 ; STATIC:       bl weak_preemptable_function
-; STATIC-NOT:   nop
+; STATIC-NEXT:  nop
 ; STATIC:       blr
 
 ; CHECK-LABEL:  @weak_preemptable_function_caller
 ; CHECK:        bl weak_preemptable_function
 ; CHECK-NEXT:   nop
 ; CHECK:        blr
 }
 

llvm/test/CodeGen/PowerPC/xray-tail-call-hidden.ll

 ; RUN: llc -filetype=asm -o - -mtriple=powerpc64le-unknown-linux-gnu < %s | FileCheck %s
 
 declare hidden i32 @callee() nounwind noinline uwtable "function-instrument"="xray-always"
 
 define i32 @caller() nounwind noinline uwtable "function-instrument"="xray-always" {
 ; CHECK-LABEL: .Ltmp0:
 ; CHECK:              b .Ltmp1
 ; CHECK-NEXT:         nop
 ; CHECK-NEXT:         std 0, -8(1)
 ; CHECK-NEXT:         mflr 0
 ; CHECK-NEXT:         bl __xray_FunctionEntry
 ; CHECK-NEXT:         nop
 ; CHECK-NEXT:         mtlr 0
 ; CHECK-LABEL: .Ltmp1:
+; CHECK:              bl callee
+; CHECK-NEXT:         nop
   %retval = tail call i32 @callee()
   ret i32 %retval
 ; CHECK-LABEL: .Ltmp2:
-; CHECK:              b callee
-; CHECK-NEXT:         nop
-; CHECK-NEXT:         std 0, -8(1)
+; CHECK:              std 0, -8(1)
 ; CHECK-NEXT:         mflr 0
 ; CHECK-NEXT:         bl __xray_FunctionExit
 ; CHECK-NEXT:         nop
 ; CHECK-NEXT:         mtlr 0
 }