Merge branch 'main' into cir_complex_comma_op

Author: AmrDeveloper

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

@@ -2962,29 +2962,16 @@ def CIR_GetMemberOp : CIR_Op<"get_member"> {
   let arguments = (ins
     Arg<CIR_PointerType, "the address to load from", [MemRead]>:$addr,
     StrAttr:$name,
-    IndexAttr:$index_attr);
+    I64Attr:$index);
 
   let results = (outs Res<CIR_PointerType, "">:$result);
 
   let assemblyFormat = [{
-    $addr `[` $index_attr `]` attr-dict
+    $addr `[` $index `]` attr-dict
     `:` qualified(type($addr)) `->` qualified(type($result))
   }];
 
-  let builders = [
-    OpBuilder<(ins "mlir::Type":$type,
-                   "mlir::Value":$value,
-                   "llvm::StringRef":$name,
-                   "unsigned":$index),
-    [{
-      mlir::APInt fieldIdx(64, index);
-      build($_builder, $_state, type, value, name, fieldIdx);
-    }]>
-  ];
-
   let extraClassDeclaration = [{
-    /// Return the index of the record member being accessed.
-    uint64_t getIndex() { return getIndexAttr().getZExtValue(); }
 
     /// Return the record type pointed by the base pointer.
     cir::PointerType getAddrTy() { return getAddr().getType(); }

clang/lib/CIR/CodeGen/CIRGenBuiltinX86.cpp

@@ -134,6 +134,21 @@ static mlir::Value emitX86ExpandLoad(CIRGenFunction &cgf,
       .getResult();
 }
 
+static mlir::Value emitX86CompressStore(CIRGenFunction &cgf,
+                                        ArrayRef<mlir::Value> ops,
+                                        mlir::Location loc) {
+  auto resultTy = cast<cir::VectorType>(ops[1].getType());
+  mlir::Value ptr = ops[0];
+
+  mlir::Value maskVec = getMaskVecValue(cgf, ops[2], resultTy.getSize(), loc);
+
+  return cgf.getBuilder()
+      .create<cir::LLVMIntrinsicCallOp>(
+          loc, cgf.getBuilder().getStringAttr("masked.compressstore"),
+          cgf.getBuilder().getVoidTy(), mlir::ValueRange{ops[1], ptr, maskVec})
+      .getResult();
+}
+
 static mlir::Value emitX86SExtMask(CIRGenFunction &cgf, mlir::Value op,
                                    mlir::Type dstTy, mlir::Location loc) {
   unsigned numberOfElements = cast<cir::VectorType>(dstTy).getSize();
@@ -645,7 +660,7 @@ mlir::Value CIRGenFunction::emitX86BuiltinExpr(unsigned BuiltinID,
   case X86::BI__builtin_ia32_compressstoreqi128_mask:
   case X86::BI__builtin_ia32_compressstoreqi256_mask:
   case X86::BI__builtin_ia32_compressstoreqi512_mask:
-    llvm_unreachable("compress*_mask NYI");
+    return emitX86CompressStore(*this, Ops, getLoc(E->getExprLoc()));
 
   case X86::BI__builtin_ia32_expanddf128_mask:
   case X86::BI__builtin_ia32_expanddf256_mask:

clang/lib/CIR/CodeGen/CIRGenCXXABI.cpp

@@ -86,6 +86,10 @@ bool CIRGenCXXABI::isZeroInitializable(const MemberPointerType *MPT) {
   return true;
 }
 
+mlir::TypedAttr CIRGenCXXABI::emitNullMemberPointer(clang::QualType T) {
+  llvm_unreachable("NYI");
+}
+
 CharUnits CIRGenCXXABI::getArrayCookieSize(const CXXNewExpr *E) {
   if (!requiresArrayCookie(E))
     return CharUnits::Zero();

clang/lib/CIR/CodeGen/CIRGenCXXABI.h

@@ -292,6 +292,9 @@ class CIRGenCXXABI {
     return true;
   }
 
+  /// Create a null member pointer of the given type.
+  virtual mlir::TypedAttr emitNullMemberPointer(clang::QualType T);
+
   /// Gets the offsets of all the virtual base pointers in a given class.
   virtual std::vector<CharUnits> getVBPtrOffsets(const CXXRecordDecl *RD);
 

clang/lib/CIR/CodeGen/CIRGenExpr.cpp

@@ -1056,7 +1056,8 @@ LValue CIRGenFunction::emitDeclRefLValue(const DeclRefExpr *E) {
       cir::GlobalOp var = CGM.getOrCreateStaticVarDecl(
           *VD, CGM.getCIRLinkageVarDefinition(VD, /*IsConstant=*/false));
       auto getGlobalOp = builder.createGetGlobal(var);
-      auto actualElemTy = llvm::cast<cir::PointerType>(getGlobalOp.getType()).getPointee();
+      auto actualElemTy =
+          llvm::cast<cir::PointerType>(getGlobalOp.getType()).getPointee();
       addr = Address(getGlobalOp, actualElemTy, getContext().getDeclAlign(VD));
     } else {
       llvm_unreachable("DeclRefExpr for decl not entered in LocalDeclMap?");
@@ -2017,7 +2018,15 @@ LValue CIRGenFunction::emitCastLValue(const CastExpr *E) {
     assert(0 && "NYI");
   }
   case CK_LValueBitCast: {
-    assert(0 && "NYI");
+    // This must be a reinterpret_cast (or c-style equivalent).
+    const auto *ce = cast<ExplicitCastExpr>(E);
+
+    CGM.emitExplicitCastExprType(ce, this);
+    LValue LV = emitLValue(E->getSubExpr());
+    Address V = LV.getAddress().withElementType(
+        builder, convertTypeForMem(ce->getTypeAsWritten()->getPointeeType()));
+
+    return makeAddrLValue(V, E->getType(), LV.getBaseInfo(), LV.getTBAAInfo());
   }
   case CK_AddressSpaceConversion: {
     LValue LV = emitLValue(E->getSubExpr());

clang/lib/CIR/CodeGen/CIRGenExprComplex.cpp

@@ -311,8 +311,24 @@ class ComplexExprEmitter : public StmtVisitor<ComplexExprEmitter, mlir::Value> {
   }
 
   mlir::Value
-  VisitAbstractConditionalOperator(const AbstractConditionalOperator *CO) {
-    llvm_unreachable("NYI");
+  VisitAbstractConditionalOperator(const AbstractConditionalOperator *E) {
+    mlir::Value condValue = Visit(E->getCond());
+    mlir::Location loc = CGF.getLoc(E->getSourceRange());
+
+    return Builder
+        .create<cir::TernaryOp>(
+            loc, condValue,
+            /*thenBuilder=*/
+            [&](mlir::OpBuilder &b, mlir::Location loc) {
+              mlir::Value trueValue = Visit(E->getTrueExpr());
+              b.create<cir::YieldOp>(loc, trueValue);
+            },
+            /*elseBuilder=*/
+            [&](mlir::OpBuilder &b, mlir::Location loc) {
+              mlir::Value falseValue = Visit(E->getFalseExpr());
+              b.create<cir::YieldOp>(loc, falseValue);
+            })
+        .getResult();
   }
 
   mlir::Value VisitChooseExpr(ChooseExpr *CE) {
@@ -429,8 +445,13 @@ mlir::Value ComplexExprEmitter::emitCast(CastKind CK, Expr *Op,
   case CK_UserDefinedConversion:
     llvm_unreachable("NYI");
 
-  case CK_LValueBitCast:
-    llvm_unreachable("NYI");
+  case CK_LValueBitCast: {
+    LValue origLV = CGF.emitLValue(Op);
+    Address addr =
+        origLV.getAddress().withElementType(Builder, CGF.convertType(DestTy));
+    LValue destLV = CGF.makeAddrLValue(addr, DestTy);
+    return emitLoadOfLValue(destLV, Op->getExprLoc());
+  }
 
   case CK_LValueToRValueBitCast: {
     LValue SourceLVal = CGF.emitLValue(Op);