feedback

Author: HendrikHuebner

clang/include/clang/CIR/MissingFeatures.h

@@ -271,6 +271,7 @@ struct MissingFeatures {
   static bool insertBuiltinUnpredictable() { return false; }
   static bool instrumentation() { return false; }
   static bool intrinsics() { return false; }
+  static bool intrinsicElementTypeSupport() {return false; }
   static bool isMemcpyEquivalentSpecialMember() { return false; }
   static bool isTrivialCtorOrDtor() { return false; }
   static bool lambdaCaptures() { return false; }

clang/lib/CIR/CodeGen/CIRGenBuiltinX86.cpp

@@ -26,43 +26,32 @@ static int64_t getIntValueFromConstOp(mlir::Value val) {
   return val.getDefiningOp<cir::ConstantOp>().getIntValue().getSExtValue();
 }
 
-static mlir::Value emitClFlush(CIRGenFunction& cgf,
-                               const CallExpr* e,
-                               mlir::Value& op) {
-    mlir::Type voidTy = cir::VoidType::get(&cgf.getMLIRContext());
-    mlir::Location location = cgf.getLoc(e->getExprLoc());
-    return cir::LLVMIntrinsicCallOp::create(
-          cgf.getBuilder(), location, 
-          cgf.getBuilder().getStringAttr("x86.sse2.clflush"), voidTy, op)
+static mlir::Value emitClFlush(CIRGenFunction &cgf, const CallExpr *e,
+                               mlir::Value &op) {
+  mlir::Type voidTy = cir::VoidType::get(&cgf.getMLIRContext());
+  mlir::Location location = cgf.getLoc(e->getExprLoc());
+  return cir::LLVMIntrinsicCallOp::create(
+             cgf.getBuilder(), location,
+             cgf.getBuilder().getStringAttr("x86.sse2.clflush"), voidTy, op)
       .getResult();
 }
 
-static mlir::Value emitPrefetch(CIRGenFunction& cgf,
-                                const CallExpr* e,
-                                mlir::Value& addr,
-                                int64_t hint) {
-  CIRGenBuilderTy& builder = cgf.getBuilder();
-  mlir::Type voidTy = cir::VoidType::get(&cgf.getMLIRContext());
-  mlir::Type sInt32Ty = cir::IntType::get(&cgf.getMLIRContext(), 32, true);
-  mlir::Value address = builder.createPtrBitcast(addr, voidTy);
+static mlir::Value emitPrefetch(CIRGenFunction &cgf, const CallExpr *e,
+                                mlir::Value &addr, int64_t hint) {
+  CIRGenBuilderTy &builder = cgf.getBuilder();
   mlir::Location location = cgf.getLoc(e->getExprLoc());
-  mlir::Value rw =
-      cir::ConstantOp::create(builder, location,
-                              cir::IntAttr::get(sInt32Ty, (hint >> 2) & 0x1));
-  mlir::Value locality =
-      cir::ConstantOp::create(builder, location,
-                              cir::IntAttr::get(sInt32Ty, hint & 0x3));
-  mlir::Value data = cir::ConstantOp::create(builder, location,
-                                             cir::IntAttr::get(sInt32Ty, 1));
+  mlir::Type voidTy = builder.getVoidTy();
+  mlir::Value address = builder.createPtrBitcast(addr, voidTy);
+  mlir::Value rw = builder.getSignedInt(location, (hint >> 2) & 0x1, 32);
+  mlir::Value locality = builder.getSignedInt(location, hint & 0x3, 32);
+  mlir::Value data = builder.getSignedInt(location, 1, 32);
 
   return cir::LLVMIntrinsicCallOp::create(
-             builder, location,
-             builder.getStringAttr("prefetch"), voidTy,
+             builder, location, builder.getStringAttr("prefetch"), voidTy,
              mlir::ValueRange{address, rw, locality, data})
       .getResult();
 }
 
-
 mlir::Value CIRGenFunction::emitX86BuiltinExpr(unsigned builtinID,
                                                const CallExpr *e) {
   if (builtinID == Builtin::BI__builtin_cpu_is) {
@@ -90,14 +79,14 @@ mlir::Value CIRGenFunction::emitX86BuiltinExpr(unsigned builtinID,
 
   // `ICEArguments` is a bitmap indicating whether the argument at the i-th bit
   // is required to be a constant integer expression.
-  unsigned ICEArguments = 0;
+  unsigned iceArguments = 0;
   ASTContext::GetBuiltinTypeError error;
-  getContext().GetBuiltinType(builtinID, error, &ICEArguments);
+  getContext().GetBuiltinType(builtinID, error, &iceArguments);
   assert(error == ASTContext::GE_None && "Error while getting builtin type.");
 
   const unsigned numArgs = e->getNumArgs();
   for (unsigned i = 0; i != numArgs; i++) {
-    ops.push_back(emitScalarOrConstFoldImmArg(ICEArguments, i, e));
+    ops.push_back(emitScalarOrConstFoldImmArg(iceArguments, i, e));
   }
 
   switch (builtinID) {

clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp

@@ -321,14 +321,24 @@ static mlir::LLVM::CallIntrinsicOp replaceOpWithCallLLVMIntrinsicOp(
 }
 
 mlir::LogicalResult CIRToLLVMLLVMIntrinsicCallOpLowering::matchAndRewrite(
-    cir::LLVMIntrinsicCallOp op,
-    OpAdaptor adaptor,
+    cir::LLVMIntrinsicCallOp op, OpAdaptor adaptor,
     mlir::ConversionPatternRewriter &rewriter) const {
   mlir::Type llvmResTy =
       getTypeConverter()->convertType(op->getResultTypes()[0]);
   if (!llvmResTy)
     return op.emitError("expected LLVM result type");
   StringRef name = op.getIntrinsicName();
+  
+  // Some LLVM intrinsics require ElementType attribute to be attached to
+  // the argument of pointer type. That prevents us from generating LLVM IR
+  // because from LLVM dialect, we have LLVM IR like the below which fails
+  // LLVM IR verification.
+  // %3 = call i64 @llvm.aarch64.ldxr.p0(ptr %2)
+  // The expected LLVM IR should be like
+  // %3 = call i64 @llvm.aarch64.ldxr.p0(ptr elementtype(i32) %2)
+  // TODO(cir): MLIR LLVM dialect should handle this part as CIR has no way
+  // to set LLVM IR attribute.
+  assert(!cir::MissingFeatures::intrinsicElementTypeSupport());
   replaceOpWithCallLLVMIntrinsicOp(rewriter, op, "llvm." + name, llvmResTy,
                                    adaptor.getOperands());
   return mlir::success();

clang/test/CIR/CodeGen/X86/sse2-builtins.c

@@ -18,6 +18,6 @@ void test_mm_clflush(void* A) {
   // CIR-LABEL: test_mm_clflush
   // LLVM-LABEL: teh
   _mm_clflush(A);
-  // CIR-CHECK: {{%.*}} = cir.llvm.intrinsic "x86.sse2.clflush" {{%.*}} : (!cir.ptr<!void>) -> !void
+  // CIR-CHECK: {{%.*}} = cir.call_llvm_intrinsic "x86.sse2.clflush" {{%.*}} : (!cir.ptr<!void>) -> !void
   // LLVM-CHECK: call void @llvm.x86.sse2.clflush(ptr {{%.*}})
 }