[GlobalISel][AArch64] Save a copy on G_SELECT by fixing condition to GPR

[paquette]

Summary

The condition can never be fed by FPRs, so it should always be on a GPR.

[aemerson]

LGTM.

llvm/trunk/lib/Target/AArch64/AArch64RegisterBankInfo.cpp

case TargetOpcode::G_STORE:
     }
     break;
   case TargetOpcode::G_SELECT: {
     // If the destination is FPR, preserve that.
     if (OpRegBankIdx[0] != PMI_FirstGPR)
       break;
 
     // If we're taking in vectors, we have no choice but to put everything on
-    // FPRs.
+    // FPRs, except for the condition. The condition must always be on a GPR.
     LLT SrcTy = MRI.getType(MI.getOperand(2).getReg());
     if (SrcTy.isVector()) {
-      for (unsigned Idx = 0; Idx < 4; ++Idx)
-        OpRegBankIdx[Idx] = PMI_FirstFPR;
+      OpRegBankIdx = {PMI_FirstFPR, PMI_FirstGPR, PMI_FirstFPR, PMI_FirstFPR};
       break;
     }
 
     // Try to minimize the number of copies. If we have more floating point
     // constrained values than not, then we'll put everything on FPR. Otherwise,
     // everything has to be on GPR.
     unsigned NumFP = 0;
 
for (unsigned Idx = 2; Idx < 4; ++Idx) {
       if (getRegBank(VReg, MRI, TRI) == &AArch64::FPRRegBank ||
           onlyDefinesFP(*DefMI, MRI, TRI))
         ++NumFP;
     }
 
     // If we have more FP constraints than not, then move everything over to
     // FPR.
     if (NumFP >= 2)
-      for (unsigned Idx = 0; Idx < 4; ++Idx)
-        OpRegBankIdx[Idx] = PMI_FirstFPR;
+      OpRegBankIdx = {PMI_FirstFPR, PMI_FirstGPR, PMI_FirstFPR, PMI_FirstFPR};
 
     break;
   }
   case TargetOpcode::G_UNMERGE_VALUES: {
     // If the first operand belongs to a FPR register bank, then make sure that
     // we preserve that.
     if (OpRegBankIdx[0] != PMI_FirstGPR)
       break;

llvm/trunk/test/CodeGen/AArch64/GlobalISel/regbank-fp-use-def.mir

bb.0:
     liveins: $w0, $w1, $w2
     ; CHECK-LABEL: name: select_defined_by_fp_using_fp
     ; CHECK: liveins: $w0, $w1, $w2
     ; CHECK: [[COPY:%[0-9]+]]:gpr(s32) = COPY $w0
     ; CHECK: [[TRUNC:%[0-9]+]]:gpr(s1) = G_TRUNC %2(s32)
     ; CHECK: [[COPY1:%[0-9]+]]:gpr(s32) = COPY $w1
     ; CHECK: [[COPY2:%[0-9]+]]:gpr(s32) = COPY $w2
     ; CHECK: [[SITOFP:%[0-9]+]]:fpr(s32) = G_SITOFP [[COPY1]](s32)
-    ; CHECK: [[COPY3:%[0-9]+]]:fpr(s1) = COPY [[TRUNC]](s1)
-    ; CHECK: [[COPY4:%[0-9]+]]:fpr(s32) = COPY [[COPY2]](s32)
-    ; CHECK: [[SELECT:%[0-9]+]]:fpr(s32) = G_SELECT [[COPY3]](s1), [[COPY4]], [[SITOFP]]
+    ; CHECK: [[COPY3:%[0-9]+]]:fpr(s32) = COPY [[COPY2]](s32)
+    ; CHECK: [[SELECT:%[0-9]+]]:fpr(s32) = G_SELECT [[TRUNC]](s1), [[COPY3]], [[SITOFP]]
     ; CHECK: [[FPTOSI:%[0-9]+]]:gpr(s32) = G_FPTOSI [[SELECT]](s32)
     %0:_(s32) = COPY $w0
     %1:_(s1) = G_TRUNC %3(s32)
     %2:_(s32) = COPY $w1
     %3:_(s32) = COPY $w2
     %4:_(s32) = G_SITOFP %2
     %6:_(s32) = G_SELECT %1(s1), %3, %4
     %8:_(s32) = G_FPTOSI %6

llvm/trunk/test/CodeGen/AArch64/GlobalISel/regbank-select.mir

bb.0:
     liveins: $s0, $s1, $w0
 
     ; CHECK-LABEL: name: select_f32
     ; CHECK: liveins: $s0, $s1, $w0
     ; CHECK: [[COPY:%[0-9]+]]:gpr(s32) = COPY $w0
     ; CHECK: [[TRUNC:%[0-9]+]]:gpr(s1) = G_TRUNC [[COPY]](s32)
     ; CHECK: [[COPY1:%[0-9]+]]:fpr(s32) = COPY $s0
     ; CHECK: [[COPY2:%[0-9]+]]:fpr(s32) = COPY $s1
-    ; CHECK: [[COPY3:%[0-9]+]]:fpr(s1) = COPY [[TRUNC]](s1)
-    ; CHECK: [[SELECT:%[0-9]+]]:fpr(s32) = G_SELECT [[COPY3]](s1), [[COPY1]], [[COPY2]]
+    ; CHECK: [[SELECT:%[0-9]+]]:fpr(s32) = G_SELECT [[TRUNC]](s1), [[COPY1]], [[COPY2]]
     ; CHECK: $s0 = COPY [[SELECT]](s32)
     ; CHECK: RET_ReallyLR implicit $s0
     %3:_(s32) = COPY $w0
     %0:_(s1) = G_TRUNC %3(s32)
     %1:_(s32) = COPY $s0
     %2:_(s32) = COPY $s1
     %4:_(s32) = G_SELECT %0(s1), %1, %2
     $s0 = COPY %4(s32)
bb.0:
     liveins: $d0, $d1, $w0
 
     ; CHECK-LABEL: name: select_f64
     ; CHECK: liveins: $d0, $d1, $w0
     ; CHECK: [[COPY:%[0-9]+]]:gpr(s32) = COPY $w0
     ; CHECK: [[TRUNC:%[0-9]+]]:gpr(s1) = G_TRUNC [[COPY]](s32)
     ; CHECK: [[COPY1:%[0-9]+]]:fpr(s64) = COPY $d0
     ; CHECK: [[COPY2:%[0-9]+]]:fpr(s64) = COPY $d1
-    ; CHECK: [[COPY3:%[0-9]+]]:fpr(s1) = COPY [[TRUNC]](s1)
-    ; CHECK: [[SELECT:%[0-9]+]]:fpr(s64) = G_SELECT [[COPY3]](s1), [[COPY1]], [[COPY2]]
+    ; CHECK: [[SELECT:%[0-9]+]]:fpr(s64) = G_SELECT [[TRUNC]](s1), [[COPY1]], [[COPY2]]
     ; CHECK: $d0 = COPY [[SELECT]](s64)
     ; CHECK: RET_ReallyLR implicit $d0
     %3:_(s32) = COPY $w0
     %0:_(s1) = G_TRUNC %3(s32)
     %1:_(s64) = COPY $d0
     %2:_(s64) = COPY $d1
     %4:_(s64) = G_SELECT %0(s1), %1, %2
     $d0 = COPY %4(s64)
body:             |
   bb.0:
     liveins: $d0, $d1, $w0
     ; CHECK-LABEL: name: two_fpr_inputs_gpr_output
     ; CHECK: liveins: $d0, $d1, $w0
     ; CHECK: [[COPY:%[0-9]+]]:gpr(s32) = COPY $w0
     ; CHECK: [[TRUNC:%[0-9]+]]:gpr(s1) = G_TRUNC [[COPY]](s32)
     ; CHECK: [[COPY1:%[0-9]+]]:fpr(s64) = COPY $d0
     ; CHECK: [[COPY2:%[0-9]+]]:fpr(s64) = COPY $d1
-    ; CHECK: [[COPY3:%[0-9]+]]:fpr(s1) = COPY [[TRUNC]](s1)
-    ; CHECK: [[SELECT:%[0-9]+]]:fpr(s64) = G_SELECT [[COPY3]](s1), [[COPY1]], [[COPY2]]
+    ; CHECK: [[SELECT:%[0-9]+]]:fpr(s64) = G_SELECT [[TRUNC]](s1), [[COPY1]], [[COPY2]]
     ; CHECK: $x0 = COPY [[SELECT]](s64)
     ; CHECK: RET_ReallyLR implicit $x0
 
     ; Verify that the G_SELECT only has FPRs.
     ; The only difference between fcsel and csel are the register banks. So,
     ; if we have two FPR inputs and a GPR output, we should do a floating point
     ; select anyway. This will cost one copy for the output, but that's less
     ; than doing two to put the inputs on GPRs.
body:             |
   bb.0:
     liveins: $d0, $x1, $w0
     ; CHECK-LABEL: name: one_fpr_input_fpr_output
     ; CHECK: liveins: $d0, $x1, $w0
     ; CHECK: [[COPY:%[0-9]+]]:gpr(s32) = COPY $w0
     ; CHECK: [[TRUNC:%[0-9]+]]:gpr(s1) = G_TRUNC [[COPY]](s32)
     ; CHECK: [[COPY1:%[0-9]+]]:fpr(s64) = COPY $d0
     ; CHECK: [[COPY2:%[0-9]+]]:gpr(s64) = COPY $x1
-    ; CHECK: [[COPY3:%[0-9]+]]:fpr(s1) = COPY [[TRUNC]](s1)
-    ; CHECK: [[COPY4:%[0-9]+]]:fpr(s64) = COPY [[COPY2]](s64)
-    ; CHECK: [[SELECT:%[0-9]+]]:fpr(s64) = G_SELECT [[COPY3]](s1), [[COPY1]], [[COPY4]]
+    ; CHECK: [[COPY3:%[0-9]+]]:fpr(s64) = COPY [[COPY2]](s64)
+    ; CHECK: [[SELECT:%[0-9]+]]:fpr(s64) = G_SELECT [[TRUNC]](s1), [[COPY1]], [[COPY3]]
     ; CHECK: $d0 = COPY [[SELECT]](s64)
     ; CHECK: RET_ReallyLR implicit $d0
 
     ; Same idea as the above test. If the output is an FPR, and one of the
     ; inputs is an FPR, then it's fewer copies to just do a FCSEL.
 
     %3:_(s32) = COPY $w0
     %0:_(s1) = G_TRUNC %3(s32)