[TableGen] Fix spurious type error in bit assignment.

[simon_tatham]

Summary

The following example gives the error message "expected value of type
'bits<32>', got 'bit'" on the assignment.

class Instruction { bits<32> encoding; }
def foo: Instruction { let encoding{10} = !eq(0, 1); }

But there's nothing wrong with this code: 'bit' is a perfectly good
type for the RHS of an assignment to a single bit of an
instruction encoding.

The problem is that ParseBodyItem is accidentally type-checking the
RHS against the full type of the encoding field, without adjusting
it in the case where we're only assigning to a subset of the bits. The
fix is trivial.

[hfinkel]

LGTM

llvm/lib/TableGen/TGParser.cpp

if (Lex.getCode() != tgtok::equal)
     return TokError("expected '=' in let expression");
   Lex.Lex();  // eat the '='.
 
   RecordVal *Field = CurRec->getValue(FieldName);
   if (!Field)
     return TokError("Value '" + FieldName->getValue() + "' unknown!");
 
   RecTy *Type = Field->getType();
+  if (!BitList.empty() && isa<BitsRecTy>(Type)) {
+    // When assigning to a subset of a 'bits' object, expect the RHS to have
+    // the type of that subset instead of the type of the whole object.
+    Type = BitsRecTy::get(BitList.size());
+  }
 
   Init *Val = ParseValue(CurRec, Type);
   if (!Val) return true;
 
   if (Lex.getCode() != tgtok::semi)
     return TokError("expected ';' after let expression");
   Lex.Lex();
 

llvm/test/TableGen/BitsInit.td

def {
 
   bits<16> H;
   let H{15-0} = { { 0b11001100 }, 0b00110011 };
   bits<16> I = { G1, G2 };
 
   // Make sure we can initialise ints with bits<> values.
   int J = H;
   int K = { 0, 1 };
+
+  bits<2> L;
+  let L{0} = 1;
+  let L{1} = !eq(L{0}, 0);
 }
 
 // CHECK: def {{.*}} {
 // CHECK: bits<2> B1;
 // CHECK: bits<3> B2 = { 0, 1, 1 };
 // CHECK: bits<2> C1;
 // CHECK: bits<3> C2 = { 1, 1, 1 };
 // CHECK: bits<2> D1 = { 0, 0 };

 // CHECK: bits<9> F3;
 // CHECK: bits<8> G1 = { 0, 1, 1, 0, 0, 1, 0, 0 };
 // CHECK: bits<8> G2 = { 0, 1, 1, 0, 0, 1, 0, 0 };
 // CHECK: bits<8> G3 = { 0, 1, 1, 0, 0, 1, 0, 0 };
 // CHECK: bits<16> H = { 1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1 };
 // CHECK: bits<16> I = { 0, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0 };
 // CHECK: int J = 52275;
 // CHECK: int K = 1;
+// CHECK: bits<2> L = { 0, 1 };
 // CHECK: }