Fix incorrect logic in maintaining the side-effect of compiler generated outliner functions

[jinlin]

Summary

Fix incorrect logic in maintaining the side-effect of compiler generated outliner functions by adding the up-exposed uses.

[lebedev.ri]

Are tests missing here?

[tellenbach]

As @lebedev.ri already said, is it possible to add a test for this? I know it is probably covered in your test for D71027 but an independent test would be great!

llvm/lib/CodeGen/MachineOutliner.cpp

1249

This comment is not correct anymore: The helper lambda is gone.

1255

I guess this can be moved into the for-loop since it's not needed outside of the loop scope.

1263

Can't this just be MachineInstr *MI = Iter;? You could actually just use Iter directly and omit the new variable.

1282–1283

This ; can be removed.

1283–1290

Can this be const &? You could even think about making this type explicit since it's not very verbose but no strong opinion on this.

[jinlin]

In D71217#1775913, @tellenbach wrote:

As @lebedev.ri already said, is it possible to add a test for this? I know it is probably covered in your test for D71027 but an independent test would be great!

Hi David, a standalone test would be ideal, but it is extremely difficult to come up with such a test case. I have spent many days thinking about a test case for this incorrect logic.
Given the end of the workflow where it happen, exposing the bug is quite difficult.
Under such circumstance, it would not be prudent to get blocked on a test case. The outline-repeat feature exercises the need for this fix and a test case added there serves the purpose.
Hope you can understand and sympathize with me.

[paquette]

I think that it should be possible to write a test case for this. You don't really have to expose a *bug* here but just show that the exposed uses are added to the outlined function. That's sufficient for a testcase.

I think that you can probably do this by copying + editing one of the existing outliner testcases. A good test to base it off of might be llvm/test/CodeGen/AArch64/machine-outliner-calls.mir, since it's pretty simple.

llvm/lib/CodeGen/MachineOutliner.cpp

1252–1263

Can this be Register instead of unsigned?

1262

Can you pull the variables into the loop header to fit this sort of style?

for (MachineBasicBlock::reverse_iterator Iter = (stuff), Last = (stuff); Iter != Last; ++Iter)

Then it's clear that the variables are only used in the loop.

1273–1274

Comment?

1275–1276

Add a brace?

1275–1276

Comment?

1283–1290

+1 for making type explicit

[jinlin]

llvm/lib/CodeGen/MachineOutliner.cpp

1263

The iterators you’ll be working with in the LLVM framework are special: they will automatically convert to a ptr-to-instance type whenever they need to. Instead of dereferencing the iterator and then taking the address of the result, you can simply assign the iterator to the proper pointer type and you get the dereference and address-of operation as a result of the assignment. You can refer to the details in http://llvm.org/docs/ProgrammersManual.html.

[jinlin]

I have updated the code based on reviewers' feedback and added one test case. Thanks.

[jinlin]

Fix typos in the comments.

[jinlin]

More minor changes.

[paquette]

I think a MIR testcase would be simpler here. Something like this should work, no?

# NOTE: Assertions have been autogenerated by utils/update_mir_test_checks.py
# RUN: llc -mtriple=aarch64-apple-darwin -run-pass=machine-outliner -verify-machineinstrs  %s -o - | FileCheck %s
--- |
  define void @foo() noredzone {ret void}
...
---

name:            foo
tracksRegLiveness: true
body:             |
  ; CHECK-LABEL: name: foo
  ; CHECK: bb.0:
  ; CHECK:   successors: %bb.1(0x80000000)
  ; CHECK:   liveins: $w4
  ; CHECK:   BL @OUTLINED_FUNCTION_0, implicit-def $lr, implicit $sp, implicit-def $w3, implicit-def $w2, implicit-def $w1, implicit-def $w0, implicit-def $lr, implicit-def $w3, implicit-def $w2, implicit-def $w1, implicit-def $w0, implicit $sp, implicit $wzr, implicit $w4
  ; CHECK: bb.1:
  ; CHECK:   successors: %bb.2(0x80000000)
  ; CHECK:   liveins: $w4
  ; CHECK:   BL @OUTLINED_FUNCTION_0, implicit-def $lr, implicit $sp, implicit-def $w3, implicit-def $w2, implicit-def $w1, implicit-def $w0, implicit-def $lr, implicit-def $w3, implicit-def $w2, implicit-def $w1, implicit-def $w0, implicit $sp, implicit $wzr, implicit $w4
  ; CHECK: bb.2:
  ; CHECK:   successors: %bb.3(0x80000000)
  ; CHECK:   liveins: $w4
  ; CHECK:   BL @OUTLINED_FUNCTION_0, implicit-def $lr, implicit $sp, implicit-def $w3, implicit-def $w2, implicit-def $w1, implicit-def $w0, implicit-def $lr, implicit-def $w3, implicit-def $w2, implicit-def $w1, implicit-def $w0, implicit $sp, implicit $wzr, implicit $w4
  ; CHECK: bb.3:
  ; CHECK:   liveins: $w4
  ; CHECK:   RET_ReallyLR
  bb.0:
  liveins: $w4
    $w0 = ORRWri $wzr, 1
    $w1 = ORRWri $wzr, 2
    $w2 = ORRWri $wzr, 3
    $w3 = ORRWri $w4, 4
  bb.1:
  liveins: $w4
    $w0 = ORRWri $wzr, 1
    $w1 = ORRWri $wzr, 2
    $w2 = ORRWri $wzr, 3
    $w3 = ORRWri $w4, 4
  bb.2:
    liveins: $w4
    $w0 = ORRWri $wzr, 1
    $w1 = ORRWri $wzr, 2
    $w2 = ORRWri $wzr, 3
    $w3 = ORRWri $w4, 4
  bb.3:
    liveins: $w4
    RET_ReallyLR

[jinlin]

In D71217#1875153, @paquette wrote:

I think a MIR testcase would be simpler here. Something like this should work, no?

# NOTE: Assertions have been autogenerated by utils/update_mir_test_checks.py
# RUN: llc -mtriple=aarch64-apple-darwin -run-pass=machine-outliner -verify-machineinstrs  %s -o - | FileCheck %s
--- |
  define void @foo() noredzone {ret void}
...
---

name:            foo
tracksRegLiveness: true
body:             |
  ; CHECK-LABEL: name: foo
  ; CHECK: bb.0:
  ; CHECK:   successors: %bb.1(0x80000000)
  ; CHECK:   liveins: $w4
  ; CHECK:   BL @OUTLINED_FUNCTION_0, implicit-def $lr, implicit $sp, implicit-def $w3, implicit-def $w2, implicit-def $w1, implicit-def $w0, implicit-def $lr, implicit-def $w3, implicit-def $w2, implicit-def $w1, implicit-def $w0, implicit $sp, implicit $wzr, implicit $w4
  ; CHECK: bb.1:
  ; CHECK:   successors: %bb.2(0x80000000)
  ; CHECK:   liveins: $w4
  ; CHECK:   BL @OUTLINED_FUNCTION_0, implicit-def $lr, implicit $sp, implicit-def $w3, implicit-def $w2, implicit-def $w1, implicit-def $w0, implicit-def $lr, implicit-def $w3, implicit-def $w2, implicit-def $w1, implicit-def $w0, implicit $sp, implicit $wzr, implicit $w4
  ; CHECK: bb.2:
  ; CHECK:   successors: %bb.3(0x80000000)
  ; CHECK:   liveins: $w4
  ; CHECK:   BL @OUTLINED_FUNCTION_0, implicit-def $lr, implicit $sp, implicit-def $w3, implicit-def $w2, implicit-def $w1, implicit-def $w0, implicit-def $lr, implicit-def $w3, implicit-def $w2, implicit-def $w1, implicit-def $w0, implicit $sp, implicit $wzr, implicit $w4
  ; CHECK: bb.3:
  ; CHECK:   liveins: $w4
  ; CHECK:   RET_ReallyLR
  bb.0:
  liveins: $w4
    $w0 = ORRWri $wzr, 1
    $w1 = ORRWri $wzr, 2
    $w2 = ORRWri $wzr, 3
    $w3 = ORRWri $w4, 4
  bb.1:
  liveins: $w4
    $w0 = ORRWri $wzr, 1
    $w1 = ORRWri $wzr, 2
    $w2 = ORRWri $wzr, 3
    $w3 = ORRWri $w4, 4
  bb.2:
    liveins: $w4
    $w0 = ORRWri $wzr, 1
    $w1 = ORRWri $wzr, 2
    $w2 = ORRWri $wzr, 3
    $w3 = ORRWri $w4, 4
  bb.3:
    liveins: $w4
    RET_ReallyLR

The outlined function in this test case does not serve the purpose since there are no live in registers. I did check this test case before. If I change the arguments 1, 2, 3, 4 to be incoming registers, the machine outliner won't kick in.

[paquette]

The outlined function in this test case does not serve the purpose since there are no live in registers. I did check this test case before. If I change the arguments 1, 2, 3, 4 to be incoming registers, the machine outliner won't kick in.

Maybe I'm misunderstanding something here?

(1) Locally, with the patch, adding

liveins: $w0, $w1, $w2, $w3, $w4

does not change the outliner's behaviour.

(2) If I understand correctly, what you are trying to test here is that implicit $xN is added to the outlined call when $xN is not undefined in the outlined range.

Without this patch, this testcase produces

BL @OUTLINED_FUNCTION_0, implicit-def $lr, implicit $sp, implicit-def $lr, implicit-def $w0, implicit-def $w1, implicit-def $w2, implicit-def $w3

With the patch, it adds implicit $wzr, implicit $w4 at the end:

BL @OUTLINED_FUNCTION_0, implicit-def $lr, implicit $sp, implicit-def $w3, implicit-def $w2, implicit-def $w1, implicit-def $w0, implicit-def $lr, implicit-def $w3, implicit-def $w2, implicit-def $w1, implicit-def $w0, implicit $sp, implicit $wzr, implicit $w4

It's kind of weird that the implicit defs are duplicated though. ($lr appears twice in both cases). I'd expect it to be

BL @OUTLINED_FUNCTION_0, implicit-def $lr, implicit-def $w0, implicit-def $w1, implicit-def $w2, implicit-def $w3, implicit $sp, implicit $wzr, implicit $w4

Also, I guess it would also be good to add a testcase that ensures that a register is not added as implicit when it's undefined in the range.

[jinlin]

The reason that the implicit defs are duplicate is because the compiler traverses the instructions in the reverse order and update the side effect of the new call instruction on the fly.
So the def reg set is introduced to avoid the redundant register.

In fact, the existing compiler already inserts some duplicate defs for call instruction.

BL @OUTLINED_FUNCTION_0, implicit-def $lr, implicit $sp, implicit-def $lr, implicit-def $w0, implicit-def $w1, implicit-def $w2, implicit-def $w3

[jinlin]

In D71217#1875226, @paquette wrote:

The outlined function in this test case does not serve the purpose since there are no live in registers. I did check this test case before. If I change the arguments 1, 2, 3, 4 to be incoming registers, the machine outliner won't kick in.

Maybe I'm misunderstanding something here?

(1) Locally, with the patch, adding

liveins: $w0, $w1, $w2, $w3, $w4

does not change the outliner's behaviour.

(2) If I understand correctly, what you are trying to test here is that implicit $xN is added to the outlined call when $xN is not undefined in the outlined range.

Without this patch, this testcase produces

BL @OUTLINED_FUNCTION_0, implicit-def $lr, implicit $sp, implicit-def $lr, implicit-def $w0, implicit-def $w1, implicit-def $w2, implicit-def $w3

With the patch, it adds implicit $wzr, implicit $w4 at the end:

BL @OUTLINED_FUNCTION_0, implicit-def $lr, implicit $sp, implicit-def $w3, implicit-def $w2, implicit-def $w1, implicit-def $w0, implicit-def $lr, implicit-def $w3, implicit-def $w2, implicit-def $w1, implicit-def $w0, implicit $sp, implicit $wzr, implicit $w4

It's kind of weird that the implicit defs are duplicated though. ($lr appears twice in both cases). I'd expect it to be

BL @OUTLINED_FUNCTION_0, implicit-def $lr, implicit-def $w0, implicit-def $w1, implicit-def $w2, implicit-def $w3, implicit $sp, implicit $wzr, implicit $w4

Also, I guess it would also be good to add a testcase that ensures that a register is not added as implicit when it's undefined in the range.

Hi Jessica.
My current test case does not have undefined use register issue. It is very difficult to come up another test case to show the undefined register issue. Is it all right to have one test case for this change?
Thanks,
--Jin

[jinlin]

Also, I guess it would also be good to add a testcase that ensures that a register is not added as implicit when it's undefined in the range.

Hi Jessica,

The logic at line 1275 will not introduce any new stability issue compared to the existing compiler since the existing compiler does not generate any implicit use of registers. That is why I think it is fine not to have a test case for this. What do you think?

--Jin

[jinlin]

Updated test case.

[jinlin]

Hi Jessica,

Is there anything I can improve with latest change?

Thanks,

Jin

In D71217#1875153, @paquette wrote:

I think a MIR testcase would be simpler here. Something like this should work, no?

# NOTE: Assertions have been autogenerated by utils/update_mir_test_checks.py
# RUN: llc -mtriple=aarch64-apple-darwin -run-pass=machine-outliner -verify-machineinstrs  %s -o - | FileCheck %s
--- |
  define void @foo() noredzone {ret void}
...
---

name:            foo
tracksRegLiveness: true
body:             |
  ; CHECK-LABEL: name: foo
  ; CHECK: bb.0:
  ; CHECK:   successors: %bb.1(0x80000000)
  ; CHECK:   liveins: $w4
  ; CHECK:   BL @OUTLINED_FUNCTION_0, implicit-def $lr, implicit $sp, implicit-def $w3, implicit-def $w2, implicit-def $w1, implicit-def $w0, implicit-def $lr, implicit-def $w3, implicit-def $w2, implicit-def $w1, implicit-def $w0, implicit $sp, implicit $wzr, implicit $w4
  ; CHECK: bb.1:
  ; CHECK:   successors: %bb.2(0x80000000)
  ; CHECK:   liveins: $w4
  ; CHECK:   BL @OUTLINED_FUNCTION_0, implicit-def $lr, implicit $sp, implicit-def $w3, implicit-def $w2, implicit-def $w1, implicit-def $w0, implicit-def $lr, implicit-def $w3, implicit-def $w2, implicit-def $w1, implicit-def $w0, implicit $sp, implicit $wzr, implicit $w4
  ; CHECK: bb.2:
  ; CHECK:   successors: %bb.3(0x80000000)
  ; CHECK:   liveins: $w4
  ; CHECK:   BL @OUTLINED_FUNCTION_0, implicit-def $lr, implicit $sp, implicit-def $w3, implicit-def $w2, implicit-def $w1, implicit-def $w0, implicit-def $lr, implicit-def $w3, implicit-def $w2, implicit-def $w1, implicit-def $w0, implicit $sp, implicit $wzr, implicit $w4
  ; CHECK: bb.3:
  ; CHECK:   liveins: $w4
  ; CHECK:   RET_ReallyLR
  bb.0:
  liveins: $w4
    $w0 = ORRWri $wzr, 1
    $w1 = ORRWri $wzr, 2
    $w2 = ORRWri $wzr, 3
    $w3 = ORRWri $w4, 4
  bb.1:
  liveins: $w4
    $w0 = ORRWri $wzr, 1
    $w1 = ORRWri $wzr, 2
    $w2 = ORRWri $wzr, 3
    $w3 = ORRWri $w4, 4
  bb.2:
    liveins: $w4
    $w0 = ORRWri $wzr, 1
    $w1 = ORRWri $wzr, 2
    $w2 = ORRWri $wzr, 3
    $w3 = ORRWri $w4, 4
  bb.3:
    liveins: $w4
    RET_ReallyLR

[paquette]

This is a lot better, thank you for adding a MIR testcase! :)

I think that the testcase can be simplified a bit more, but this is very close.

llvm/test/CodeGen/AArch64/machine-outliner-side-effect.mir

1 ↗

(On Diff #245788)

I don't think you need prologepilog for this one

6–45 ↗

(On Diff #245788)

Most of the IR here can be deleted. Only things that must be directly referenced in the MIR are necessary. (e.g. function calls)

For example, you can replace baz.14 with just

define void @baz.14() { ret void } and it should still work.

60–82 ↗

(On Diff #245788)

Most of this can be deleted, I'm pretty sure.

86 ↗

(On Diff #245788)

Are the ADJCALLSTACKs actually necessary here?

87 ↗

(On Diff #245788)

Do you actually have to use calls to get the behaviour you want?

[jinlin]

llvm/test/CodeGen/AArch64/machine-outliner-side-effect.mir

1 ↗

(On Diff #245788)

The flag prologepilog is necessary otherwise the machine outlined function will not be generated.

6–45 ↗

(On Diff #245788)

The IR here cannot be deleted since all of them are referenced in the MIR.

Replacing baz.14 with define void @baz.14() { ret void } does not work.

60–82 ↗

(On Diff #245788)

Removed all unnecessary ones.

86 ↗

(On Diff #245788)

Removed.

87 ↗

(On Diff #245788)

Replaced with parameter.

[jinlin]

Thank you Jessica for quick feedback. I have updated the test case based on your advice.

[paquette]

The reason you weren't getting outlined functions is probably because there were attributes missing on the function.

I think that we should be able to simplify it further like this:

# RUN: llc -mtriple=aarch64 -run-pass=machine-outliner -verify-machineinstrs %s -o - | FileCheck %s

# The test checks whether the compiler updates the side effect of function @OUTLINED_FUNCTION_0 by adding the use of register x20.

--- |
  declare void @spam() local_unnamed_addr
  define void @baz() optsize minsize noredzone { ret void }
...
---
name:            baz
tracksRegLiveness: true
body:             |
  bb.0:
    liveins: $x0, $x20

    $x0 = COPY renamable $x20
    BL @spam, csr_aarch64_aapcs, implicit-def dead $lr, implicit $sp, implicit $x0, implicit-def $sp, implicit-def $x0
    renamable $x21 = COPY $x0

    $x0 = COPY renamable $x20
    BL @spam, csr_aarch64_aapcs, implicit-def dead $lr, implicit $sp, implicit $x0, implicit-def $sp, implicit-def $x0
    renamable $x22 = COPY $x0

    $x0 = COPY killed renamable $x20
    BL @spam, csr_aarch64_aapcs, implicit-def dead $lr, implicit $sp, implicit $x0, implicit-def $sp, implicit-def $x0
    renamable $x3 = COPY $x0

    RET_ReallyLR

...

# CHECK: BL @OUTLINED_FUNCTION_0, {{.*}}, implicit $x20, {{.*}}

[jinlin]

In D71217#1903635, @paquette wrote:

The reason you weren't getting outlined functions is probably because there were attributes missing on the function.

I think that we should be able to simplify it further like this:

# RUN: llc -mtriple=aarch64 -run-pass=machine-outliner -verify-machineinstrs %s -o - | FileCheck %s

# The test checks whether the compiler updates the side effect of function @OUTLINED_FUNCTION_0 by adding the use of register x20.

--- |
  declare void @spam() local_unnamed_addr
  define void @baz() optsize minsize noredzone { ret void }
...
---
name:            baz
tracksRegLiveness: true
body:             |
  bb.0:
    liveins: $x0, $x20

    $x0 = COPY renamable $x20
    BL @spam, csr_aarch64_aapcs, implicit-def dead $lr, implicit $sp, implicit $x0, implicit-def $sp, implicit-def $x0
    renamable $x21 = COPY $x0

    $x0 = COPY renamable $x20
    BL @spam, csr_aarch64_aapcs, implicit-def dead $lr, implicit $sp, implicit $x0, implicit-def $sp, implicit-def $x0
    renamable $x22 = COPY $x0

    $x0 = COPY killed renamable $x20
    BL @spam, csr_aarch64_aapcs, implicit-def dead $lr, implicit $sp, implicit $x0, implicit-def $sp, implicit-def $x0
    renamable $x3 = COPY $x0

    RET_ReallyLR

...

# CHECK: BL @OUTLINED_FUNCTION_0, {{.*}}, implicit $x20, {{.*}}

Thank you Jessica for helping creating the test case. It is much more simple compared to my old test.

[paquette]

LGTM!

[jinlin]

In D71217#1904168, @paquette wrote:

LGTM!

Thanks you Jessica for your great help!

[jinlin]

Hi Jessica,

I have updated the test machine-outliner-noreturn-save-lr.mir due to the changes of side-effect information for outlined functions. Would you please review it?

Thanks,

Jin

[paquette]

The changes to machine-outliner-noreturn-save-lr.mir look fine to me.

[jinlin]

rebase master

[jinlin]

In D71217#1905675, @paquette wrote:

The changes to machine-outliner-noreturn-save-lr.mir look fine to me.

Thank you Jessica for your quick update.

[aemerson]

Hi, I just tried out this patch locally and I'm seeing failures running the tests:

Failing Tests (3):
    LLVM :: CodeGen/AArch64/machine-outliner-cfi.mir
    LLVM :: CodeGen/AArch64/machine-outliner-noreturn-save-lr.mir
    LLVM :: CodeGen/AArch64/machine-outliner-side-effect.mir

[jinlin]

In D71217#1906007, @aemerson wrote:

Hi, I just tried out this patch locally and I'm seeing failures running the tests:

Failing Tests (3):
    LLVM :: CodeGen/AArch64/machine-outliner-cfi.mir
    LLVM :: CodeGen/AArch64/machine-outliner-noreturn-save-lr.mir
    LLVM :: CodeGen/AArch64/machine-outliner-side-effect.mir

Thanks for your notification. I did test it last night and did not see the failures. Let me double check.

[jinlin]

In D71217#1906007, @aemerson wrote:

Hi, I just tried out this patch locally and I'm seeing failures running the tests:

Failing Tests (3):
    LLVM :: CodeGen/AArch64/machine-outliner-cfi.mir
    LLVM :: CodeGen/AArch64/machine-outliner-noreturn-save-lr.mir
    LLVM :: CodeGen/AArch64/machine-outliner-side-effect.mir

I am sorry to post the the incorrect version of the file MachineOutliner in the last diff.

When I compared the last diff (10) with diff 9, I found that the file MachineOutliner is in the old version. This morning I tried to use git rebase master in my local branch, somehow this file was changed when the conflict happened.

I am working on the revert now.

[jinlin]

I have updated the diffs. Now when you compare Diff 248212 with Diff 248301, you will see they are the same.

[jinlin]

All the llvm-lit tests passed without any unexpected fails.

llvm/lib/CodeGen/MachineOutliner.cpp

 /// http://lists.llvm.org/pipermail/llvm-dev/2016-August/104170.html
 ///
 /// For more information on the suffix tree data structure, please see
 /// https://www.cs.helsinki.fi/u/ukkonen/SuffixT1withFigs.pdf
 ///
 //===----------------------------------------------------------------------===//
 #include "llvm/CodeGen/MachineOutliner.h"
 #include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/SmallSet.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/CodeGen/MachineFunction.h"
 #include "llvm/CodeGen/MachineModuleInfo.h"
 #include "llvm/CodeGen/MachineOptimizationRemarkEmitter.h"
 #include "llvm/CodeGen/MachineRegisterInfo.h"
 #include "llvm/CodeGen/Passes.h"
 #include "llvm/CodeGen/TargetInstrInfo.h"
for (Candidate &C : OF.Candidates) {
       auto CallInst = TII.insertOutlinedCall(M, MBB, StartIt, *MF, C);
 
       // If the caller tracks liveness, then we need to make sure that
       // anything we outline doesn't break liveness assumptions. The outlined
       // functions themselves currently don't track liveness, but we should
       // make sure that the ranges we yank things out of aren't wrong.
       if (MBB.getParent()->getProperties().hasProperty(
               MachineFunctionProperties::Property::TracksLiveness)) {
-        // Helper lambda for adding implicit def operands to the call
+        // The following code is to add implicit def operands to the call
         // instruction. It also updates call site information for moved
         // code.
-        auto CopyDefsAndUpdateCalls = [&CallInst](MachineInstr &MI) {
-          for (MachineOperand &MOP : MI.operands()) {
+        SmallSet<Register, 2> UseRegs;
+        // Copy over the defs in the outlined range.
+        // First inst in outlined range <-- Anything that's defined in this
+        // ...                           .. range has to be added as an
+        // implicit Last inst in outlined range  <-- def to the call
+        // instruction. Also remove call site information for outlined block
+        // of code. The exposed uses need to be copied in the outlined range.
+        for (MachineBasicBlock::reverse_iterator Iter = EndIt.getReverse(),
+             Last = std::next(CallInst.getReverse());
+             Iter != Last; Iter++) {
+          MachineInstr *MI = &*Iter;
+          for (MachineOperand &MOP : MI->operands()) {
             // Skip over anything that isn't a register.
             if (!MOP.isReg())
               continue;
 
             // If it's a def, add it to the call instruction.
-            if (MOP.isDef())
+            if (MOP.isDef()) {
               CallInst->addOperand(MachineOperand::CreateReg(
                   MOP.getReg(), true, /* isDef = true */
                   true /* isImp = true */));
-          }
-          if (MI.isCandidateForCallSiteEntry())
-            MI.getMF()->eraseCallSiteInfo(&MI);
-        };
-        // Copy over the defs in the outlined range.
-        // First inst in outlined range <-- Anything that's defined in this
-        // ...                           .. range has to be added as an
-        // implicit Last inst in outlined range  <-- def to the call
-        // instruction. Also remove call site information for outlined block
-        // of code.
-        std::for_each(CallInst, std::next(EndIt), CopyDefsAndUpdateCalls);
+              if (UseRegs.count(MOP.getReg()))
+                // Since the regiester is modeled as define,
+                // it is not necessary to stay in use register set.
+                UseRegs.erase(MOP.getReg());
+            } else if (!MOP.isUndef()) {
+              // Any register which is undefined should
+              // stay in the use register set.
+              UseRegs.insert(MOP.getReg());
+            }
+          }
+          if (MI->isCandidateForCallSiteEntry())
+            MI->getMF()->eraseCallSiteInfo(MI);
+        }
+        for (const Register &I : UseRegs)
+          // If it's a exposed use, add it to the call instruction.
+          CallInst->addOperand(
+              MachineOperand::CreateReg(I, false, /* isDef = false */
+                                        true /* isImp = true */));
       }
 
       // Erase from the point after where the call was inserted up to, and
       // including, the final instruction in the sequence.
       // Erase needs one past the end, so we need std::next there too.
       MBB.erase(std::next(StartIt), std::next(EndIt));
 
       // Keep track of what we removed by marking them all as -1.

llvm/test/CodeGen/AArch64/machine-outliner-side-effect.ll

+; RUN: llc -verify-machineinstrs -enable-machine-outliner -mtriple=aarch64-apple-darwin -stop-after=machine-outliner < %s | FileCheck %s
+
+; The test checks whether the compiler updates the side effect of function @OUTLINED_FUNCTION_3 by adding the use of register x27.
+
+%0 = type { double, double, double, double }
+%1 = type { i64 }
+%2 = type { %1*, i64 }
+%3 = type opaque
+%4 = type <{ [41 x i8] }>
+%5 = type opaque
+%6 = type <{ %7 }>
+%7 = type <{ %8 }>
+%8 = type <{ %3* }>
+%9 = type <{ [40 x i8] }>
+%10 = type <{ %2, %9, %11, %13, %14, %15, %16, %16, %16, %16, %16, %16, %16, %16, %16 }>
+%11 = type <{ %12 }>
+%12 = type <{ double }>
+%13 = type <{ [8 x i8] }>
+%14 = type { %5* }
+%15 = type { %2* }
+%16 = type <{ [1 x i8] }>
+%17 = type <{ %2, %6 }>
+%18 = type <{ %2, %19, %6 }>
+%19 = type <{ %11, %11, %11, %11 }>
+%20 = type <{ %2, %21 }>
+%21 = type <{ %22 }>
+%22 = type <{ %23, %23 }>
+%23 = type <{ i64 }>
+%24 = type <{ i8 }>
+
+@global = external local_unnamed_addr constant %0, align 8
+@global.3 = external hidden local_unnamed_addr global %1*, align 8
+@global.4 = external global %1
+
+; Function Attrs: nounwind
+declare void @blam(%2*) local_unnamed_addr #0
+
+; Function Attrs: nounwind
+declare %2* @widget(%2* returned) local_unnamed_addr #0
+
+; Function Attrs: nounwind
+declare %3* @blam.5(%3* returned) local_unnamed_addr #0
+
+; Function Attrs: argmemonly nounwind willreturn
+declare void @llvm.lifetime.start.p0i8(i64 immarg, i8* nocapture) #1
+
+; Function Attrs: nounwind
+declare void @foo(i8*, [24 x i8]*, i64, i8*) local_unnamed_addr #0
+
+; Function Attrs: nounwind
+declare %2* @widget.6(%1*, i64, i64) local_unnamed_addr #0
+
+; Function Attrs: nounwind
+declare void @widget.7(%3*) local_unnamed_addr #0
+
+; Function Attrs: argmemonly nounwind willreturn
+declare void @llvm.lifetime.end.p0i8(i64 immarg, i8* nocapture) #1
+
+; Function Attrs: noinline nounwind
+declare hidden %4* @hoge(%4*) local_unnamed_addr #2
+
+; Function Attrs: nounwind
+declare void @blam.8([24 x i8]*) local_unnamed_addr #0
+
+; Function Attrs: nounwind
+declare %2* @blam.9(%1*, %2*) local_unnamed_addr #0
+
+; Function Attrs: cold noreturn nounwind
+declare void @llvm.trap() #3
+
+; Function Attrs: minsize
+declare swiftcc %2 @barney(i64, %1*) local_unnamed_addr #4
+
+; Function Attrs: minsize noinline nounwind readnone
+declare hidden swiftcc %2 @foo.10(i64, %1**, %1*, %2 (i64, %1*)*) local_unnamed_addr #5
+
+; Function Attrs: nounwind readnone speculatable willreturn
+declare { i64, i1 } @llvm.sadd.with.overflow.i64(i64, i64) #6
+
+; Function Attrs: minsize
+declare swiftcc i64 @spam(%5*) local_unnamed_addr #4
+
+; Function Attrs: minsize
+declare hidden swiftcc void @blam.11(i64, %6* nocapture swiftself dereferenceable(8), void (i64, %6*)*) local_unnamed_addr #4
+
+; Function Attrs: noinline nounwind
+declare hidden %9* @foo.12(%9*, %9*) local_unnamed_addr #2
+
+; Function Attrs: minsize noinline nounwind readnone
+declare hidden swiftcc %2 @zot(i64) #5
+
+; Function Attrs: minsize noinline nounwind readnone
+declare hidden swiftcc %2 @foo.13(i64) #5
+
+; Function Attrs: minsize
+declare hidden swiftcc i1 @baz(%10* swiftself) #4
+
+; Function Attrs: minsize
+define hidden swiftcc void @baz.14(%10* swiftself %arg) #4 {
+bb:
+  %tmp = alloca %9, align 8
+  %tmp1 = alloca [24 x i8], align 8
+  %tmp2 = alloca [33 x i8], align 8
+  %tmp3 = alloca [24 x i8], align 8
+  %tmp4 = alloca [24 x i8], align 8
+  %tmp5 = alloca [36 x i8], align 8
+  %tmp6 = alloca [24 x i8], align 8
+  %tmp7 = alloca [34 x i8], align 8
+  %tmp8 = alloca [24 x i8], align 8
+  %tmp9 = alloca [24 x i8], align 8
+  %tmp10 = alloca [24 x i8], align 8
+  %tmp11 = tail call swiftcc %17* @bar(%1* swiftself undef)
+  %tmp12 = tail call swiftcc %2 @wibble(i64 0) #10
+  %tmp13 = extractvalue %2 %tmp12, 0
+  %tmp14 = getelementptr inbounds %9, %9* %tmp, i64 0, i32 0, i64 0
+  call void @llvm.lifetime.start.p0i8(i64 40, i8* nonnull %tmp14)
+  %tmp15 = getelementptr inbounds %10, %10* %arg, i64 0, i32 1
+  %tmp16 = getelementptr inbounds [24 x i8], [24 x i8]* %tmp1, i64 0, i64 0
+  call void @llvm.lifetime.start.p0i8(i64 -1, i8* nonnull %tmp16)
+  %tmp17 = getelementptr inbounds %9, %9* %tmp15, i64 0, i32 0, i64 0
+  call void @foo(i8* nonnull %tmp17, [24 x i8]* nonnull %tmp1, i64 0, i8* null) #0
+  %tmp18 = call %9* @foo.12(%9* %tmp15, %9* %tmp)
+  %tmp19 = call swiftcc i1 @widget.20(%9* noalias nocapture nonnull dereferenceable(40) %tmp, %1* swiftself %tmp13)
+  %tmp20 = call %9* bitcast (%4* (%4*)* @hoge to %9* (%9*)*)(%9* %tmp)
+  call void @llvm.lifetime.end.p0i8(i64 40, i8* nonnull %tmp14)
+  br label %bb28
+
+bb28:                                             ; preds = %bb21, %bb
+  %tmp29 = call swiftcc double @spam.23(double 2.500000e+00)
+  %tmp30 = call swiftcc double @spam.21()
+  %tmp31 = call swiftcc double @spam.23(double 2.500000e+00)
+  %tmp32 = call swiftcc double @spam.21()
+  %tmp33 = call swiftcc %2 @foo.13(i64 undef) #10
+  %tmp34 = extractvalue %2 %tmp33, 0
+  %tmp35 = call noalias %2* @widget.6(%1* %tmp34, i64 56, i64 7) #0
+  %tmp36 = bitcast %2* %tmp35 to %18*
+  %tmp37 = call swiftcc %18* @barney.16(double %tmp29, double %tmp30, double %tmp31, double %tmp32, %18* returned swiftself %tmp36)
+  %tmp38 = load double, double* getelementptr inbounds (%0, %0* @global, i64 0, i32 0), align 8
+  %tmp39 = load double, double* getelementptr inbounds (%0, %0* @global, i64 0, i32 1), align 8
+  %tmp40 = load double, double* getelementptr inbounds (%0, %0* @global, i64 0, i32 2), align 8
+  %tmp41 = load double, double* getelementptr inbounds (%0, %0* @global, i64 0, i32 3), align 8
+  %tmp42 = call swiftcc %2 @zot(i64 undef) #10
+  %tmp43 = extractvalue %2 %tmp42, 0
+  %tmp44 = call noalias %2* @widget.6(%1* %tmp43, i64 56, i64 7) #0
+  %tmp45 = bitcast %2* %tmp44 to %18*
+  %tmp46 = call swiftcc %18* @barney.16(double %tmp38, double %tmp39, double %tmp40, double %tmp41, %18* swiftself %tmp45)
+  %tmp47 = call swiftcc %2 @foo.10(i64 0, %1** @global.3, %1* @global.4, %2 (i64, %1*)* @barney)
+  %tmp48 = extractvalue %2 %tmp47, 0
+  %tmp49 = bitcast [33 x i8]* %tmp2 to %2*
+  %tmp50 = call %2* @blam.9(%1* %tmp48, %2* nonnull %tmp49) #0
+  %tmp51 = getelementptr inbounds %2, %2* %tmp50, i64 1
+  %tmp52 = bitcast %2* %tmp51 to <2 x i64>*
+  store <2 x i64> <i64 1, i64 2>, <2 x i64>* %tmp52, align 8
+  %tmp53 = bitcast %2* %tmp50 to %3*
+  %tmp54 = getelementptr inbounds %2, %2* %tmp50, i64 2
+  %tmp55 = bitcast %2* %tmp54 to i8*
+  store i8 6, i8* %tmp55, align 8
+  call swiftcc void @barney.17(%3* %tmp53, %18* swiftself %tmp46)
+  call void @eggs(%2* %tmp50) #0
+  %tmp56 = bitcast %2* %tmp50 to i8*
+  call void @llvm.lifetime.end.p0i8(i64 -1, i8* %tmp56)
+  %tmp57 = getelementptr inbounds %18, %18* %tmp37, i64 0, i32 2
+  %tmp58 = getelementptr inbounds [24 x i8], [24 x i8]* %tmp3, i64 0, i64 0
+  call void @llvm.lifetime.start.p0i8(i64 -1, i8* nonnull %tmp58)
+  %tmp59 = bitcast %6* %tmp57 to i8*
+  call void @foo(i8* nonnull %tmp59, [24 x i8]* nonnull %tmp3, i64 33, i8* null) #0
+  %tmp60 = getelementptr inbounds %18, %18* %tmp46, i64 0, i32 0
+  %tmp61 = call %2* @widget(%2* returned %tmp60) #0
+  call swiftcc void @quux(%6* nocapture swiftself dereferenceable(8) %tmp57, void (i64, %6*)* @wobble)
+  %tmp62 = getelementptr inbounds %6, %6* %tmp57, i64 0, i32 0, i32 0, i32 0
+  %tmp63 = load %3*, %3** %tmp62, align 8
+  %tmp64 = ptrtoint %3* %tmp63 to i64
+  %tmp65 = icmp ugt %3* %tmp63, inttoptr (i64 4611686018427387903 to %3*)
+  br label %bb66
+
+bb66:                                             ; preds = %bb28
+  %tmp67 = icmp sgt %3* %tmp63, inttoptr (i64 -1 to %3*)
+  %tmp68 = bitcast %3* %tmp63 to %5*
+  %tmp69 = and i64 %tmp64, 1152921504606846968
+  %tmp70 = inttoptr i64 %tmp69 to %5*
+  %tmp71 = select i1 %tmp67, %5* %tmp70, %5* %tmp68
+  %tmp72 = call %3* @blam.5(%3* returned %tmp63) #0
+  %tmp73 = call swiftcc i64 @spam(%5* %tmp71)
+  %tmp74 = call swiftcc i64 @spam(%5* %tmp71)
+  %tmp75 = call swiftcc i64 @spam(%5* %tmp71)
+  %tmp76 = icmp slt i64 %tmp75, %tmp73
+  %tmp77 = or i64 %tmp74, %tmp73
+  %tmp78 = icmp slt i64 %tmp77, 0
+  %tmp79 = or i1 %tmp78, %tmp76
+  br label %bb80
+
+bb80:                                             ; preds = %bb66
+  call void @widget.7(%3* %tmp63) #0
+  br label %bb86
+
+bb86:                                             ; preds = %bb81, %bb80
+  call swiftcc void @blam.11(i64 %tmp73, %6* nocapture swiftself dereferenceable(8) %tmp57, void (i64, %6*)* @wobble)
+  %tmp88 = call { i64, i1 } @llvm.sadd.with.overflow.i64(i64 %tmp73, i64 1)
+  %tmp89 = extractvalue { i64, i1 } %tmp88, 1
+  br label %bb90
+
+bb90:                                             ; preds = %bb86
+  %tmp91 = extractvalue { i64, i1 } %tmp88, 0
+  %tmp92 = bitcast %6* %tmp57 to i64*
+  %tmp93 = load i64, i64* %tmp92, align 8
+  %tmp94 = and i64 %tmp93, 1152921504606846968
+  %tmp95 = inttoptr i64 %tmp94 to %20*
+  %tmp96 = getelementptr inbounds %20, %20* %tmp95, i64 0, i32 1, i32 0, i32 0, i32 0
+  store i64 %tmp91, i64* %tmp96, align 8
+  %tmp97 = inttoptr i64 %tmp94 to i8*
+  %tmp98 = getelementptr inbounds i8, i8* %tmp97, i64 32
+  %tmp99 = bitcast i8* %tmp98 to %18**
+  %tmp100 = getelementptr inbounds %18*, %18** %tmp99, i64 %tmp73
+  store %18* %tmp46, %18** %tmp100, align 8
+  call void @blam.8([24 x i8]* nonnull %tmp3) #0
+  call void @llvm.lifetime.end.p0i8(i64 -1, i8* nonnull %tmp58)
+  %tmp101 = getelementptr inbounds %17, %17* %tmp11, i64 0, i32 1
+  %tmp102 = getelementptr inbounds [24 x i8], [24 x i8]* %tmp4, i64 0, i64 0
+  call void @llvm.lifetime.start.p0i8(i64 -1, i8* nonnull %tmp102)
+  %tmp103 = bitcast %6* %tmp101 to i8*
+  call void @foo(i8* nonnull %tmp103, [24 x i8]* nonnull %tmp4, i64 33, i8* null) #0
+  %tmp104 = getelementptr inbounds %18, %18* %tmp37, i64 0, i32 0
+  %tmp105 = call %2* @widget(%2* returned %tmp104) #0
+  call swiftcc void @quux(%6* nocapture swiftself dereferenceable(8) %tmp101, void (i64, %6*)* @baz.18)
+  %tmp106 = getelementptr inbounds %6, %6* %tmp101, i64 0, i32 0, i32 0, i32 0
+  %tmp107 = load %3*, %3** %tmp106, align 8
+  %tmp108 = ptrtoint %3* %tmp107 to i64
+  %tmp109 = icmp ugt %3* %tmp107, inttoptr (i64 4611686018427387903 to %3*)
+  br label %bb110
+
+bb110:                                            ; preds = %bb90
+  %tmp111 = icmp sgt %3* %tmp107, inttoptr (i64 -1 to %3*)
+  %tmp112 = bitcast %3* %tmp107 to %5*
+  %tmp113 = and i64 %tmp108, 1152921504606846968
+  %tmp114 = inttoptr i64 %tmp113 to %5*
+  %tmp115 = select i1 %tmp111, %5* %tmp114, %5* %tmp112
+  %tmp116 = call %3* @blam.5(%3* returned %tmp107) #0
+  %tmp117 = call swiftcc i64 @spam(%5* %tmp115)
+  %tmp118 = call swiftcc i64 @spam(%5* %tmp115)
+  %tmp119 = call swiftcc i64 @spam(%5* %tmp115)
+  %tmp120 = icmp slt i64 %tmp119, %tmp117
+  %tmp121 = or i64 %tmp118, %tmp117
+  %tmp122 = icmp slt i64 %tmp121, 0
+  %tmp123 = or i1 %tmp122, %tmp120
+  br label %bb124
+
+bb124:                                            ; preds = %bb110
+  call void @widget.7(%3* %tmp107) #0
+  br label %bb130
+
+bb130:                                            ; preds = %bb125, %bb124
+  call swiftcc void @blam.11(i64 %tmp117, %6* nocapture swiftself dereferenceable(8) %tmp101, void (i64, %6*)* @baz.18)
+  %tmp132 = call { i64, i1 } @llvm.sadd.with.overflow.i64(i64 %tmp117, i64 1)
+  %tmp133 = extractvalue { i64, i1 } %tmp132, 1
+  br label %bb134
+
+bb134:                                            ; preds = %bb130
+  %tmp135 = extractvalue { i64, i1 } %tmp132, 0
+  %tmp136 = bitcast %6* %tmp101 to i64*
+  %tmp137 = load i64, i64* %tmp136, align 8
+  %tmp138 = and i64 %tmp137, 1152921504606846968
+  %tmp139 = inttoptr i64 %tmp138 to %20*
+  %tmp140 = getelementptr inbounds %20, %20* %tmp139, i64 0, i32 1, i32 0, i32 0, i32 0
+  store i64 %tmp135, i64* %tmp140, align 8
+  %tmp141 = inttoptr i64 %tmp138 to i8*
+  %tmp142 = getelementptr inbounds i8, i8* %tmp141, i64 32
+  %tmp143 = bitcast i8* %tmp142 to %18**
+  %tmp144 = getelementptr inbounds %18*, %18** %tmp143, i64 %tmp117
+  store %18* %tmp37, %18** %tmp144, align 8
+  call void @blam.8([24 x i8]* nonnull %tmp4) #0
+  call void @llvm.lifetime.end.p0i8(i64 -1, i8* nonnull %tmp102)
+  call void @blam(%2* %tmp104) #0
+  call void @blam(%2* %tmp60) #0
+  br label %bb145
+
+bb145:                                            ; preds = %bb134, %bb23
+  %tmp150 = call swiftcc double @spam.23(double 2.500000e+00)
+  %tmp151 = call swiftcc double @spam.21()
+  %tmp152 = call swiftcc double @spam.23(double 2.500000e+00)
+  %tmp153 = call swiftcc double @spam.21()
+  %tmp154 = call swiftcc %2 @foo.13(i64 undef) #10
+  %tmp155 = extractvalue %2 %tmp154, 0
+  %tmp156 = call noalias %2* @widget.6(%1* %tmp155, i64 56, i64 7) #0
+  %tmp157 = bitcast %2* %tmp156 to %18*
+  %tmp158 = call swiftcc %18* @barney.16(double %tmp150, double %tmp151, double %tmp152, double %tmp153, %18* returned swiftself %tmp157)
+  %tmp159 = call swiftcc %2 @zot(i64 undef) #10
+  %tmp160 = extractvalue %2 %tmp159, 0
+  %tmp161 = call noalias %2* @widget.6(%1* %tmp160, i64 56, i64 7) #0
+  %tmp162 = bitcast %2* %tmp161 to %18*
+  %tmp163 = call swiftcc %18* @barney.16(double %tmp38, double %tmp39, double %tmp40, double %tmp41, %18* swiftself %tmp162)
+  %tmp164 = call swiftcc %2 @foo.10(i64 0, %1** @global.3, %1* @global.4, %2 (i64, %1*)* @barney)
+  %tmp165 = extractvalue %2 %tmp164, 0
+  %tmp166 = bitcast [36 x i8]* %tmp5 to %2*
+  %tmp167 = call %2* @blam.9(%1* %tmp165, %2* nonnull %tmp166) #0
+  %tmp168 = getelementptr inbounds %2, %2* %tmp167, i64 1
+  %tmp169 = bitcast %2* %tmp168 to <2 x i64>*
+  store <2 x i64> <i64 4, i64 8>, <2 x i64>* %tmp169, align 8
+  %tmp170 = bitcast %2* %tmp167 to %3*
+  %tmp171 = getelementptr inbounds %2, %2* %tmp167, i64 2
+  %tmp172 = bitcast %2* %tmp171 to %24*
+  %tmp173 = bitcast %2* %tmp171 to i8*
+  store i8 0, i8* %tmp173, align 8
+  %tmp174 = getelementptr inbounds %24, %24* %tmp172, i64 1, i32 0
+  store i8 3, i8* %tmp174, align 1
+  %tmp175 = getelementptr inbounds %24, %24* %tmp172, i64 2, i32 0
+  store i8 7, i8* %tmp175, align 2
+  %tmp176 = getelementptr inbounds %24, %24* %tmp172, i64 3, i32 0
+  store i8 2, i8* %tmp176, align 1
+  call swiftcc void @barney.17(%3* %tmp170, %18* swiftself %tmp163)
+  call void @eggs(%2* %tmp167) #0
+  %tmp177 = bitcast %2* %tmp167 to i8*
+  call void @llvm.lifetime.end.p0i8(i64 -1, i8* %tmp177)
+  %tmp178 = getelementptr inbounds %18, %18* %tmp158, i64 0, i32 2
+  %tmp179 = getelementptr inbounds [24 x i8], [24 x i8]* %tmp6, i64 0, i64 0
+  call void @llvm.lifetime.start.p0i8(i64 -1, i8* nonnull %tmp179)
+  %tmp180 = bitcast %6* %tmp178 to i8*
+  call void @foo(i8* nonnull %tmp180, [24 x i8]* nonnull %tmp6, i64 33, i8* null) #0
+  %tmp181 = getelementptr inbounds %18, %18* %tmp163, i64 0, i32 0
+  %tmp182 = call %2* @widget(%2* returned %tmp181) #0
+  call swiftcc void @quux(%6* nocapture swiftself dereferenceable(8) %tmp178, void (i64, %6*)* @wobble)
+  %tmp183 = getelementptr inbounds %6, %6* %tmp178, i64 0, i32 0, i32 0, i32 0
+  %tmp184 = load %3*, %3** %tmp183, align 8
+  %tmp185 = ptrtoint %3* %tmp184 to i64
+  %tmp186 = icmp ugt %3* %tmp184, inttoptr (i64 4611686018427387903 to %3*)
+  ret void
+
+}
+
+; Function Attrs: minsize nounwind
+declare hidden swiftcc %17* @bar(%1* nocapture readnone swiftself) #7
+
+; Function Attrs: minsize nounwind
+declare hidden swiftcc %18* @barney.16(double, double, double, double, %18* returned swiftself) local_unnamed_addr #7
+
+; Function Attrs: minsize
+declare hidden swiftcc void @barney.17(%3* nocapture readonly, %18* swiftself) local_unnamed_addr #4
+
+; Function Attrs: nounwind
+declare void @eggs(%2*) local_unnamed_addr #0
+
+; Function Attrs: minsize noinline
+declare hidden swiftcc void @wobble(i64, %6* nocapture swiftself dereferenceable(8)) local_unnamed_addr #8
+
+; Function Attrs: minsize
+declare hidden swiftcc void @quux(%6* nocapture swiftself dereferenceable(8), void (i64, %6*)*) local_unnamed_addr #4
+
+; Function Attrs: minsize noinline
+declare hidden swiftcc void @baz.18(i64, %6* nocapture swiftself dereferenceable(8)) local_unnamed_addr #8
+
+; Function Attrs: minsize noinline nounwind readnone
+declare swiftcc %2 @wibble(i64) #5
+
+; Function Attrs: minsize
+declare swiftcc i1 @widget.20(%9* noalias nocapture dereferenceable(40), %1* nocapture readnone swiftself) #4
+
+; Function Attrs: minsize
+declare swiftcc double @spam.21() #4
+
+; Function Attrs: minsize norecurse nounwind readnone
+declare swiftcc double @spam.23(double)
+
+attributes #0 = { nounwind }
+attributes #1 = { argmemonly nounwind willreturn }
+attributes #2 = { noinline nounwind }
+attributes #3 = { cold noreturn nounwind }
+attributes #4 = { minsize "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "target-cpu"="cyclone" "target-features"="+crypto,+fp-armv8,+neon,+zcm,+zcz" }
+attributes #5 = { minsize noinline nounwind readnone "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "target-cpu"="cyclone" "target-features"="+crypto,+fp-armv8,+neon,+zcm,+zcz" }
+attributes #6 = { nounwind readnone speculatable willreturn }
+attributes #7 = { minsize nounwind "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "target-cpu"="cyclone" "target-features"="+crypto,+fp-armv8,+neon,+zcm,+zcz" }
+attributes #8 = { minsize noinline "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "target-cpu"="cyclone" "target-features"="+crypto,+fp-armv8,+neon,+zcm,+zcz" }
+attributes #9 = { minsize norecurse nounwind readnone "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "target-cpu"="cyclone" "target-features"="+crypto,+fp-armv8,+neon,+zcm,+zcz" }
+attributes #10 = { nounwind readnone }
+
+; CHECK: BL @OUTLINED_FUNCTION_3, {{.*}}, implicit $x27