Stash

Author: monthdev

clang/include/clang/CIR/MissingFeatures.h

@@ -321,7 +321,7 @@ struct MissingFeatures {
   static bool ifOp() { return false; }
   static bool invokeOp() { return false; }
   static bool labelOp() { return false; }
-  static bool ptrDiffOp() { return false; }
+  static bool ptrDiffOp() { return true; }
   static bool ptrStrideOp() { return false; }
   static bool switchOp() { return false; }
   static bool throwOp() { return false; }

clang/lib/CIR/CodeGen/CIRGenExprScalar.cpp

@@ -1735,8 +1735,7 @@ mlir::Value ScalarExprEmitter::emitSub(const BinOpInfo &ops) {
   //
   // See more in `EmitSub` in CGExprScalar.cpp.
   assert(!cir::MissingFeatures::ptrDiffOp());
-  cgf.cgm.errorNYI("ptrdiff");
-  return {};
+  return builder.create<cir::PtrDiffOp>(cgf.getLoc(ops.loc), cgf.PtrDiffTy, ops.lhs, ops.rhs);
 }
 
 mlir::Value ScalarExprEmitter::emitShl(const BinOpInfo &ops) {

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

@@ -1499,6 +1499,40 @@ mlir::LogicalResult CIRToLLVMConstantOpLowering::matchAndRewrite(
   return mlir::success();
 }
 
+mlir::LogicalResult CIRToLLVMPtrDiffOpLowering::matchAndRewrite(
+    cir::PtrDiffOp op, OpAdaptor adaptor,
+    mlir::ConversionPatternRewriter &rewriter) const {
+  auto dstTy = mlir::cast<cir::IntType>(op.getType());
+  auto llvmDstTy = getTypeConverter()->convertType(dstTy);
+
+  auto lhs = rewriter.create<mlir::LLVM::PtrToIntOp>(op.getLoc(), llvmDstTy,
+                                                     adaptor.getLhs());
+  auto rhs = rewriter.create<mlir::LLVM::PtrToIntOp>(op.getLoc(), llvmDstTy,
+                                                     adaptor.getRhs());
+
+  auto diff =
+      rewriter.create<mlir::LLVM::SubOp>(op.getLoc(), llvmDstTy, lhs, rhs);
+
+  cir::PointerType ptrTy = op.getLhs().getType();
+  auto typeSize = getTypeSize(ptrTy.getPointee(), *op);
+
+  // Avoid silly division by 1.
+  auto resultVal = diff.getResult();
+  if (typeSize != 1) {
+    auto typeSizeVal = rewriter.create<mlir::LLVM::ConstantOp>(
+        op.getLoc(), llvmDstTy, typeSize);
+
+    if (dstTy.isUnsigned())
+      resultVal =
+          rewriter.create<mlir::LLVM::UDivOp>(op.getLoc(), diff, typeSizeVal);
+    else
+      resultVal =
+          rewriter.create<mlir::LLVM::SDivOp>(op.getLoc(), diff, typeSizeVal);
+  }
+  rewriter.replaceOp(op, resultVal);
+  return mlir::success();
+}
+
 mlir::LogicalResult CIRToLLVMExpectOpLowering::matchAndRewrite(
     cir::ExpectOp op, OpAdaptor adaptor,
     mlir::ConversionPatternRewriter &rewriter) const {

clang/test/CIR/CodeGen/ptrdiff.c

@@ -16,3 +16,17 @@ int addrcmp(const void* a, const void* b) {
   // LLVM: trunc i64 %[[SUB]] to i32
   return *(const void**)a - *(const void**)b;
 }
+
+unsigned long long test_ptr_diff(int *a, int* b) {
+  // CIR-LABEL: test_ptr_diff
+  // CIR: %[[D:.*]] = cir.ptr_diff{{.*}} : !cir.ptr<!s32i> -> !u64i
+  // CIR: cir.return %[[D]] : !u64i
+
+  // LLVM-LABEL: @_Z13test_ptr_diffPiS_
+  // LLVM: %[[IA:.*]] = ptrtoint ptr %{{.*}} to i64
+  // LLVM: %[[IB:.*]] = ptrtoint ptr %{{.*}} to i64
+  // LLVM: %[[SUB:.*]] = sub i64 %[[IA]], %[[IB]]
+  // LLVM: %[[Q:.*]] = sdiv exact i64 %[[SUB]], 4
+  // LLVM: ret i64 %[[Q]]
+  return a - b;
+}

clang/test/CIR/CodeGen/ptrdiff.cpp

@@ -2,22 +2,35 @@
 // RUN: FileCheck --input-file=%t.cir %s
 
 typedef unsigned long size_type;
+
 size_type size(unsigned long *_start, unsigned long *_finish) {
+  // CIR-LABEL: cir.func dso_local @_Z4sizePmS_
+  // CIR: %[[D:.*]] = cir.ptr_diff {{.*}} : !cir.ptr<!u64i> -> !s64i
+  // CIR: %[[U:.*]] = cir.cast integral %[[D]] : !s64i -> !u64i
+  // CIR: cir.return %[[U]] : !u64i
+
+  // LLVM-LABEL: @_Z4sizePmS_
+  // LLVM: ptrtoint ptr {{.*}} to i64
+  // LLVM: ptrtoint ptr {{.*}} to i64
+  // LLVM: %[[SUB:.*]] = sub i64 {{.*}}, {{.*}}
+  // LLVM: %[[DIV:.*]] = sdiv exact i64 %[[SUB]], 8
+  // LLVM: ret i64 %[[DIV]]
   return static_cast<size_type>(_finish - _start);
 }
 
-// CHECK: cir.func dso_local @_Z4sizePmS_(%arg0: !cir.ptr<!u64i>
-// CHECK:   %3 = cir.load{{.*}} %1 : !cir.ptr<!cir.ptr<!u64i>>, !cir.ptr<!u64i>
-// CHECK:   %4 = cir.load{{.*}} %0 : !cir.ptr<!cir.ptr<!u64i>>, !cir.ptr<!u64i>
-// CHECK:   %5 = cir.ptr_diff %3, %4 : !cir.ptr<!u64i> -> !s64i
-// CHECK:   %6 = cir.cast integral %5 : !s64i -> !u64i
-
 long add(char *a, char *b) {
+  // CIR-LABEL: cir.func dso_local @_Z3addPcS_
+  // CIR: %[[D:.*]] = cir.ptr_diff {{.*}} : !cir.ptr<!s8i> -> !s64i
+  // CIR: %[[C1:.*]] = cir.const #cir.int<1> : !s32i
+  // CIR: %[[C1W:.*]] = cir.cast integral %[[C1]] : !s32i -> !s64i
+  // CIR: %[[S:.*]] = cir.binop(add, %[[D]], %[[C1W]]) : !s64i
+  // CIR: cir.return %[[S]] : !s64i
+
+  // LLVM-LABEL: @_Z3addPcS_
+  // LLVM: ptrtoint ptr {{.*}} to i64
+  // LLVM: ptrtoint ptr {{.*}} to i64
+  // LLVM: %[[SUB:.*]] = sub i64 {{.*}}, {{.*}}
+  // LLVM: %[[ADD1:.*]] = add i64 %[[SUB]], 1
+  // LLVM: ret i64 %[[ADD1]]
   return a - b + 1;
 }
-
-// CHECK: cir.func dso_local @_Z3addPcS_(%arg0: !cir.ptr<!s8i>
-//          %5 = cir.ptr_diff %3, %4 : !cir.ptr<!s8i> -> !s64i
-//          %6 = cir.const #cir.int<1> : !s32i
-//          %7 = cir.cast integral %6 : !s32i -> !s64i
-//          %8 = cir.binop(add, %5, %7) : !s64i