[MIRParser] Add parser support for 'true' and 'false' i1s.

[aemerson]

Summary

We already output true and false in the printer, but the parser isn't able to read it.

[thegameg]

lib/CodeGen/MIRParser/MIParser.cpp

1389

It looks like parseIRConstant already handles true and false. Can we reuse that here?

1907

Can we get a test for the errors here?

[rtereshin]

lib/CodeGen/MIRParser/MIParser.cpp

1389

Also, parseIRConstant will produce a neat error message if the boolean literal isn't specified as i1:

error: /Volumes/Data/llvm/test/CodeGen/MIR/AArch64/parse-integer-true-false.mir:9:32: constant expression type mismatch
    %0:_(s32) = G_CONSTANT i32 true

while the current version will just silently replace the type with i1.

[aemerson]

lib/CodeGen/MIRParser/MIParser.cpp

1389

Sure, that makes it a lot simpler.

[rtereshin]

lib/CodeGen/MIRParser/MIParser.cpp

1378

Why startswith instead of direct comparisons? Is it going to parse truee as true?

[aemerson]

lib/CodeGen/MIRParser/MIParser.cpp

1378

It won't parse that because parseIRConstant will fail, but you're right I had startswith mistakenly because it was a stringref view onto the raw source since they're not tokens any more, which in the debugger looked like a longer string than just "true" or "false".

lib/CodeGen/MIRParser/MILexer.h

enum TokenKind {
     kw_call_entry,
     kw_liveout,
     kw_address_taken,
     kw_landing_pad,
     kw_liveins,
     kw_successors,
     kw_floatpred,
     kw_intpred,
+    kw_true,
+    kw_false,
 
     // Named metadata keywords
     md_tbaa,
     md_alias_scope,
     md_noalias,
     md_range,
     md_diexpr,
 

lib/CodeGen/MIRParser/MILexer.cpp

return StringSwitch<MIToken::TokenKind>(Identifier)
       .Case("call-entry", MIToken::kw_call_entry)
       .Case("liveout", MIToken::kw_liveout)
       .Case("address-taken", MIToken::kw_address_taken)
       .Case("landing-pad", MIToken::kw_landing_pad)
       .Case("liveins", MIToken::kw_liveins)
       .Case("successors", MIToken::kw_successors)
       .Case("floatpred", MIToken::kw_floatpred)
       .Case("intpred", MIToken::kw_intpred)
+      .Case("true", MIToken::kw_true)
+      .Case("false", MIToken::kw_false)
       .Default(MIToken::Identifier);
 }
 
 static Cursor maybeLexIdentifier(Cursor C, MIToken &Token) {
   if (!isalpha(C.peek()) && C.peek() != '_')
     return None;
   auto Range = C;
   while (isIdentifierChar(C.peek()))

lib/CodeGen/MIRParser/MIParser.cpp

if (TypeStr.front() != 'i' && TypeStr.front() != 's' &&
     return error(
         "a typed immediate operand should start with one of 'i', 's', or 'p'");
   StringRef SizeStr = Token.range().drop_front();
   if (SizeStr.size() == 0 || !llvm::all_of(SizeStr, isdigit))
     return error("expected integers after 'i'/'s'/'p' type character");
 
   auto Loc = Token.location();
   lex();
-  if (Token.isNot(MIToken::IntegerLiteral))
-    return error("expected an integer literal");
   const Constant *C = nullptr;
+
+  const Module *M = MF.getFunction().getParent();
+  switch (Token.kind()) {
+  case MIToken::kw_true:
+    C = ConstantInt::getTrue(M->getContext());
+    lex();
+    break;
+  case MIToken::kw_false:
+    C = ConstantInt::getFalse(M->getContext());
+    lex();
+    break;
+  case MIToken::IntegerLiteral:
     if (parseIRConstant(Loc, C))
       return true;
+    break;
+  default:
+    return error("expected an integer literal");
+  }
+
   Dest = MachineOperand::CreateCImm(cast<ConstantInt>(C));
   return false;
 }
 
 bool MIParser::parseFPImmediateOperand(MachineOperand &Dest) {
   auto Loc = Token.location();
   lex();
   if (Token.isNot(MIToken::FloatingPointLiteral) &&

 bool MIParser::parsePredicateOperand(MachineOperand &Dest) {
   assert(Token.is(MIToken::kw_intpred) || Token.is(MIToken::kw_floatpred));
   bool IsFloat = Token.is(MIToken::kw_floatpred);
   lex();
 
   if (expectAndConsume(MIToken::lparen))
     return error("expected syntax intpred(whatever) or floatpred(whatever");
 
-  if (Token.isNot(MIToken::Identifier))
-    return error("whatever");
-
   CmpInst::Predicate Pred;
+  if (Token.is(MIToken::kw_true)) {
+    if (IsFloat)
+      Pred = CmpInst::FCMP_TRUE;
+    else
+      return error("invalid integer predicate");
+  } else if (Token.is(MIToken::kw_false)) {
+    if (IsFloat)
+      Pred = CmpInst::FCMP_FALSE;
+    else
+      return error("invalid integer predicate");
+  } else if (Token.isNot(MIToken::Identifier)) {
+    return error("expected a predicate");
+  }
+
   if (IsFloat) {
+    if (Pred != CmpInst::FCMP_TRUE && Pred != CmpInst::FCMP_FALSE) {
       Pred = StringSwitch<CmpInst::Predicate>(Token.stringValue())
-               .Case("false", CmpInst::FCMP_FALSE)
                  .Case("oeq", CmpInst::FCMP_OEQ)
                  .Case("ogt", CmpInst::FCMP_OGT)
                  .Case("oge", CmpInst::FCMP_OGE)
                  .Case("olt", CmpInst::FCMP_OLT)
                  .Case("ole", CmpInst::FCMP_OLE)
                  .Case("one", CmpInst::FCMP_ONE)
                  .Case("ord", CmpInst::FCMP_ORD)
                  .Case("uno", CmpInst::FCMP_UNO)
                  .Case("ueq", CmpInst::FCMP_UEQ)
                  .Case("ugt", CmpInst::FCMP_UGT)
                  .Case("uge", CmpInst::FCMP_UGE)
                  .Case("ult", CmpInst::FCMP_ULT)
                  .Case("ule", CmpInst::FCMP_ULE)
                  .Case("une", CmpInst::FCMP_UNE)
-               .Case("true", CmpInst::FCMP_TRUE)
                  .Default(CmpInst::BAD_FCMP_PREDICATE);
+    }
     if (!CmpInst::isFPPredicate(Pred))
       return error("invalid floating-point predicate");
   } else {
     Pred = StringSwitch<CmpInst::Predicate>(Token.stringValue())
                .Case("eq", CmpInst::ICMP_EQ)
                .Case("ne", CmpInst::ICMP_NE)
                .Case("sgt", CmpInst::ICMP_SGT)
                .Case("sge", CmpInst::ICMP_SGE)

test/CodeGen/MIR/AArch64/parse-integer-true-false.mir

+# RUN: llc -mtriple=aarch64-- -run-pass none -o - %s | FileCheck %s
+# Parse an i1 being a 'true' or 'false'
+---
+name: i1_true_false
+body: |
+  bb.0:
+    ; CHECK: %0:_(s1) = G_CONSTANT i1 true
+    ; CHECK: %1:_(s1) = G_CONSTANT i1 false
+    %0:_(s1) = G_CONSTANT i1 true
+    %1:_(s1) = G_CONSTANT i1 false
+...