[CodeGen] Use the non-pointer LLT equivalent to check regclass type

[lewis-revill]

Summary

When we check the type legality of assigning a given LLT to a register class, we compare the LLT equivalents of the MVTs assigned to the register class to the given LLT. However since no MVTs match to the pointer LLTs, we always return false when given a pointer LLT - even if the type size and shape is legal for the register class.

This patch simply uses the non-pointer LLT equivalent to compare against the LLT equivalents of the MVTs assigned to the register class instead. Thus we can report pointer types as legal for register classes when their size and shape is legal.

[lewis-revill]

Bump - is anyone able to review this?

[arsenm]

Can you add a verifier test for this?

The bridging between LLT and MVT is increasingly painful, we should probably start putting in the effort to move more infrastructure to directly using LLT

[lewis-revill]

In D118766#3308106, @arsenm wrote:

Can you add a verifier test for this?

The bridging between LLT and MVT is increasingly painful, we should probably start putting in the effort to move more infrastructure to directly using LLT

Sorry not quite sure what exactly a verifier test refers to. Do you mean an LLC test for the issue in RISC-V that exposed this or something else?

[arsenm]

In D118766#3322284, @lewis-revill wrote:

In D118766#3308106, @arsenm wrote:

Can you add a verifier test for this?

The bridging between LLT and MVT is increasingly painful, we should probably start putting in the effort to move more infrastructure to directly using LLT

Sorry not quite sure what exactly a verifier test refers to. Do you mean an LLC test for the issue in RISC-V that exposed this or something else?

Yes. You can write a test that fails the verifier and check the verifier output is consistent here. e.g. I added such a test in cea97fc0fcd86d52f9efa215116356b72faeb17d when I added this version

[arsenm]

Should get a verifier test

llvm/include/llvm/CodeGen/TargetRegisterInfo.h

bool isTypeLegalForClass(const TargetRegisterClass &RC, MVT T) const {
     for (auto I = legalclasstypes_begin(RC); *I != MVT::Other; ++I)
       if (MVT(*I) == T)
         return true;
     return false;
   }
 
   /// Return true if the given TargetRegisterClass is compatible with LLT T.
   bool isTypeLegalForClass(const TargetRegisterClass &RC, LLT T) const {
+    // There's no equivalent MVT for LLT pointer types, so here we transform the
+    // LLT to its non-pointer equivalent before checking legality based on just
+    // the size and shape if applicable.
+    LLT NonPtrT = T.changeElementType(LLT::scalar(T.getScalarSizeInBits()));
     for (auto I = legalclasstypes_begin(RC); *I != MVT::Other; ++I) {
       MVT VT(*I);
       if (VT == MVT::Untyped)
         return true;
 
-      if (LLT(VT) == T)
+      if (LLT(VT) == NonPtrT)
         return true;
     }
     return false;
   }
 
   /// Loop over all of the value types that can be represented by values
   /// in the given register class.
   vt_iterator legalclasstypes_begin(const TargetRegisterClass &RC) const {