GlobalISel: Make buildConstant handle vectors

[arsenm]

Summary

Produce a splat build_vector similar to how
SelectionDAG::getConstant does.

[aditya_nandakumar]

Could you please add a test case for the vector build constant case? I suspect unless there is already a target to use this, unit test might be the only way.

lib/CodeGen/GlobalISel/MachineIRBuilder.cpp

260

Any reason for not using buildBuildVector here?

[arsenm]

lib/CodeGen/GlobalISel/MachineIRBuilder.cpp

260

It seemed less convenient to create the vector of arguments than to just add them directly

[arsenm]

Add unit test

[aditya_nandakumar]

Thanks. Looks good.

[arsenm]

r351880

include/llvm/Support/LowLevelTypeImpl.h

public:
 
   /// Returns the total size of the type. Must only be called on sized types.
   unsigned getSizeInBits() const {
     if (isPointer() || isScalar())
       return getScalarSizeInBits();
     return getScalarSizeInBits() * getNumElements();
   }
 
+  LLT getScalarType() const {
+    return isVector() ? getElementType() : *this;
+  }
+
   unsigned getScalarSizeInBits() const {
     assert(RawData != 0 && "Invalid Type");
     if (!IsVector) {
       if (!IsPointer)
         return getFieldValue(ScalarSizeFieldInfo);
       else
         return getFieldValue(PointerSizeFieldInfo);
     } else {

lib/CodeGen/GlobalISel/MachineIRBuilder.cpp

 MachineInstrBuilder MachineIRBuilder::buildCopy(const DstOp &Res,
                                                 const SrcOp &Op) {
   return buildInstr(TargetOpcode::COPY, Res, Op);
 }
 
 MachineInstrBuilder MachineIRBuilder::buildConstant(const DstOp &Res,
                                                     const ConstantInt &Val) {
   LLT Ty = Res.getLLTTy(*getMRI());
+  LLT EltTy = Ty.getScalarType();
 
   const ConstantInt *NewVal = &Val;
-  if (Ty.getScalarSizeInBits() != Val.getBitWidth())
-    NewVal = ConstantInt::get(getMF().getFunction().getContext(),
-                              Val.getValue().sextOrTrunc(Ty.getSizeInBits()));
+  if (EltTy.getSizeInBits() != Val.getBitWidth()) {
+    NewVal = ConstantInt::get(
+      getMF().getFunction().getContext(),
+      Val.getValue().sextOrTrunc(EltTy.getSizeInBits()));
+  }
+
+  if (Ty.isVector()) {
+    unsigned EltReg = getMRI()->createGenericVirtualRegister(EltTy);
+    buildInstr(TargetOpcode::G_CONSTANT)
+      .addDef(EltReg)
+      .addCImm(NewVal);
+
+    auto MIB = buildInstr(TargetOpcode::G_BUILD_VECTOR);
+    Res.addDefToMIB(*getMRI(), MIB);
+
+    for (unsigned I = 0, E = Ty.getNumElements(); I != E; ++I)
+      MIB.addUse(EltReg);
+    return MIB;
+  }
 
   auto MIB = buildInstr(TargetOpcode::G_CONSTANT);
   Res.addDefToMIB(*getMRI(), MIB);
   MIB.addCImm(NewVal);
   return MIB;
 }
 
 MachineInstrBuilder MachineIRBuilder::buildConstant(const DstOp &Res,
                                                     int64_t Val) {
   auto IntN = IntegerType::get(getMF().getFunction().getContext(),
                                Res.getLLTTy(*getMRI()).getSizeInBits());
   ConstantInt *CI = ConstantInt::get(IntN, Val, true);
   return buildConstant(Res, *CI);
 }
 
 MachineInstrBuilder MachineIRBuilder::buildFConstant(const DstOp &Res,
                                                      const ConstantFP &Val) {
-  assert(!Res.getLLTTy(*getMRI()).isPointer() && "invalid operand type");
+  LLT Ty = Res.getLLTTy(*getMRI());
+
+  assert(!Ty.isPointer() && "invalid operand type");
+
+  if (Ty.isVector()) {
+    unsigned EltReg
+      = getMRI()->createGenericVirtualRegister(Ty.getElementType());
+    buildInstr(TargetOpcode::G_FCONSTANT)
+      .addDef(EltReg)
+      .addFPImm(&Val);
+
+    auto MIB = buildInstr(TargetOpcode::G_BUILD_VECTOR);
+    Res.addDefToMIB(*getMRI(), MIB);
+
+    for (unsigned I = 0, E = Ty.getNumElements(); I != E; ++I)
+      MIB.addUse(EltReg);
+    return MIB;
+  }
 
   auto MIB = buildInstr(TargetOpcode::G_FCONSTANT);
   Res.addDefToMIB(*getMRI(), MIB);
   MIB.addFPImm(&Val);
   return MIB;
 }
 
 MachineInstrBuilder MachineIRBuilder::buildFConstant(const DstOp &Res,

unittests/CodeGen/GlobalISel/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   ${LLVM_TARGETS_TO_BUILD}
   CodeGen
   Core
   GlobalISel
   MC
   MIRParser
   Support
   Target
   )
 
 add_llvm_unittest(GlobalISelTests
-        LegalizerInfoTest.cpp
-        PatternMatchTest.cpp
-        LegalizerHelperTest.cpp
-        CSETest.cpp
-        )
+  CSETest.cpp
+  LegalizerHelperTest.cpp
+  MachineIRBuilderTest.cpp

unittests/CodeGen/GlobalISel/GISelMITest.h

-//===- GISelMITest.h
-//-----------------------------------------------===//
+//===- GISelMITest.h --------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 #ifndef LLVM_UNITTEST_CODEGEN_GLOBALISEL_GISELMI_H
 #define LLVM_UNITTEST_CODEGEN_GLOBALISEL_GISELMI_H

unittests/CodeGen/GlobalISel/MachineIRBuilderTest.cpp

+//===- MachineIRBuilderTest.cpp -------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "GISelMITest.h"
+#include "llvm/CodeGen/GlobalISel/MachineIRBuilder.h"
+
+TEST_F(GISelMITest, TestBuildConstantFConstant) {
+  if (!TM)
+    return;
+
+  MachineIRBuilder B(*MF);
+  B.setInsertPt(*EntryMBB, EntryMBB->begin());
+
+  B.buildConstant(LLT::scalar(32), 42);
+  B.buildFConstant(LLT::scalar(32), 1.0);
+
+  B.buildConstant(LLT::vector(2, 32), 99);
+  B.buildFConstant(LLT::vector(2, 32), 2.0);
+
+  auto CheckStr = R"(
+  CHECK: [[CONST0:%[0-9]+]]:_(s32) = G_CONSTANT i32 42
+  CHECK: [[FCONST0:%[0-9]+]]:_(s32) = G_FCONSTANT float 1.000000e+00
+  CHECK: [[CONST1:%[0-9]+]]:_(s32) = G_CONSTANT i32 99
+  CHECK: [[VEC0:%[0-9]+]]:_(<2 x s32>) = G_BUILD_VECTOR [[CONST1]]:_(s32), [[CONST1]]:_(s32)
+  CHECK: [[FCONST1:%[0-9]+]]:_(s32) = G_FCONSTANT double 2.000000e+00
+  CHECK: [[VEC1:%[0-9]+]]:_(<2 x s32>) = G_BUILD_VECTOR [[FCONST1]]:_(s32), [[FCONST1]]:_(s32)
+
+  )";
+
+  ASSERT_TRUE(CheckMachineFunction(*MF, CheckStr));
+}