Index: include/llvm/CodeGen/GlobalISel/MachineIRBuilder.h =================================================================== --- include/llvm/CodeGen/GlobalISel/MachineIRBuilder.h +++ include/llvm/CodeGen/GlobalISel/MachineIRBuilder.h @@ -605,6 +605,43 @@ /// \return a MachineInstrBuilder for the newly created instruction. MachineInstrBuilder buildUnmerge(ArrayRef Res, unsigned Op); + /// Build and insert \p Res = G_BUILD_VECTOR \p Op0, ... + /// + /// G_BUILD_VECTOR creates a vector value from multiple scalar registers. + /// \pre setBasicBlock or setMI must have been called. + /// \pre The entire register \p Res (and no more) must be covered by the + /// input scalar registers. + /// \pre The type of all \p Ops registers must be identical. + /// + /// \return a MachineInstrBuilder for the newly created instruction. + MachineInstrBuilder buildBuildVector(unsigned Res, ArrayRef Ops); + + /// Build and insert \p Res = G_BUILD_VECTOR_TRUNC \p Op0, ... + /// + /// G_BUILD_VECTOR_TRUNC creates a vector value from multiple scalar registers + /// which have types larger than the destination vector element type, and + /// truncates the values to fit. + /// \pre setBasicBlock or setMI must have been called. + /// \pre The type of all \p Ops registers must be identical, and must be + /// larger than the element type of the result vector. + /// + /// \return a MachineInstrBuilder for the newly created instruction. + MachineInstrBuilder buildBuildVectorTrunc(unsigned Res, + ArrayRef Ops); + + /// Build and insert \p Res = G_CONCAT_VECTORS \p Op0, ... + /// + /// G_CONCAT_VECTORS creates a vector from the concatenation of 2 or more + /// vectors. + /// + /// \pre setBasicBlock or setMI must have been called. + /// \pre The entire register \p Res (and no more) must be covered by the input + /// registers. + /// \pre The type of all source operands must be identical. + /// + /// \return a MachineInstrBuilder for the newly created instruction. + MachineInstrBuilder buildConcatVectors(unsigned Res, ArrayRef Ops); + MachineInstrBuilder buildInsert(unsigned Res, unsigned Src, unsigned Op, unsigned Index); Index: include/llvm/Support/TargetOpcodes.def =================================================================== --- include/llvm/Support/TargetOpcodes.def +++ include/llvm/Support/TargetOpcodes.def @@ -258,6 +258,17 @@ /// larger register. HANDLE_TARGET_OPCODE(G_MERGE_VALUES) +/// Generic instruction to create a vector value from a number of scalar +/// components. +HANDLE_TARGET_OPCODE(G_BUILD_VECTOR) + +/// Generic instruction to create a vector value from a number of scalar +/// components, which have types larger than the result vector elt type. +HANDLE_TARGET_OPCODE(G_BUILD_VECTOR_TRUNC) + +/// Generic instruction to create a vector by concatenating multiple vectors. +HANDLE_TARGET_OPCODE(G_CONCAT_VECTORS) + /// Generic pointer to int conversion. HANDLE_TARGET_OPCODE(G_PTRTOINT) Index: include/llvm/Target/GenericOpcodes.td =================================================================== --- include/llvm/Target/GenericOpcodes.td +++ include/llvm/Target/GenericOpcodes.td @@ -669,6 +669,28 @@ let hasSideEffects = 0; } +/// Create a vector from multiple scalar registers. +def G_BUILD_VECTOR : GenericInstruction { + let OutOperandList = (outs type0:$dst); + let InOperandList = (ins type1:$src0, variable_ops); + let hasSideEffects = 0; +} + +/// Like G_BUILD_VECTOR, but truncates the larger operand types to fit the +/// destination vector elt type. +def G_BUILD_VECTOR_TRUNC : GenericInstruction { + let OutOperandList = (outs type0:$dst); + let InOperandList = (ins type1:$src0, variable_ops); + let hasSideEffects = 0; +} + +/// Create a vector by concatenating vectors together. +def G_CONCAT_VECTORS : GenericInstruction { + let OutOperandList = (outs type0:$dst); + let InOperandList = (ins type1:$src0, variable_ops); + let hasSideEffects = 0; +} + // Intrinsic without side effects. def G_INTRINSIC : GenericInstruction { let OutOperandList = (outs); Index: lib/CodeGen/GlobalISel/MachineIRBuilder.cpp =================================================================== --- lib/CodeGen/GlobalISel/MachineIRBuilder.cpp +++ lib/CodeGen/GlobalISel/MachineIRBuilder.cpp @@ -521,6 +521,64 @@ return MIB; } +MachineInstrBuilder +MachineIRBuilderBase::buildBuildVector(unsigned Res, ArrayRef Ops) { +#ifndef NDEBUG + assert((!Ops.empty() || Ops.size() < 2) && "Must have at least 2 operands"); + assert(getMRI()->getType(Res).isVector() && "Res type must be a vector"); + LLT Ty = getMRI()->getType(Ops[0]); + for (auto Reg : Ops) + assert(getMRI()->getType(Reg) == Ty && "type mismatch in input list"); + assert(Ops.size() * Ty.getSizeInBits() == + getMRI()->getType(Res).getSizeInBits() && + "input scalars do not exactly cover the outpur vector register"); +#endif + MachineInstrBuilder MIB = buildInstr(TargetOpcode::G_BUILD_VECTOR); + MIB.addDef(Res); + for (auto Op : Ops) + MIB.addUse(Op); + return MIB; +} + +MachineInstrBuilder +MachineIRBuilderBase::buildBuildVectorTrunc(unsigned Res, + ArrayRef Ops) { +#ifndef NDEBUG + assert((!Ops.empty() || Ops.size() < 2) && "Must have at least 2 operands"); + LLT Ty = getMRI()->getType(Ops[0]); + for (auto Reg : Ops) + assert(getMRI()->getType(Reg) == Ty && "type mismatch in input list"); +#endif + if (getMRI()->getType(Ops[0]).getSizeInBits() == + getMRI()->getType(Res).getElementType().getSizeInBits()) + return buildBuildVector(Res, Ops); + MachineInstrBuilder MIB = buildInstr(TargetOpcode::G_BUILD_VECTOR_TRUNC); + MIB.addDef(Res); + for (auto Op : Ops) + MIB.addUse(Op); + return MIB; +} + +MachineInstrBuilder +MachineIRBuilderBase::buildConcatVectors(unsigned Res, ArrayRef Ops) { + #ifndef NDEBUG + assert((!Ops.empty() || Ops.size() < 2) && "Must have at least 2 operands"); + LLT Ty = getMRI()->getType(Ops[0]); + for (auto Reg : Ops) { + assert(getMRI()->getType(Reg).isVector() && "expected vector operand"); + assert(getMRI()->getType(Reg) == Ty && "type mismatch in input list"); + } + assert(Ops.size() * Ty.getSizeInBits() == + getMRI()->getType(Res).getSizeInBits() && + "input vectors do not exactly cover the outpur vector register"); + #endif + MachineInstrBuilder MIB = buildInstr(TargetOpcode::G_CONCAT_VECTORS); + MIB.addDef(Res); + for (auto Op : Ops) + MIB.addUse(Op); + return MIB; +} + MachineInstrBuilder MachineIRBuilderBase::buildInsert(unsigned Res, unsigned Src, unsigned Op, unsigned Index) { Index: lib/CodeGen/MachineVerifier.cpp =================================================================== --- lib/CodeGen/MachineVerifier.cpp +++ lib/CodeGen/MachineVerifier.cpp @@ -1055,6 +1055,63 @@ } break; } + case TargetOpcode::G_BUILD_VECTOR: { + // Source types must be scalars, dest type a vector. Total size of scalars + // must match the dest vector size. + LLT DstTy = MRI->getType(MI->getOperand(0).getReg()); + LLT SrcEltTy = MRI->getType(MI->getOperand(1).getReg()); + if (!DstTy.isVector() || SrcEltTy.isVector()) + report("G_BUILD_VECTOR must produce a vector from scalar operands", MI); + for (unsigned i = 2; i < MI->getNumOperands(); ++i) { + if (MRI->getType(MI->getOperand(1).getReg()) != + MRI->getType(MI->getOperand(i).getReg())) + report("G_BUILD_VECTOR source operand types are not homogeneous", MI); + } + if (DstTy.getSizeInBits() != + SrcEltTy.getSizeInBits() * (MI->getNumOperands() - 1)) + report("G_BUILD_VECTOR src operands total size don't match dest " + "size.", + MI); + break; + } + case TargetOpcode::G_BUILD_VECTOR_TRUNC: { + // Source types must be scalars, dest type a vector. Scalar types must be + // larger than the dest vector elt type, as this is a truncating operation. + LLT DstTy = MRI->getType(MI->getOperand(0).getReg()); + LLT SrcEltTy = MRI->getType(MI->getOperand(1).getReg()); + if (!DstTy.isVector() || SrcEltTy.isVector()) + report("G_BUILD_VECTOR_TRUNC must produce a vector from scalar operands", + MI); + for (unsigned i = 2; i < MI->getNumOperands(); ++i) { + if (MRI->getType(MI->getOperand(1).getReg()) != + MRI->getType(MI->getOperand(i).getReg())) + report("G_BUILD_VECTOR_TRUNC source operand types are not homogeneous", + MI); + } + if (SrcEltTy.getSizeInBits() <= DstTy.getElementType().getSizeInBits()) + report("G_BUILD_VECTOR_TRUNC source operand types are not larger than " + "dest elt type", + MI); + break; + } + case TargetOpcode::G_CONCAT_VECTORS: { + // Source types should be vectors, and total size should match the dest + // vector size. + LLT DstTy = MRI->getType(MI->getOperand(0).getReg()); + LLT SrcTy = MRI->getType(MI->getOperand(1).getReg()); + if (!DstTy.isVector() || !SrcTy.isVector()) + report("G_CONCAT_VECTOR requires vector source and destination operands", + MI); + for (unsigned i = 2; i < MI->getNumOperands(); ++i) { + if (MRI->getType(MI->getOperand(1).getReg()) != + MRI->getType(MI->getOperand(i).getReg())) + report("G_CONCAT_VECTOR source operand types are not homogeneous", MI); + } + if (DstTy.getNumElements() != + SrcTy.getNumElements() * (MI->getNumOperands() - 1)) + report("G_CONCAT_VECTOR num dest and source elements should match", MI); + break; + } case TargetOpcode::COPY: { if (foundErrors) break; Index: test/CodeGen/AArch64/GlobalISel/legalizer-info-validation.mir =================================================================== --- test/CodeGen/AArch64/GlobalISel/legalizer-info-validation.mir +++ test/CodeGen/AArch64/GlobalISel/legalizer-info-validation.mir @@ -69,6 +69,15 @@ # DEBUG-NEXT: G_MERGE_VALUES (opcode {{[0-9]+}}): 2 type indices # DEBUG: .. type index coverage check SKIPPED: user-defined predicate detected # +# DEBUG-NEXT: G_BUILD_VECTOR (opcode {{[0-9]+}}): 2 type indices +# DEBUG: .. type index coverage check SKIPPED: no rules defined +# +# DEBUG-NEXT: G_BUILD_VECTOR_TRUNC (opcode {{[0-9]+}}): 2 type indices +# DEBUG: .. type index coverage check SKIPPED: no rules defined +# +# DEBUG-NEXT: G_CONCAT_VECTORS (opcode {{[0-9]+}}): 2 type indices +# DEBUG: .. type index coverage check SKIPPED: no rules defined +# # DEBUG-NEXT: G_PTRTOINT (opcode {{[0-9]+}}): 2 type indices # DEBUG: .. the first uncovered type index: 2, OK #