[AntiDepBreaker] Use liveins as well in StartBlock

[timshen]

Summary

Only calling getPristineRegs() is not sufficient, considering shrink wrapping puts
registers not saved in certain blocks. Use explicit isLiveIn instead.

This fixes pr32292.

[timshen]

About the test:

I tried to reduce the test, but as soon as the complexity gets smaller (not by much), the symptom disappears. I deliberately didn't shrink the test, and posted here to see if you think it's Ok to keep.

[hfinkel]

I see only 5 uses of getPristineRegs, two you're removing here from the anti-dep breakers, one in MachineVerifier, and two in asserts in ARM frame lowering. Should we remove it completely? Update it with the logic you're adding here?

llvm/lib/CodeGen/AggressiveAntiDepBreaker.cpp

166

Should this return an Optional (or similar)? It seems unfortunate to check MF.getFrameInfo().isCalleeSavedInfoValid() here and also check MFI.isCalleeSavedInfoValid() in the if below.

[timshen]

Don't do redundant check.

[timshen]

llvm/lib/CodeGen/AggressiveAntiDepBreaker.cpp

166

Good catch! I turned the first isCalleeSavedInfoValid into an assert, since it's guarded by the second call.

[MatzeB]

llvm/lib/CodeGen/AggressiveAntiDepBreaker.cpp

165

Please do not use auto in context where the type is not immediately obvious. (A reader has to lookup that getFrameInfo() does return a MachineFrameInfo here, it is not immediately obvious). A few more of these below.

175

I don't think this pass will (or should) be used before the prolog epilog inserter so isCalleeSavedInfoValid() should always be true and you could simply assert on it.

176

Adding isLiveIn() here looks wrong given that the code is already adding the live ins of the successors above (which is the way to compute the live-outs of this block). This should already be fine if the code is walking the block backwards afterwards.

Seeing this I would assume we walk the blocks backwards and starting with the live-outs so adding the live-ins would not make sense.

llvm/lib/CodeGen/CriticalAntiDepBreaker.cpp

83–84

see above.

[MatzeB]

llvm/lib/CodeGen/AggressiveAntiDepBreaker.cpp

167–172

This looks like you are replacing the check for pristine regs with manually written code that does the same. Am I missing something?

[timshen]

llvm/lib/CodeGen/AggressiveAntiDepBreaker.cpp

175

I didn't assert on this, only because of https://github.com/llvm-mirror/llvm/blob/6095a7948d32d712811e8c2ab2190acf8e66a8bc/lib/CodeGen/PrologEpilogInserter.cpp#L66

It appears that CSInfo is valid only if doSpillCalleeSavedRegs is executed.

Is it always the case where usesPhysRegsForPEI is necessary for post-RA scheduling?

176

Looking at https://github.com/llvm-project/llvm-project/blob/master/llvm/lib/CodeGen/PostRASchedulerList.cpp#L331

The blocks are just traversed without an explicit order.

I'll take a closer look at StartBlock. I was more or less confused by its intention.

[timshen]

llvm/lib/CodeGen/AggressiveAntiDepBreaker.cpp

167–172

This is because of Quentin's comment in the bug:

I would just resort on live ins information, if at all possible.
If not possible I would work toward making that possible :).

I did it without fully understanding the big picture. :P

It'd be good to have you or someone explain the big picture. :)

[MatzeB]

llvm/lib/CodeGen/AggressiveAntiDepBreaker.cpp

175

Ah, that is special behavior for webassembly which keeps using vregs long after register allocation is done. I don't think we should concern ourself with that here as this pass doesn't seem to be compatible with that anyway (a bunch of passes are not and webassembly just isn't using them).

[timshen]

Preserve the use of getPristineRegs() for now.

[timshen]

As discussed in the bug, I'll preserve the use of getPristineRegs() in this patch. And many of your comments don't apply anymore. :)

[qcolombet]

llvm/lib/CodeGen/AggressiveAntiDepBreaker.cpp

167–172

Yeah what I was saying is that is we can use isLiveIn alone we should do that.
If we cannot, the long run should be to get rid of the pristine stuff (i.e., just resort on isLiveIn to convey the right information).
I don't expect this patch to fix that :).

llvm/test/CodeGen/PowerPC/pr32292.ll

1 ↗

(On Diff #92510)

Using a .mir test case you should be able to reduce the test even more.

1 ↗

(On Diff #92510)

Please use a more descriptive name for the filename. List the PR in the file if you want.

[timshen]

llvm/lib/CodeGen/AggressiveAntiDepBreaker.cpp

167–172

I see.

I was clear whether I need to do anything (e.g. remove this use site) or not. :)

[timshen]

Reduce to a smaller test case.

[timshen]

Rename the test.

[timshen]

llvm/test/CodeGen/PowerPC/pr32292.ll

1 ↗

(On Diff #92510)

I didn't use .mir, but got a much smaller test case.

1 ↗

(On Diff #92510)

Renamed.

[timshen]

Ping? :)

[qcolombet]

Hi Tim,

LGTM.
Out-of-curiosity, what is missing to use a .mir test instead of the .ll test?

I expect a .mir to be more robust against changes.

Cheers,
-Quentin

[timshen]

Hi Quentin,

Oh you mean turn this IR test into a mir test? I don't know how to use mir to reduce the test for even more (I used bugpoint on IR test).

I can turn the test to a mir test.

[qcolombet]

Oh you mean turn this IR test into a mir test?

Yes.

Use -stop-before <ExeDepPassDEBUG_TYPE> to produce the .mir input.
Then, you should be able to reproduce the problem with that input and -run-pass <ExeDepPassDEBUG_TYPE>

[timshen]

Update the test to .mir.

Also fix a mir parser bug, parsing nulls as constants.

[echristo]

Committed thusly:

echristo@athyra ~/s/llvm> git svn dcommit
Committing to https://llvm.org/svn/llvm-project/llvm/trunk ...
M lib/AsmParser/LLParser.cpp
M lib/CodeGen/AggressiveAntiDepBreaker.cpp
M lib/CodeGen/CriticalAntiDepBreaker.cpp
Committed r299124

and... here:

echristo@athyra ~/s/llvm> git svn dcommit
Committing to https://llvm.org/svn/llvm-project/llvm/trunk ...
A test/CodeGen/PowerPC/pristine-and-livein.mir
Committed r299125

*sigh*

[MatzeB]

In D31188#714712, @echristo wrote:

Committed thusly:

echristo@athyra ~/s/llvm> git svn dcommit
Committing to https://llvm.org/svn/llvm-project/llvm/trunk ...
M lib/AsmParser/LLParser.cpp
M lib/CodeGen/AggressiveAntiDepBreaker.cpp
M lib/CodeGen/CriticalAntiDepBreaker.cpp
Committed r299124

and... here:

echristo@athyra ~/s/llvm> git svn dcommit
Committing to https://llvm.org/svn/llvm-project/llvm/trunk ...
A test/CodeGen/PowerPC/pristine-and-livein.mir
Committed r299125

*sigh*

FWIW: I am pretty sure "getPristineRegs is not accurately considering shrink wrapping puts registers not saved in certain blocks." as mentioned in the commit message is not true! getPristineRegs() doesn't have to do that!

I also don't understand the fix here: Adding live-in registers when the code here appears to be searching for live-out registers seem like an odd fix to me (I can see how it helps though as it will just mark more registers as occupied).

[echristo]

Totally happy to pull it back if you'd like, was just going on what Quentin said to do.

-eric

[timshen]

In D31188#718346, @MatzeB wrote:

In D31188#714712, @echristo wrote:

Committed thusly:

echristo@athyra ~/s/llvm> git svn dcommit
Committing to https://llvm.org/svn/llvm-project/llvm/trunk ...
M lib/AsmParser/LLParser.cpp
M lib/CodeGen/AggressiveAntiDepBreaker.cpp
M lib/CodeGen/CriticalAntiDepBreaker.cpp
Committed r299124

and... here:

echristo@athyra ~/s/llvm> git svn dcommit
Committing to https://llvm.org/svn/llvm-project/llvm/trunk ...
A test/CodeGen/PowerPC/pristine-and-livein.mir
Committed r299125

*sigh*

FWIW: I am pretty sure "getPristineRegs is not accurately considering shrink wrapping puts registers not saved in certain blocks." as mentioned in the commit message is not true! getPristineRegs() doesn't have to do that!

Sounds fair, I fixed the description.

I also don't understand the fix here: Adding live-in registers when the code here appears to be searching for live-out registers seem like an odd fix to me (I can see how it helps though as it will just mark more registers as occupied).

This is based on my inderstanding on "ideal liveins()" I mentioned in the bug:

/* Returns all live-ins, including the unspilled callee-saved registers. */
iterator_range<concat_iterator<...>> liveins();

The fix turns "Pristine.test(Reg)" into "Pristine.test(Reg) || BB.IsLiveIn(Reg)" as a refinement (to match the ideal definition of liveins()).

It means that not only those callee-saved registers (we are iterating over only them) who don't have spill slots are considered, but also those who “have spill slots but not spilled”.

[timshen]

In D31188#718346, @MatzeB wrote:

In D31188#714712, @echristo wrote:

Committed thusly:

echristo@athyra ~/s/llvm> git svn dcommit
Committing to https://llvm.org/svn/llvm-project/llvm/trunk ...
M lib/AsmParser/LLParser.cpp
M lib/CodeGen/AggressiveAntiDepBreaker.cpp
M lib/CodeGen/CriticalAntiDepBreaker.cpp
Committed r299124

and... here:

echristo@athyra ~/s/llvm> git svn dcommit
Committing to https://llvm.org/svn/llvm-project/llvm/trunk ...
A test/CodeGen/PowerPC/pristine-and-livein.mir
Committed r299125

*sigh*

FWIW: I am pretty sure "getPristineRegs is not accurately considering shrink wrapping puts registers not saved in certain blocks." as mentioned in the commit message is not true! getPristineRegs() doesn't have to do that!

I also don't understand the fix here: Adding live-in registers when the code here appears to be searching for live-out registers seem like an odd fix to me (I can see how it helps though as it will just mark more registers as occupied).

Also, the new behavior matches the intention in the comment:

In non-return this is any callee-saved register that is not saved in the prolog.

To be fair I don't yet understand why it thinks this is the right thing to do, but I trust that the intention is accurrate, only the code was not.

[MatzeB]

I also don't understand the fix here: Adding live-in registers when the code here appears to be searching for live-out registers seem like an odd fix to me (I can see how it helps though as it will just mark more registers as occupied).

This is based on my inderstanding on "ideal liveins()" I mentioned in the bug:

/* Returns all live-ins, including the unspilled callee-saved registers. */
iterator_range<concat_iterator<...>> liveins();

The fix turns "Pristine.test(Reg)" into "Pristine.test(Reg) || BB.IsLiveIn(Reg)" as a refinement (to match the ideal definition of liveins()).

It means that not only those callee-saved registers (we are iterating over only them) who don't have spill slots are considered, but also those who “have spill slots but not spilled”.

Pristine.test(Reg) || BB.IsLiveIn(Reg) would make a lot of sense when searching for live-ins. But the comments around it indicate it is actually searching for live-outs?

For live-outs you need to:

• Take the union of the successor live-ins + pristines
• In case of the return block without successors take all callee saved register instead

(you may referer to LivePhysRegs::addLiveOuts() / LivePHysRegs::addLiveIns() to see an alternative implementation of this).

From reading the code here the AntiDepBreaker is already doing the right thing. I only read the code though, and did not actually run/play with it so I may have missed something.

[timshen]

In D31188#718616, @MatzeB wrote:

I also don't understand the fix here: Adding live-in registers when the code here appears to be searching for live-out registers seem like an odd fix to me (I can see how it helps though as it will just mark more registers as occupied).

This is based on my inderstanding on "ideal liveins()" I mentioned in the bug:

/* Returns all live-ins, including the unspilled callee-saved registers. */
iterator_range<concat_iterator<...>> liveins();

The fix turns "Pristine.test(Reg)" into "Pristine.test(Reg) || BB.IsLiveIn(Reg)" as a refinement (to match the ideal definition of liveins()).

It means that not only those callee-saved registers (we are iterating over only them) who don't have spill slots are considered, but also those who “have spill slots but not spilled”.

Pristine.test(Reg) || BB.IsLiveIn(Reg) would make a lot of sense when searching for live-ins. But the comments around it indicate it is actually searching for live-outs?

Not for all live-outs, but only for "live-out callee-saved registers".

The code wants to do something on all non-spilled callee-saved registers that are live-outs of the current block. Without considering shrink wrapping, I picture that the correct behavior should be:

1. Epilogue blocks and returning blocks have all callee-saved registers live-out. Handle all of them.
2. Prologue blocks have all callee-saved registers that are spilled. Handle callee-saved registers that are pristine.
3. For the rest of the blocks, a callee-saved register is either not live, or live-through. Handle live-in callee-saved registers.

The behavior was matching my picture, only if all epilogue blocks are returning blocks.

After considering shrink wrapping, things change. Ideally:

1. All blocks before prologue, excluding prologue, have all callee-saved registers live-out.
2. All blocks after epilogue, including epilogue, have all callee-saved registers live-out.
3. For the rest of the blocks, a callee-saved register is either not live, or live-through; pristine registers are precisely live-out callee-saved registers.

Let's see what information we have (I haven't verified yet):

1. For all blocks before prologue, including prologue, shrink wrapping marks all callee-saved registers live-in.
2. For all blocks after epilogue, excluding epilogue, shrink wrapping marks all-callee-saved registers live-in.

I think my fix is wrong about prologues and epilogues, but correct for other blocks. I think that your suggestion is the correct fix, that is looking at the live-ins of the successors. I'll do that.

Do you think that we should keep this patch in the mean time? This patch makes some of the correct cases overly-conservative (but not wrong), and fixes some of the wrong cases. It doesn't make any correct cases wrong. Feel free to revert it if you don't think so.

I'm on vacation until April 15th, so I'll work on it after that. :)

[MatzeB]

Just found the time to look at this a bit:

The thing that is wrong here is the live-in list of bb.2. bb.2 is a return block without any restore instructions in it so it must have the %x29 as a live-in. So it seems the actual problem lies before the DepBreakers here.

I tried reproducing the earlier passes by copying the IR out of the mir test and re-running it on that, but I only always seem to get a version with a single return block without shrink wrapping...

[timshen]

In D31188#725545, @MatzeB wrote:

Just found the time to look at this a bit:

The thing that is wrong here is the live-in list of bb.2. bb.2 is a return block without any restore instructions in it so it must have the %x29 as a live-in. So it seems the actual problem lies before the DepBreakers here.

Good catch!

After some investigation, I found that line:

https://github.com/llvm-mirror/llvm/blob/8c6e6605aa4b10ac5c3e3afc4e87361c2ac1ff9d/lib/CodeGen/BranchFolding.cpp#L391

computeLiveIns() doesn't add r29 and r30 into NewMBB's liveins. I believe that computeLiveIns is doing what it's intended to do (add liveins based on instructions), so we should change the caller side to propagate CSR live-ins.

I tried reproducing the earlier passes by copying the IR out of the mir test and re-running it on that, but I only always seem to get a version with a single return block without shrink wrapping...

[timshen]

In D31188#728097, @timshen wrote:

so we should change the caller side to propagate CSR live-ins.

I'm not sure how to do this -

when splitting a block B to C and D, where C unconditionally jumps (or falls through) to D, how to compute D's liveins, including CSRs?

B could be any block -

1. before save point, CSRs live-through.
2. save point, CSRs live-in, dead-out.
3. between save point and restore point, CSRs are considered normal registers.
4. restore point, CSRs dead-in, live-out.
5. after restore point, CSRs live-through.

If the only information are the liveins(), it seems not easy to tell liveness at the split position. Do we want to use LiveIntervals in BranchFolding.cpp?

[MatzeB]

Ok, now that r303938 / https://reviews.llvm.org/D32464 has landed could you please double check and then revert this?

[MatzeB]

In D31188#765178, @MatzeB wrote:

Ok, now that r303938 / https://reviews.llvm.org/D32464 has landed could you please double check and then revert this?

You can hold off with this for now, somehow I broke some clang stage2 bots with that commit and I first have to investigate why.

[MatzeB]

In D31188#765330, @MatzeB wrote:

In D31188#765178, @MatzeB wrote:

Ok, now that r303938 / https://reviews.llvm.org/D32464 has landed could you please double check and then revert this?

You can hold off with this for now, somehow I broke some clang stage2 bots with that commit and I first have to investigate why.

I re-landed the patch with a fix and it seems to be fine now. I also filed http://llvm.org/PR33182 to document a MachineVerifier shortcoming of catching a case like this.

[timshen]

In D31188#765178, @MatzeB wrote:

Ok, now that r303938 / https://reviews.llvm.org/D32464 has landed could you please double check and then revert this?

D32464 doesn't seem to fix this test case - I ran pass post-RA-sched on this test case, and got bb.2.if.then not having X29 as live-in. Can you take a look?

[MatzeB]

In D31188#766326, @timshen wrote:

In D31188#765178, @MatzeB wrote:

Ok, now that r303938 / https://reviews.llvm.org/D32464 has landed could you please double check and then revert this?

D32464 doesn't seem to fix this test case - I ran pass post-RA-sched on this test case, and got bb.2.if.then not having X29 as live-in. Can you take a look?

The original testcase? The mir test in the repository already has the invalid livein lists from the earlier branch folding.

[timshen]

In D31188#766336, @MatzeB wrote:

In D31188#766326, @timshen wrote:

In D31188#765178, @MatzeB wrote:

Ok, now that r303938 / https://reviews.llvm.org/D32464 has landed could you please double check and then revert this?

D32464 doesn't seem to fix this test case - I ran pass post-RA-sched on this test case, and got bb.2.if.then not having X29 as live-in. Can you take a look?

The original testcase? The mir test in the repository already has the invalid livein lists from the earlier branch folding.

Yes you are right. Posted D33697 to revert.

llvm/lib/AsmParser/LLParser.cpp

bool LLParser::parseConstantValue(Type *Ty, Constant *&C) {
   case ValID::t_PackedConstantStruct: {
     Value *V;
     if (ConvertValIDToValue(Ty, ID, V, /*PFS=*/nullptr))
       return true;
     assert(isa<Constant>(V) && "Expected a constant value");
     C = cast<Constant>(V);
     return false;
   }
+  case ValID::t_Null:
+    C = Constant::getNullValue(Ty);
+    return false;
   default:
     return Error(Loc, "expected a constant value");
   }
 }
 
 bool LLParser::ParseValue(Type *Ty, Value *&V, PerFunctionState *PFS) {
   V = nullptr;
   ValID ID;

llvm/lib/CodeGen/AggressiveAntiDepBreaker.cpp

for (const auto &LI : (*SI)->liveins()) {
         DefIndices[Reg] = ~0u;
       }
     }
 
   // Mark live-out callee-saved registers. In a return block this is
   // all callee-saved registers. In non-return this is any
   // callee-saved register that is not saved in the prolog.
   const MachineFrameInfo &MFI = MF.getFrameInfo();
   BitVector Pristine = MFI.getPristineRegs(MF);
   for (const MCPhysReg *I = MF.getRegInfo().getCalleeSavedRegs(); *I;
        ++I) {
     unsigned Reg = *I;
-    if (!IsReturnBlock && !Pristine.test(Reg)) continue;
+    if (!IsReturnBlock && !(Pristine.test(Reg) || BB->isLiveIn(Reg)))
+      continue;
     for (MCRegAliasIterator AI(Reg, TRI, true); AI.isValid(); ++AI) {
       unsigned AliasReg = *AI;
       State->UnionGroups(AliasReg, 0);
       KillIndices[AliasReg] = BB->size();
       DefIndices[AliasReg] = ~0u;
     }
   }
 }
 
 void AggressiveAntiDepBreaker::FinishBlock() {
   delete State;
   State = nullptr;
 }
 

llvm/lib/CodeGen/CriticalAntiDepBreaker.cpp

void CriticalAntiDepBreaker::StartBlock(MachineBasicBlock *BB) {
 
   // Mark live-out callee-saved registers. In a return block this is
   // all callee-saved registers. In non-return this is any
   // callee-saved register that is not saved in the prolog.
   const MachineFrameInfo &MFI = MF.getFrameInfo();
   BitVector Pristine = MFI.getPristineRegs(MF);
   for (const MCPhysReg *I = MF.getRegInfo().getCalleeSavedRegs(); *I;
        ++I) {
-    if (!IsReturnBlock && !Pristine.test(*I)) continue;
+    unsigned Reg = *I;
+    if (!IsReturnBlock && !(Pristine.test(Reg) || BB->isLiveIn(Reg)))
+      continue;
     for (MCRegAliasIterator AI(*I, TRI, true); AI.isValid(); ++AI) {
       unsigned Reg = *AI;
       Classes[Reg] = reinterpret_cast<TargetRegisterClass *>(-1);
       KillIndices[Reg] = BBSize;
       DefIndices[Reg] = ~0u;
     }
   }
 }
 
 void CriticalAntiDepBreaker::FinishBlock() {
   RegRefs.clear();
   KeepRegs.reset();
 }
 

llvm/test/CodeGen/PowerPC/pristine-and-livein.mir

+# RUN: llc -run-pass=post-RA-sched %s -o - | FileCheck %s
+
+# CHECK: callee-saved-register: '[[REG:%x[0-9]+]]'
+# CHECK: callee-saved-register: '{{%x[0-9]+}}'
+# CHECK-NOT: [[REG]] = LI8 0
+# CHECK: STD killed [[REG]],
+--- |
+  ; ModuleID = '<stdin>'
+  source_filename = "bugpoint-output-4d91ae2.bc"
+  target datalayout = "e-m:e-i64:64-n32:64"
+  target triple = "powerpc64le--linux-gnu"
+  
+  ; Function Attrs: norecurse nounwind readonly
+  define i64 @adler32_z(i64 %adler, i8* readonly %buf, i64 %len) local_unnamed_addr #0 {
+  entry:
+    %shr = lshr i64 %adler, 16
+    %and = and i64 %shr, 65535
+    %and1 = and i64 %adler, 65535
+    br i1 undef, label %if.then, label %if.end15
+  
+  if.then:                                          ; preds = %entry
+    %add5 = add nsw i64 %and1, %and
+    %sub9 = add nsw i64 %add5, 281474976645135
+    %shl = shl i64 %add5, 16
+    %or = or i64 %shl, %and1
+    br label %cleanup
+  
+  if.end15:                                         ; preds = %entry
+    br i1 undef, label %while.cond.preheader, label %while.cond30.preheader
+  
+  while.cond30.preheader:                           ; preds = %if.end15
+    br i1 undef, label %while.body33.preheader, label %while.body109.preheader
+  
+  while.body33.preheader:                           ; preds = %while.cond30.preheader
+    br label %while.body33
+  
+  while.cond.preheader:                             ; preds = %if.end15
+    %sub25 = add i64 %and1, -65521
+    %rem = urem i64 %and, 65521
+    %shl27 = shl nuw nsw i64 %rem, 16
+    %or28 = or i64 %shl27, %and1
+    br label %cleanup
+  
+  while.body33:                                     ; preds = %do.end, %while.body33.preheader
+    %indvar = phi i64 [ %indvar.next, %do.end ], [ 0, %while.body33.preheader ]
+    %sum2.2385 = phi i64 [ %rem102, %do.end ], [ %and, %while.body33.preheader ]
+    %len.addr.1384 = phi i64 [ %sub34, %do.end ], [ %len, %while.body33.preheader ]
+    %buf.addr.1383 = phi i8* [ %scevgep390, %do.end ], [ %buf, %while.body33.preheader ]
+    %adler.addr.3382 = phi i64 [ %rem101, %do.end ], [ %and1, %while.body33.preheader ]
+    %0 = mul i64 %indvar, 5552
+    %1 = add i64 %0, -13
+    %scevgep2 = getelementptr i8, i8* %buf, i64 %1
+    %sub34 = add i64 %len.addr.1384, -5552
+    call void @llvm.ppc.mtctr.i64(i64 347)
+    br label %do.body
+  
+  do.body:                                          ; preds = %do.body, %while.body33
+    %adler.addr.4 = phi i64 [ %adler.addr.3382, %while.body33 ], [ %add49, %do.body ]
+    %sum2.3 = phi i64 [ %sum2.2385, %while.body33 ], [ %add98, %do.body ]
+    %tmp15.phi = phi i8* [ %scevgep2, %while.body33 ], [ %tmp15.inc, %do.body ]
+    %tmp15.inc = getelementptr i8, i8* %tmp15.phi, i64 16
+    %add38 = add i64 %adler.addr.4, %sum2.3
+    %add42 = add i64 %add38, %adler.addr.4
+    %add46 = add i64 %add42, %adler.addr.4
+    %tmp15 = load i8, i8* %tmp15.inc, align 1, !tbaa !1
+    %conv48 = zext i8 %tmp15 to i64
+    %add49 = add i64 %adler.addr.4, %conv48
+    %add50 = add i64 %add46, %add49
+    %add54 = add i64 %add50, %add49
+    %add58 = add i64 %add54, %add49
+    %add62 = add i64 %add58, %add49
+    %add66 = add i64 %add62, %add49
+    %add70 = add i64 %add66, %add49
+    %add74 = add i64 %add70, %add49
+    %add78 = add i64 %add74, %add49
+    %add82 = add i64 %add78, %add49
+    %add86 = add i64 %add82, %add49
+    %add90 = add i64 %add86, %add49
+    %add94 = add i64 %add90, %add49
+    %add98 = add i64 %add94, %add49
+    %2 = call i1 @llvm.ppc.is.decremented.ctr.nonzero()
+    br i1 %2, label %do.body, label %do.end
+  
+  do.end:                                           ; preds = %do.body
+    %scevgep390 = getelementptr i8, i8* %buf.addr.1383, i64 5552
+    %rem101 = urem i64 %add49, 65521
+    %rem102 = urem i64 %add98, 65521
+    %cmp31 = icmp ugt i64 %sub34, 5551
+    %indvar.next = add i64 %indvar, 1
+    br i1 %cmp31, label %while.body33, label %while.end103
+  
+  while.end103:                                     ; preds = %do.end
+    br i1 undef, label %if.end188, label %while.body109.preheader
+  
+  while.body109.preheader:                          ; preds = %while.end103, %while.cond30.preheader
+    %buf.addr.1.lcssa394400 = phi i8* [ %buf, %while.cond30.preheader ], [ %scevgep390, %while.end103 ]
+    %arrayidx151 = getelementptr inbounds i8, i8* %buf.addr.1.lcssa394400, i64 10
+    %tmp45 = load i8, i8* %arrayidx151, align 1, !tbaa !1
+    %conv152 = zext i8 %tmp45 to i64
+    br label %while.body109
+  
+  while.body109:                                    ; preds = %while.body109, %while.body109.preheader
+    %adler.addr.5373 = phi i64 [ %add153, %while.body109 ], [ undef, %while.body109.preheader ]
+    %add153 = add i64 %adler.addr.5373, %conv152
+    br label %while.body109
+  
+  if.end188:                                        ; preds = %while.end103
+    %shl189 = shl nuw nsw i64 %rem102, 16
+    %or190 = or i64 %shl189, %rem101
+    br label %cleanup
+  
+  cleanup:                                          ; preds = %if.end188, %while.cond.preheader, %if.then
+    %retval.0 = phi i64 [ %or, %if.then ], [ %or28, %while.cond.preheader ], [ %or190, %if.end188 ]
+    ret i64 %retval.0
+  }
+  
+  ; Function Attrs: nounwind
+  declare void @llvm.ppc.mtctr.i64(i64) #1
+  
+  ; Function Attrs: nounwind
+  declare i1 @llvm.ppc.is.decremented.ctr.nonzero() #1
+  
+  ; Function Attrs: nounwind
+  declare void @llvm.stackprotector(i8*, i8**) #1
+  
+  attributes #0 = { norecurse nounwind readonly "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="ppc64le" "target-features"="+altivec,+bpermd,+crypto,+direct-move,+extdiv,+power8-vector,+vsx,-power9-vector,-qpx" "unsafe-fp-math"="false" "use-soft-float"="false" }
+  attributes #1 = { nounwind }
+  
+  !llvm.ident = !{!0}
+  
+  !0 = !{!"clang version 5.0.0 "}
+  !1 = !{!2, !2, i64 0}
+  !2 = !{!"omnipotent char", !3, i64 0}
+  !3 = !{!"Simple C/C++ TBAA"}
+
+...
+---
+name:            adler32_z
+alignment:       4
+exposesReturnsTwice: false
+legalized:       false
+regBankSelected: false
+selected:        false
+tracksRegLiveness: true
+liveins:         
+  - { reg: '%x3' }
+  - { reg: '%x4' }
+  - { reg: '%x5' }
+frameInfo:       
+  isFrameAddressTaken: false
+  isReturnAddressTaken: false
+  hasStackMap:     false
+  hasPatchPoint:   false
+  stackSize:       0
+  offsetAdjustment: 0
+  maxAlignment:    0
+  adjustsStack:    false
+  hasCalls:        false
+  maxCallFrameSize: 0
+  hasOpaqueSPAdjustment: false
+  hasVAStart:      false
+  hasMustTailInVarArgFunc: false
+fixedStack:      
+  - { id: 0, type: spill-slot, offset: -16, size: 8, alignment: 16, callee-saved-register: '%x30' }
+  - { id: 1, type: spill-slot, offset: -24, size: 8, alignment: 8, callee-saved-register: '%x29' }
+  - { id: 2, offset: -8, size: 8, alignment: 8, isImmutable: true, isAliased: false }
+body:             |
+  bb.0.entry:
+    successors: %bb.1.if.then(0x40000000), %bb.3.if.end15(0x40000000)
+    liveins: %x3, %x4, %x5, %x29, %x30
+  
+    %x6 = RLWINM8 %x3, 16, 16, 31
+    %x3 = RLDICL killed %x3, 0, 48
+    BC undef %cr5lt, %bb.3.if.end15
+  
+  bb.1.if.then:
+    successors: %bb.2.if.then(0x80000000)
+    liveins: %x3, %x6, %x29, %x30
+  
+    %x4 = ADD8 %x3, killed %x6
+  
+  bb.2.if.then:
+    liveins: %lr8, %rm, %x3, %x4
+  
+    %x4 = RLDICR killed %x4, 16, 47
+    %x3 = OR8 killed %x4, killed %x3
+    BLR8 implicit %lr8, implicit %rm, implicit %x3
+  
+  bb.3.if.end15:
+    successors: %bb.6.while.cond.preheader(0x40000000), %bb.4.while.cond30.preheader(0x40000000)
+    liveins: %x3, %x4, %x5, %x6, %x29, %x30
+  
+    BC undef %cr5lt, %bb.6.while.cond.preheader
+  
+  bb.4.while.cond30.preheader:
+    successors: %bb.7.while.body33.preheader(0x40000000), %bb.5(0x40000000)
+    liveins: %x3, %x4, %x5, %x6, %x29, %x30
+  
+    BCn undef %cr5lt, %bb.7.while.body33.preheader
+  
+  bb.5:
+    successors: %bb.12.while.body109.preheader(0x80000000)
+    liveins: %x4, %x29, %x30
+  
+    %x7 = OR8 %x4, killed %x4
+    B %bb.12.while.body109.preheader
+  
+  bb.6.while.cond.preheader:
+    successors: %bb.2.if.then(0x80000000)
+    liveins: %x3, %x6, %x29, %x30
+  
+    %x4 = LIS8 15
+    %x4 = ORI8 killed %x4, 225
+    %x4 = RLDICR killed %x4, 32, 31
+    %x4 = ORIS8 killed %x4, 3375
+    %x4 = ORI8 killed %x4, 50637
+    %x4 = MULHDU %x6, killed %x4
+    %x5 = SUBF8 %x4, %x6
+    %x5 = RLDICL killed %x5, 63, 1
+    %x4 = ADD8 killed %x5, killed %x4
+    %x5 = LI8 0
+    %x4 = RLDICL killed %x4, 49, 15
+    %x5 = ORI8 killed %x5, 65521
+    %x4 = MULLD killed %x4, killed %x5
+    %x4 = SUBF8 killed %x4, killed %x6
+    B %bb.2.if.then
+  
+  bb.7.while.body33.preheader:
+    successors: %bb.8.while.body33(0x80000000)
+    liveins: %x3, %x4, %x5, %x6, %x29, %x30
+  
+    STD killed %x29, -24, %x1 :: (store 8 into %fixed-stack.1)
+    STD killed %x30, -16, %x1 :: (store 8 into %fixed-stack.0, align 16)
+    %x7 = LIS8 15
+    %x7 = ORI8 killed %x7, 225
+    %x7 = RLDICR killed %x7, 32, 31
+    %x8 = LI8 0
+    %x7 = ORIS8 killed %x7, 3375
+    %x9 = LI8 347
+    %x10 = ORI8 killed %x7, 50637
+    %x11 = ORI8 %x8, 65521
+    %x7 = OR8 %x4, %x4
+  
+  bb.8.while.body33:
+    successors: %bb.9.do.body(0x80000000)
+    liveins: %x3, %x4, %x5, %x6, %x7, %x8, %x9, %x10, %x11
+  
+    %x12 = MULLI8 %x8, 5552
+    %x12 = ADD8 %x4, killed %x12
+    %x12 = ADDI8 killed %x12, -13
+    %x5 = ADDI8 killed %x5, -5552
+    MTCTR8loop %x9, implicit-def dead %ctr8
+  
+  bb.9.do.body:
+    successors: %bb.9.do.body(0x7c000000), %bb.10.do.end(0x04000000)
+    liveins: %x3, %x4, %x5, %x6, %x7, %x8, %x9, %x10, %x11, %x12
+  
+    %x0, %x12 = LBZU8 16, killed %x12 :: (load 1 from %ir.tmp15.inc, !tbaa !1)
+    %x6 = ADD8 %x3, killed %x6
+    %x6 = ADD8 killed %x6, %x3
+    %x6 = ADD8 killed %x6, %x3
+    %x3 = ADD8 killed %x3, killed %x0
+    %x6 = ADD8 killed %x6, %x3
+    %x6 = ADD8 killed %x6, %x3
+    %x6 = ADD8 killed %x6, %x3
+    %x6 = ADD8 killed %x6, %x3
+    %x6 = ADD8 killed %x6, %x3
+    %x6 = ADD8 killed %x6, %x3
+    %x6 = ADD8 killed %x6, %x3
+    %x6 = ADD8 killed %x6, %x3
+    %x6 = ADD8 killed %x6, %x3
+    %x6 = ADD8 killed %x6, %x3
+    %x6 = ADD8 killed %x6, %x3
+    %x6 = ADD8 killed %x6, %x3
+    %x6 = ADD8 killed %x6, %x3
+    BDNZ8 %bb.9.do.body, implicit-def %ctr8, implicit %ctr8
+  
+  bb.10.do.end:
+    successors: %bb.8.while.body33(0x7c000000), %bb.11.while.end103(0x04000000)
+    liveins: %x3, %x4, %x5, %x6, %x7, %x8, %x9, %x10, %x11
+  
+    %x12 = MULHDU %x3, %x10
+    %x0 = MULHDU %x6, %x10
+    %x30 = SUBF8 %x12, %x3
+    %x29 = SUBF8 %x0, %x6
+    %x30 = RLDICL killed %x30, 63, 1
+    %x29 = RLDICL killed %x29, 63, 1
+    %x12 = ADD8 killed %x30, killed %x12
+    %x0 = ADD8 killed %x29, killed %x0
+    %cr0 = CMPLDI %x5, 5551
+    %x12 = RLDICL killed %x12, 49, 15
+    %x0 = RLDICL killed %x0, 49, 15
+    %x12 = MULLD killed %x12, %x11
+    %x0 = MULLD killed %x0, %x11
+    %x7 = ADDI8 killed %x7, 5552
+    %x3 = SUBF8 killed %x12, killed %x3
+    %x6 = SUBF8 killed %x0, killed %x6
+    %x8 = ADDI8 killed %x8, 1
+    BCC 44, killed %cr0, %bb.8.while.body33
+  
+  bb.11.while.end103:
+    successors: %bb.14.if.end188(0x40000000), %bb.12.while.body109.preheader(0x40000000)
+    liveins: %x3, %x6, %x7
+  
+    %x30 = LD -16, %x1 :: (load 8 from %fixed-stack.0, align 16)
+    %x29 = LD -24, %x1 :: (load 8 from %fixed-stack.1)
+    BC undef %cr5lt, %bb.14.if.end188
+  
+  bb.12.while.body109.preheader:
+    successors: %bb.13.while.body109(0x80000000)
+    liveins: %x7, %x29, %x30
+  
+    %x3 = LBZ8 10, killed %x7 :: (load 1 from %ir.arrayidx151, !tbaa !1)
+    %x4 = IMPLICIT_DEF
+  
+  bb.13.while.body109:
+    successors: %bb.13.while.body109(0x80000000)
+    liveins: %x3, %x4, %x29, %x30
+  
+    %x4 = ADD8 killed %x4, %x3
+    B %bb.13.while.body109
+  
+  bb.14.if.end188:
+    liveins: %x3, %x6, %x29, %x30
+  
+    %x4 = RLDICR killed %x6, 16, 47
+    %x3 = OR8 killed %x4, killed %x3
+    BLR8 implicit %lr8, implicit %rm, implicit %x3
+
+...