[CIR] Vector types, part 2 (#387)

This is part 2 of implementing vector types and vector operations in
ClangIR, issue #284.

Create new operation `cir.vec.insert`, which changes one element of an
existing vector object and returns the modified vector object. The input
and output vectors are prvalues; this operation does not touch memory.
The assembly format and the order of the arguments match that of
llvm.insertelement in the LLVM dialect, since the operations have
identical semantics.

Implement vector element lvalues in class `LValue`, adding member
functions `getVectorAddress()`, `getVectorPointer()`, `getVectorIdx()`,
and `MakeVectorElt(...)`.

The assembly format for operation `cir.vec.extract` was changed to match
that of llvm.extractelement in the LLVM dialect, since the operations
have identical semantics.

These two features, `cir.vec.insert` and vector element lvalues, are
used to implement `v[n] = e`, where `v` is a vector. This is a little
tricky, because `v[n]` isn't really an lvalue, as its address cannot be
taken. The only place it can be used as an lvalue is on the left-hand
side of an assignment.

Implement unary operators on vector objects (except for logical not on a
vector mask, which will be covered in a future commit for boolean
vectors). The code for lowering cir.unary for all types, in
`CIRUnaryOpLowering::matchAndRewrite`, was largely rewritten. Support
for unary `+` on non-vector pointer types was added. (It was already
supported and tested in AST->ClangIR CodeGen, but was missing from
ClangIR->LLVM Dialect lowering.)

Add tests for all binary vector arithmetic operations other than
relational operators and shift operators. There were all working after
the previous vector types commit, but only addition had beet tested at
the time.

Co-authored-by: Bruno Cardoso Lopes <[email protected]>

Author: 2 people

clang/include/clang/CIR/Dialect/IR/CIROps.td

@@ -1672,14 +1672,39 @@ def GetMemberOp : CIR_Op<"get_member"> {
   let hasVerifier = 1;
 }
 
+//===----------------------------------------------------------------------===//
+// VecInsertOp
+//===----------------------------------------------------------------------===//
+
+def VecInsertOp : CIR_Op<"vec.insert", [Pure,
+  TypesMatchWith<"argument type matches vector element type", "vec", "value",
+                 "$_self.cast<VectorType>().getEltType()">,
+  AllTypesMatch<["result", "vec"]>]> {
+
+  let summary = "Insert one element into a vector object";
+  let description = [{
+    The `cir.vec.insert` operation replaces the element of the given vector at
+    the given index with the given value.  The new vector with the inserted
+    element is returned.
+  }];
+
+  let arguments = (ins CIR_VectorType:$vec, AnyType:$value, CIR_IntType:$index);
+  let results = (outs CIR_VectorType:$result);
+
+  let assemblyFormat = [{
+    $value `,` $vec `[` $index `:` type($index) `]` attr-dict `:` type($vec)
+  }];
+
+  let hasVerifier = 0;
+}
+
 //===----------------------------------------------------------------------===//
 // VecExtractOp
 //===----------------------------------------------------------------------===//
 
 def VecExtractOp : CIR_Op<"vec.extract", [Pure,
-  TypesMatchWith<"type of 'result' matches element type of 'vec'",
-                 "vec", "result",
-                 "$_self.cast<VectorType>().getEltType()">]> {
+  TypesMatchWith<"type of 'result' matches element type of 'vec'", "vec",
+                 "result", "$_self.cast<VectorType>().getEltType()">]> {
 
   let summary = "Extract one element from a vector object";
   let description = [{
@@ -1691,7 +1716,7 @@ def VecExtractOp : CIR_Op<"vec.extract", [Pure,
   let results = (outs CIR_AnyType:$result);
 
   let assemblyFormat = [{
-    $vec `[` $index `:` type($index) `]` type($vec) `->` type($result) attr-dict
+    $vec `[` $index `:` type($index) `]` attr-dict `:` type($vec)
   }];
 
   let hasVerifier = 0;

clang/lib/CIR/CodeGen/CIRGenExpr.cpp

@@ -545,16 +545,18 @@ void CIRGenFunction::buildStoreOfScalar(mlir::Value Value, Address Addr,
                                         bool Volatile, QualType Ty,
                                         LValueBaseInfo BaseInfo, bool isInit,
                                         bool isNontemporal) {
-  if (!CGM.getCodeGenOpts().PreserveVec3Type && Ty->isVectorType() &&
-      Ty->castAs<clang::VectorType>()->getNumElements() == 3)
-    llvm_unreachable("NYI: Special treatment of 3-element vectors");
-
   Value = buildToMemory(Value, Ty);
 
   if (Ty->isAtomicType()) {
     llvm_unreachable("NYI");
   }
 
+  if (const auto *ClangVecTy = Ty->getAs<clang::VectorType>()) {
+    if (!CGM.getCodeGenOpts().PreserveVec3Type &&
+        ClangVecTy->getNumElements() == 3)
+      llvm_unreachable("NYI: Special treatment of 3-element vector store");
+  }
+
   // Update the alloca with more info on initialization.
   assert(Addr.getPointer() && "expected pointer to exist");
   auto SrcAlloca =
@@ -622,6 +624,18 @@ RValue CIRGenFunction::buildLoadOfBitfieldLValue(LValue LV,
 }
 
 void CIRGenFunction::buildStoreThroughLValue(RValue Src, LValue Dst) {
+  if (!Dst.isSimple()) {
+    if (Dst.isVectorElt()) {
+      // Read/modify/write the vector, inserting the new element
+      mlir::Location loc = Dst.getVectorPointer().getLoc();
+      mlir::Value Vector = builder.createLoad(loc, Dst.getVectorAddress());
+      Vector = builder.create<mlir::cir::VecInsertOp>(
+          loc, Vector, Src.getScalarVal(), Dst.getVectorIdx());
+      builder.createStore(loc, Vector, Dst.getVectorAddress());
+      return;
+    }
+    llvm_unreachable("NYI: non-simple store through lvalue");
+  }
   assert(Dst.isSimple() && "only implemented simple");
 
   // There's special magic for assigning into an ARC-qualified l-value.
@@ -1387,7 +1401,10 @@ LValue CIRGenFunction::buildArraySubscriptExpr(const ArraySubscriptExpr *E,
   // with this subscript.
   if (E->getBase()->getType()->isVectorType() &&
       !isa<ExtVectorElementExpr>(E->getBase())) {
-    llvm_unreachable("vector subscript is NYI");
+    LValue LHS = buildLValue(E->getBase());
+    auto Index = EmitIdxAfterBase(/*Promote=*/false);
+    return LValue::MakeVectorElt(LHS.getAddress(), Index,
+                                 E->getBase()->getType(), LHS.getBaseInfo());
   }
 
   // All the other cases basically behave like simple offsetting.
@@ -2370,16 +2387,18 @@ mlir::Value CIRGenFunction::buildLoadOfScalar(Address Addr, bool Volatile,
                                               QualType Ty, mlir::Location Loc,
                                               LValueBaseInfo BaseInfo,
                                               bool isNontemporal) {
-  if (!CGM.getCodeGenOpts().PreserveVec3Type && Ty->isVectorType() &&
-      Ty->castAs<clang::VectorType>()->getNumElements() == 3)
-    llvm_unreachable("NYI: Special treatment of 3-element vectors");
-
   // Atomic operations have to be done on integral types
   LValue AtomicLValue = LValue::makeAddr(Addr, Ty, getContext(), BaseInfo);
   if (Ty->isAtomicType() || LValueIsSuitableForInlineAtomic(AtomicLValue)) {
     llvm_unreachable("NYI");
   }
 
+  if (const auto *ClangVecTy = Ty->getAs<clang::VectorType>()) {
+    if (!CGM.getCodeGenOpts().PreserveVec3Type &&
+        ClangVecTy->getNumElements() == 3)
+      llvm_unreachable("NYI: Special treatment of 3-element vector load");
+  }
+
   mlir::cir::LoadOp Load = builder.create<mlir::cir::LoadOp>(
       Loc, Addr.getElementType(), Addr.getPointer());
 

clang/lib/CIR/CodeGen/CIRGenExprScalar.cpp

@@ -1646,7 +1646,7 @@ mlir::Value ScalarExprEmitter::VisitUnaryLNot(const UnaryOperator *E) {
   if (dstTy.isa<mlir::cir::BoolType>())
     return boolVal;
 
-  llvm_unreachable("destination type for negation unary operator is NYI");
+  llvm_unreachable("destination type for logical-not unary operator is NYI");
 }
 
 // Conversion from bool, integral, or floating-point to integral or

clang/lib/CIR/CodeGen/CIRGenValue.h

@@ -207,6 +207,7 @@ class LValue {
   unsigned Alignment;
   mlir::Value V;
   mlir::Type ElementType;
+  mlir::Value VectorIdx; // Index for vector subscript
   LValueBaseInfo BaseInfo;
   const CIRGenBitFieldInfo *BitFieldInfo{0};
 
@@ -301,6 +302,31 @@ class LValue {
   const clang::Qualifiers &getQuals() const { return Quals; }
   clang::Qualifiers &getQuals() { return Quals; }
 
+  // vector element lvalue
+  Address getVectorAddress() const {
+    return Address(getVectorPointer(), ElementType, getAlignment());
+  }
+  mlir::Value getVectorPointer() const {
+    assert(isVectorElt());
+    return V;
+  }
+  mlir::Value getVectorIdx() const {
+    assert(isVectorElt());
+    return VectorIdx;
+  }
+
+  static LValue MakeVectorElt(Address vecAddress, mlir::Value Index,
+                              clang::QualType type, LValueBaseInfo BaseInfo) {
+    LValue R;
+    R.LVType = VectorElt;
+    R.V = vecAddress.getPointer();
+    R.ElementType = vecAddress.getElementType();
+    R.VectorIdx = Index;
+    R.Initialize(type, type.getQualifiers(), vecAddress.getAlignment(),
+                 BaseInfo);
+    return R;
+  }
+
   // bitfield lvalue
   Address getBitFieldAddress() const {
     return Address(getBitFieldPointer(), ElementType, getAlignment());