[MIR][ARM] MachineOperand comments to print condition code names instead of constants

[SjoerdMeijer]

Summary

Some machine operands have their values encoded as immediates and are thus printed as immediates, for example:

dead renamable $r2, $cpsr = tEOR killed renamable $r2, renamable $r1, 14, $noreg
t2Bcc %bb.4, 0, killed $cpsr

In this example, 14 is a condition code that means that the EOR instruction is not conditionally executed (it is "always executed"). The 0 on the next conditional branch instruction represents the equal condition code. The problem is that these constants make the MIR difficult to read (for a human), so here we propose to annotate MachineOperands with an annotation/comment:

dead renamable $r2, $cpsr = tEOR killed renamable $r2, renamable $r1, 14 [always], $noreg
t2Bcc %bb.4, 0 [equal], killed $cpsr

As it is a comment, the MI lexer/parser completely ignores it. The benefit is that this keeps the change in the lexer extremely minimal and no target specific parsing needs to be done. The changes on the MIPrinter side are also minimal, as targets hooks are used to create the machine operand comments.

[efriedma]

I think something like this is nice to have: various instructions use immediates with weird encodings that make perfect sense in the code, but are sort of hard to read.

I don't really like the way this is implemented; it's adding a bunch of target-specific logic to target-independent code.

I wonder if, instead of replacing the immediate with a keyword, it would make sense to add some generic mechanism to print a comments after an operand, to sort of explain it. We could print the condition for a condition code, but we could also decode various other kinds of encoded immediates: for example, "26" is "lsl #3" in ADDrsi. Printing it as a comment would be simpler to implement because the parsing change would be much smaller: we continue just parsing an integer, and ignore the comment, instead of adding target-specific parsing rules.

[SjoerdMeijer]

In D74306#1867215, @efriedma wrote:

I think something like this is nice to have: various instructions use immediates with weird encodings that make perfect sense in the code, but are sort of hard to read.

Thanks for taking a look!

I don't really like the way this is implemented; it's adding a bunch of target-specific logic to target-independent code.

I could have tried harder to hide target specific logic in targets hooks in MIParse. In the MIRPrinter for example, I added a call to TII->getPredicateByName(). In the parser, for this WIP demo, I was lazy and just added getPredicateCondCode(), but could have done something similar. But I do fully agree of course that one way or another, that means more target specific parsing.

I wonder if, instead of replacing the immediate with a keyword, it would make sense to add some generic mechanism to print a comments after an operand, to sort of explain it. We could print the condition for a condition code, but we could also decode various other kinds of encoded immediates: for example, "26" is "lsl #3" in ADDrsi. Printing it as a comment would be simpler to implement because the parsing change would be much smaller: we continue just parsing an integer, and ignore the comment, instead of adding target-specific parsing rules.

Nice one, cheers, I do really like that idea! The only disadvantage I see is that one can argue that MIR output is possibly more verbose than needed, but all together this sounds like an excellent trade-off to me. I will give this a try and make a start with implementing this soon.

[SjoerdMeijer]

How about something like this?

[efriedma]

This is roughly what I was expecting; I think this is the right approach.

Maybe getImmOperandComment should be a target-specific method, instead of putting the predicate handling logic in target-independent code? We probably want some general-purpose hook for adding comments anyway.

[SjoerdMeijer]

Created createMIROperandComment() as general-purpose hook to create comments.

I've now updated all the tests, and so thought it was time to remove the WIP tag from the subject.

[ostannard]

llvm/include/llvm/CodeGen/TargetInstrInfo.h

1310

Is this still needed in the common TargetInstrInfo?

1313

Returning a const char * is going to make it hard for targets to dynamically construct comments, e.g. Eli's example of "26" -> "lsl #3" in ADDrsi. The MIR printer is only used for debugging, so using a std::string here should be fine.

llvm/lib/CodeGen/MIRParser/MILexer.cpp

107

Is this syntax used for comments anywhere else? It's not immediately obvious from reading the changed tests that this is a comment, could we use something more common like /* C-stlye */ comments?

llvm/lib/Target/ARM/ARMBaseInstrInfo.cpp

500

I think it would be better to use the two-letter codes from the assembly syntax. They are more canonical, and easier to look up the exact meaning than these.

531

getPredicateByName can never return a null pointer.

[SjoerdMeijer]

Hi Oliver, thanks for looking too and the feedback!

Is this still needed in the common TargetInstrInfo?

Nope, good one, I have removed it. Now we only have createMIROperandComment() as a new target hook.

Returning a const char * is going to make it hard for targets

yep, done, that's a lot more convenient.

I think it would be better to use the two-letter codes from the assembly syntax. They are more canonical, and easier to look up the exact meaning than these.

Done, and related to this, I have completely removed getPredicateByName(), instead I can just call existing function ARMCondCodeToString().

Is this syntax used for comments anywhere else? It's not immediately obvious from reading the changed tests that this is a comment, could we use something more common like /* C-stlye */ comments?

I have no strong opinion on this. I chose [ and ] mainly for these 2 reasons:

• it's a character currently not used by the lexer,
• it is 1 character, which I found nice and concise and pleasant to read. I think I find it more pleasant to read than /* and */ in MIR code, but I appreciate this is very subjective, see next paragraph.

I have only added 1 changed test case, because the ~140 I had to change make things difficult to read here. I will make the final change changing all tests when we are happy about the exact syntax:

• I have adopted the 2-letter codes syntax. To make this readable, I have prefixed this with CC:: to indicate this is a condition code, so that for example you'll see [CC::al].
• As I said above, I have kept the [ and ] for now to open/close comments, but would be happy to change. If @efriedma has a preference, then I will take that into account, make the change, and then update all the tests.

About updating the tests, that's actually pretty straightforward because for about ~120 I can just use the script (just letting know that's how I changed them). For about 20 of them, that doesn't really work because of shared check-prefixes, so I need to change them "manually" with a little bit search/replace commands, but is not a big deal.

[SjoerdMeijer]

the same patch, but now with context.

[efriedma]

I can see two problems with [] comment delimiters:

1. ] is used somewhat frequently in target-specific assembly syntax, so it might end up overlapping with stuff some target wants to print. Maybe not that likely in practice.
2. It isn't obvious that the contents of the [] is a comment. Something like /**/ would give instant recognition to people even if they're not really familiar with MIR syntax.

Otherwise looks fine.

[SjoerdMeijer]

Thanks again for the suggestions/comments. The MachineOperand comments are now enclosed between /* and */, see the only test file that I have uploaded.

As a last step, I can now change all tests. I can upload them here, or commit directly when you're happy with this patch. The only reason I have not uploaded the ~140 changed tests, is because that makes this Phab diff a bit unwieldy.

[ostannard]

LGTM with one really minor nit.

llvm/lib/Target/ARM/ARMBaseInstrInfo.cpp

501

Comments should end with full stops.

llvm/include/llvm/CodeGen/TargetInstrInfo.h

public:
   virtual void getNoop(MCInst &NopInst) const;
 
   /// Return true for post-incremented instructions.
   virtual bool isPostIncrement(const MachineInstr &MI) const { return false; }
 
   /// Returns true if the instruction is already predicated.
   virtual bool isPredicated(const MachineInstr &MI) const { return false; }
 
+  /// Returns the name for the specified condition code
+  virtual const char *getPredicateByName(int CC) const {return nullptr; };
+
   /// Returns true if the instruction is a
   /// terminator instruction that has not been predicated.
   virtual bool isUnpredicatedTerminator(const MachineInstr &MI) const;
 
   /// Returns true if MI is an unconditional tail call.
   virtual bool isUnconditionalTailCall(const MachineInstr &MI) const {
     return false;
   }
 
   /// Returns true if the tail call can be made conditional on BranchCond.

llvm/lib/CodeGen/MIRParser/MILexer.h

enum TokenKind {
     lbrace,
     rbrace,
     plus,
     minus,
     less,
     greater,
 
     // Keywords
+    kw_cond_code,
     kw_implicit,
     kw_implicit_define,
     kw_def,
     kw_dead,
     kw_dereferenceable,
     kw_killed,
     kw_undef,
     kw_internal,

llvm/lib/CodeGen/MIRParser/MILexer.cpp

 static Cursor skipComment(Cursor C) {
   if (C.peek() != ';')
     return C;
   while (!isNewlineChar(C.peek()) && !C.isEOF())
     C.advance();
   return C;
 }
 
 /// Return true if the given character satisfies the following regular
 /// expression: [-a-zA-Z$._0-9]
 static bool isIdentifierChar(char C) {
   return isalpha(C) || isdigit(C) || C == '_' || C == '-' || C == '.' ||
          C == '$';
 }
 
 /// Unescapes the given string value.
 ///
static Cursor lexName(Cursor C, MIToken &Token, MIToken::TokenKind Type,
   Token.reset(Type, Range.upto(C))
       .setStringValue(Range.upto(C).drop_front(PrefixLength));
   return C;
 }
 
 static MIToken::TokenKind getIdentifierKind(StringRef Identifier) {
   return StringSwitch<MIToken::TokenKind>(Identifier)
       .Case("_", MIToken::underscore)
+      .Case("cond", MIToken::kw_cond_code)
       .Case("implicit", MIToken::kw_implicit)
       .Case("implicit-def", MIToken::kw_implicit_define)
       .Case("def", MIToken::kw_def)
       .Case("dead", MIToken::kw_dead)
       .Case("killed", MIToken::kw_killed)
       .Case("undef", MIToken::kw_undef)
       .Case("internal", MIToken::kw_internal)
       .Case("early-clobber", MIToken::kw_early_clobber)

llvm/lib/CodeGen/MIRParser/MIParser.cpp

public:
   bool parseRegisterOperand(MachineOperand &Dest,
                             Optional<unsigned> &TiedDefIdx, bool IsDef = false);
   bool parseImmediateOperand(MachineOperand &Dest);
   bool parseIRConstant(StringRef::iterator Loc, StringRef StringValue,
                        const Constant *&C);
   bool parseIRConstant(StringRef::iterator Loc, const Constant *&C);
   bool parseLowLevelType(StringRef::iterator Loc, LLT &Ty);
   bool parseTypedImmediateOperand(MachineOperand &Dest);
+  bool parseConditionCodeOperand(MachineOperand &Dest, const unsigned OpIdx);
   bool parseFPImmediateOperand(MachineOperand &Dest);
   bool parseMBBReference(MachineBasicBlock *&MBB);
   bool parseMBBOperand(MachineOperand &Dest);
   bool parseStackFrameIndex(int &FI);
   bool parseStackObjectOperand(MachineOperand &Dest);
   bool parseFixedStackFrameIndex(int &FI);
   bool parseFixedStackObjectOperand(MachineOperand &Dest);
   bool parseGlobalValue(GlobalValue *&GV);
bool MIParser::parseLowLevelType(StringRef::iterator Loc, LLT &Ty) {
   if (Token.isNot(MIToken::greater))
     return error(Loc, "expected <M x sN> or <M x pA> for vector type");
   lex();
 
   Ty = LLT::vector(NumElements, Ty);
   return false;
 }
 
+unsigned getPredicateCondCode(StringRef Pred) {
+  return StringSwitch<unsigned>(Pred)
+    .Case("equal",        0)
+    .Case("notequal",     1)
+    .Case("highersame",   2)
+    .Case("lower",        3)
+    .Case("minus",        4)
+    .Case("plus",         5)
+    .Case("overflow",     6)
+    .Case("nooverflow",   7)
+    .Case("higher",       8)
+    .Case("lowersame",    9)
+    .Case("greaterequal", 10)
+    .Case("less",         11)
+    .Case("greater",      12)
+    .Case("lessequal",    13)
+    .Case("always",       14)
+    .Default(~0);
+}
+
+bool MIParser::parseConditionCodeOperand(MachineOperand &Dest, const unsigned OpIdx) {
+  if (Token.range() != "cond")
+    return true;
+
+  lex();
+  if (expectAndConsume(MIToken::colon))
+    return error("expected ':'");
+
+  int CC = getPredicateCondCode(Token.range());
+  if (CC == ~0)
+    return error("unknown condition code");
+
+  lex();
+  Dest = MachineOperand::CreateImm(CC);
+  return false;
+}
+
 bool MIParser::parseTypedImmediateOperand(MachineOperand &Dest) {
   assert(Token.is(MIToken::Identifier));
   StringRef TypeStr = Token.range();
   if (TypeStr.front() != 'i' && TypeStr.front() != 's' &&
       TypeStr.front() != 'p')
     return error(
         "a typed immediate operand should start with one of 'i', 's', or 'p'");
   StringRef SizeStr = Token.range().drop_front();
bool MIParser::parseLiveoutRegisterMaskOperand(MachineOperand &Dest) {
   Dest = MachineOperand::CreateRegLiveOut(Mask);
   return false;
 }
 
 bool MIParser::parseMachineOperand(const unsigned OpCode, const unsigned OpIdx,
                                    MachineOperand &Dest,
                                    Optional<unsigned> &TiedDefIdx) {
   switch (Token.kind()) {
+  case MIToken::kw_cond_code:
+    return parseConditionCodeOperand(Dest, OpIdx);
   case MIToken::kw_implicit:
   case MIToken::kw_implicit_define:
   case MIToken::kw_def:
   case MIToken::kw_dead:
   case MIToken::kw_killed:
   case MIToken::kw_undef:
   case MIToken::kw_internal:
   case MIToken::kw_early_clobber:

llvm/lib/CodeGen/MIRPrinter.cpp

 }
 
 void MIPrinter::print(const MachineInstr &MI, unsigned OpIdx,
                       const TargetRegisterInfo *TRI,
                       bool ShouldPrintRegisterTies, LLT TypeToPrint,
                       bool PrintDef) {
   const MachineOperand &Op = MI.getOperand(OpIdx);
   switch (Op.getType()) {
-  case MachineOperand::MO_Immediate:
+  case MachineOperand::MO_Immediate: {
+    int FirstPredOp = MI.findFirstPredOperandIdx();
+    if (FirstPredOp == (int)OpIdx) {
+      const auto *MF = MI.getMF();
+      const auto &SubTarget = MF->getSubtarget();
+      const auto *TRI = SubTarget.getRegisterInfo();
+      assert(TRI && "Expected target register info");
+      const auto *TII = SubTarget.getInstrInfo();
+      if (const char *PredName = TII->getPredicateByName(Op.getImm())) {
+        OS << "cond:" << PredName;
+        return;
+      }
+    }
     if (MI.isOperandSubregIdx(OpIdx)) {
       MachineOperand::printTargetFlags(OS, Op);
       MachineOperand::printSubRegIdx(OS, Op.getImm(), TRI);
       break;
     }
     LLVM_FALLTHROUGH;
+  }
   case MachineOperand::MO_Register:
   case MachineOperand::MO_CImmediate:
   case MachineOperand::MO_FPImmediate:
   case MachineOperand::MO_MachineBasicBlock:
   case MachineOperand::MO_ConstantPoolIndex:
   case MachineOperand::MO_TargetIndex:
   case MachineOperand::MO_JumpTableIndex:
   case MachineOperand::MO_ExternalSymbol:

llvm/lib/Target/ARM/ARMBaseInstrInfo.h

unsigned insertBranch(MachineBasicBlock &MBB, MachineBasicBlock *TBB,
                         int *BytesAdded = nullptr) const override;
 
   bool
   reverseBranchCondition(SmallVectorImpl<MachineOperand> &Cond) const override;
 
   // Predication support.
   bool isPredicated(const MachineInstr &MI) const override;
 
+  const char *getPredicateByName(int CC) const override;
+
   ARMCC::CondCodes getPredicate(const MachineInstr &MI) const {
     int PIdx = MI.findFirstPredOperandIdx();
     return PIdx != -1 ? (ARMCC::CondCodes)MI.getOperand(PIdx).getImm()
                       : ARMCC::AL;
   }
 
   bool PredicateInstruction(MachineInstr &MI,
                             ArrayRef<MachineOperand> Pred) const override;

llvm/lib/Target/ARM/ARMBaseInstrInfo.cpp

if (MI.isBundle()) {
     }
     return false;
   }
 
   int PIdx = MI.findFirstPredOperandIdx();
   return PIdx != -1 && MI.getOperand(PIdx).getImm() != ARMCC::AL;
 }
 
+const char *ARMBaseInstrInfo::getPredicateByName(int CC) const {
+  switch (CC) {
+  case 0:   return "equal";
+  case 1:   return "notequal";
+  case 2:   return "highersame";
+  case 3:   return "lower";
+  case 4:   return "minus";
+  case 5:   return "plus";
+  case 6:   return "overflow";
+  case 7:   return "nooverflow";
+  case 8:   return "higher";
+  case 9:   return "lowersame";
+  case 10:  return "greaterequal";
+  case 11:  return "less";
+  case 12:  return "greater";
+  case 13:  return "lessequal";
+  case 14:  return "always";
+  default:
+    llvm_unreachable("unexpected condition code");
+  }
+}
+
 bool ARMBaseInstrInfo::PredicateInstruction(
     MachineInstr &MI, ArrayRef<MachineOperand> Pred) const {
   unsigned Opc = MI.getOpcode();
   if (isUncondBranchOpcode(Opc)) {
     MI.setDesc(get(getMatchingCondBranchOpcode(Opc)));
     MachineInstrBuilder(*MI.getParent()->getParent(), MI)
       .addImm(Pred[0].getImm())
       .addReg(Pred[1].getReg());
     return true;
   }
 
   int PIdx = MI.findFirstPredOperandIdx();
   if (PIdx != -1) {
     MachineOperand &PMO = MI.getOperand(PIdx);
     PMO.setImm(Pred[0].getImm());
     MI.getOperand(PIdx+1).setReg(Pred[1].getReg());
     return true;
   }
   return false;
 }

llvm/test/CodeGen/Thumb2/t2-teq-reduce.mir

 liveins:
   - { reg: '$r0', virtual-reg: '' }
   - { reg: '$r1', virtual-reg: '' }
 body:             |
   ; CHECK-LABEL: name: reg_reg_it_block
   ; CHECK: bb.0.entry:
   ; CHECK:   successors: %bb.2(0x80000000)
   ; CHECK:   liveins: $r0, $r1
-  ; CHECK:   t2B %bb.2, 14, $noreg
+  ; CHECK:   t2B %bb.2, cond:always, $noreg
   ; CHECK: bb.1.while.body.end:
   ; CHECK:   successors: %bb.2(0x80000000)
   ; CHECK:   liveins: $r0, $r1
-  ; CHECK:   renamable $r0 = tLDRi killed renamable $r0, 0, 14, $noreg :: (load 4 from %ir.next.i.14)
-  ; CHECK:   tCMPi8 renamable $r0, 0, 14, $noreg, implicit-def $cpsr
+  ; CHECK:   renamable $r0 = tLDRi killed renamable $r0, 0, cond:always, $noreg :: (load 4 from %ir.next.i.14)
+  ; CHECK:   tCMPi8 renamable $r0, 0, cond:always, $noreg, implicit-def $cpsr
   ; CHECK:   BUNDLE implicit-def dead $itstate, implicit killed $cpsr, implicit $r0 {
   ; CHECK:     t2IT 0, 8, implicit-def $itstate
-  ; CHECK:     tBX_RET 0, killed $cpsr, implicit $r0, implicit internal killed $itstate
+  ; CHECK:     tBX_RET cond:equal, killed $cpsr, implicit $r0, implicit internal killed $itstate
   ; CHECK:   }
   ; CHECK: bb.2.while.begin:
   ; CHECK:   successors: %bb.4(0x04000000), %bb.3(0x7c000000)
   ; CHECK:   liveins: $r0, $r1
-  ; CHECK:   renamable $r2 = tLDRi renamable $r0, 1, 14, $noreg :: (load 4 from %ir.info.i)
-  ; CHECK:   renamable $r2 = tLDRHi killed renamable $r2, 0, 14, $noreg :: (load 2 from %ir.data16.i1)
-  ; CHECK:   dead renamable $r2, $cpsr = tEOR killed renamable $r2, renamable $r1, 14, $noreg
-  ; CHECK:   t2Bcc %bb.4, 0, killed $cpsr
+  ; CHECK:   renamable $r2 = tLDRi renamable $r0, 1, cond:always, $noreg :: (load 4 from %ir.info.i)
+  ; CHECK:   renamable $r2 = tLDRHi killed renamable $r2, 0, cond:always, $noreg :: (load 2 from %ir.data16.i1)
+  ; CHECK:   dead renamable $r2, $cpsr = tEOR killed renamable $r2, renamable $r1, cond:always, $noreg
+  ; CHECK:   t2Bcc %bb.4, cond:equal, killed $cpsr
   ; CHECK: bb.3.while.body.a:
   ; CHECK:   successors: %bb.4(0x4207fef8), %bb.1(0x3df80108)
   ; CHECK:   liveins: $r0, $r1
-  ; CHECK:   renamable $r0 = tLDRi killed renamable $r0, 0, 14, $noreg :: (load 4 from %ir.next.i2)
-  ; CHECK:   tCMPi8 renamable $r0, 0, 14, $noreg, implicit-def $cpsr
+  ; CHECK:   renamable $r0 = tLDRi killed renamable $r0, 0, cond:always, $noreg :: (load 4 from %ir.next.i2)
+  ; CHECK:   tCMPi8 renamable $r0, 0, cond:always, $noreg, implicit-def $cpsr
   ; CHECK:   BUNDLE implicit-def dead $itstate, implicit-def dead $r2, implicit-def $cpsr, implicit $r0, implicit killed $cpsr, implicit $r1 {
   ; CHECK:     t2IT 1, 30, implicit-def $itstate
-  ; CHECK:     renamable $r2 = tLDRi renamable $r0, 1, 1, $cpsr, implicit internal $itstate :: (load 4 from %ir.info.i.1)
-  ; CHECK:     renamable $r2 = tLDRHi internal killed renamable $r2, 0, 1, $cpsr, implicit internal killed $r2, implicit internal $itstate :: (load 2 from %ir.data16.i.13)
-  ; CHECK:     t2TEQrr internal killed renamable $r2, renamable $r1, 1, killed $cpsr, implicit-def $cpsr, implicit internal killed $itstate
+  ; CHECK:     renamable $r2 = tLDRi renamable $r0, 1, cond:notequal, $cpsr, implicit internal $itstate :: (load 4 from %ir.info.i.1)
+  ; CHECK:     renamable $r2 = tLDRHi internal killed renamable $r2, 0, cond:notequal, $cpsr, implicit internal killed $r2, implicit internal $itstate :: (load 2 from %ir.data16.i.13)
+  ; CHECK:     t2TEQrr internal killed renamable $r2, renamable $r1, cond:notequal, killed $cpsr, implicit-def $cpsr, implicit internal killed $itstate
   ; CHECK:   }
-  ; CHECK:   t2Bcc %bb.1, 1, killed $cpsr
+  ; CHECK:   t2Bcc %bb.1, cond:notequal, killed $cpsr
   ; CHECK: bb.4.exit:
   ; CHECK:   liveins: $r0
-  ; CHECK:   tBX_RET 14, $noreg, implicit killed $r0
+  ; CHECK:   tBX_RET cond:always, $noreg, implicit killed $r0
   bb.0.entry:
     successors: %bb.1(0x80000000)
     liveins: $r0, $r1
 
     t2B %bb.1, 14, $noreg
 
   bb.3.while.body.end:
     successors: %bb.1(0x80000000)

 liveins:
   - { reg: '$r0', virtual-reg: '' }
   - { reg: '$r1', virtual-reg: '' }
 body:             |
   ; CHECK-LABEL: name: op_not_killed
   ; CHECK: bb.0.entry:
   ; CHECK:   successors: %bb.1(0x80000000)
   ; CHECK:   liveins: $r0, $r1
-  ; CHECK:   $r2 = tMOVr $r0, 14, $noreg
+  ; CHECK:   $r2 = tMOVr $r0, cond:always, $noreg
   ; CHECK: bb.1.while.begin:
   ; CHECK:   successors: %bb.5(0x04000000), %bb.2(0x7c000000)
   ; CHECK:   liveins: $r1, $r2
-  ; CHECK:   renamable $r0 = tLDRi renamable $r2, 1, 14, $noreg :: (load 4 from %ir.info.i)
-  ; CHECK:   renamable $r0 = tLDRHi killed renamable $r0, 0, 14, $noreg :: (load 2 from %ir.data16.i1)
-  ; CHECK:   t2TEQrr renamable $r0, renamable $r1, 14, $noreg, implicit-def $cpsr
-  ; CHECK:   t2Bcc %bb.5, 0, killed $cpsr
+  ; CHECK:   renamable $r0 = tLDRi renamable $r2, 1, cond:always, $noreg :: (load 4 from %ir.info.i)
+  ; CHECK:   renamable $r0 = tLDRHi killed renamable $r0, 0, cond:always, $noreg :: (load 2 from %ir.data16.i1)
+  ; CHECK:   t2TEQrr renamable $r0, renamable $r1, cond:always, $noreg, implicit-def $cpsr
+  ; CHECK:   t2Bcc %bb.5, cond:equal, killed $cpsr
   ; CHECK: bb.2.while.body.a:
   ; CHECK:   successors: %bb.5(0x04000000), %bb.3(0x7c000000)
   ; CHECK:   liveins: $r0, $r1, $r2
-  ; CHECK:   renamable $r2 = tLDRi killed renamable $r2, 0, 14, $noreg :: (load 4 from %ir.next.i2)
-  ; CHECK:   tCMPi8 renamable $r2, 0, 14, $noreg, implicit-def $cpsr
-  ; CHECK:   t2Bcc %bb.5, 0, killed $cpsr
+  ; CHECK:   renamable $r2 = tLDRi killed renamable $r2, 0, cond:always, $noreg :: (load 4 from %ir.next.i2)
+  ; CHECK:   tCMPi8 renamable $r2, 0, cond:always, $noreg, implicit-def $cpsr
+  ; CHECK:   t2Bcc %bb.5, cond:equal, killed $cpsr
   ; CHECK: bb.3.it.block:
   ; CHECK:   successors: %bb.5(0x04000000), %bb.4(0x7c000000)
   ; CHECK:   liveins: $r1, $r2
-  ; CHECK:   renamable $r0 = tLDRi renamable $r2, 1, 14, $noreg :: (load 4 from %ir.info.i.1)
-  ; CHECK:   renamable $r0 = tLDRHi killed renamable $r0, 0, 14, $noreg :: (load 2 from %ir.data16.i.13)
-  ; CHECK:   t2TEQrr renamable $r0, renamable $r1, 14, $noreg, implicit-def $cpsr
-  ; CHECK:   t2Bcc %bb.5, 0, killed $cpsr
+  ; CHECK:   renamable $r0 = tLDRi renamable $r2, 1, cond:always, $noreg :: (load 4 from %ir.info.i.1)
+  ; CHECK:   renamable $r0 = tLDRHi killed renamable $r0, 0, cond:always, $noreg :: (load 2 from %ir.data16.i.13)
+  ; CHECK:   t2TEQrr renamable $r0, renamable $r1, cond:always, $noreg, implicit-def $cpsr
+  ; CHECK:   t2Bcc %bb.5, cond:equal, killed $cpsr
   ; CHECK: bb.4.while.body.end:
   ; CHECK:   successors: %bb.5(0x04000000), %bb.1(0x7c000000)
   ; CHECK:   liveins: $r0, $r1, $r2
-  ; CHECK:   renamable $r2 = tLDRi killed renamable $r2, 0, 14, $noreg :: (load 4 from %ir.next.i.14)
-  ; CHECK:   tCMPi8 renamable $r2, 0, 14, $noreg, implicit-def $cpsr
-  ; CHECK:   t2Bcc %bb.1, 1, killed $cpsr
+  ; CHECK:   renamable $r2 = tLDRi killed renamable $r2, 0, cond:always, $noreg :: (load 4 from %ir.next.i.14)
+  ; CHECK:   tCMPi8 renamable $r2, 0, cond:always, $noreg, implicit-def $cpsr
+  ; CHECK:   t2Bcc %bb.1, cond:notequal, killed $cpsr
   ; CHECK: bb.5.exit:
   ; CHECK:   liveins: $r0
-  ; CHECK:   tBX_RET 14, $noreg, implicit $r0
+  ; CHECK:   tBX_RET cond:always, $noreg, implicit $r0
   bb.0.entry:
     successors: %bb.1(0x80000000)
     liveins: $r0, $r1
 
     $r2 = tMOVr $r0, 14, $noreg
 
   bb.1.while.begin:
     successors: %bb.5(0x04000000), %bb.2(0x7c000000)