[CIR][CIRGen] Support for dereferencing void pointers (#595)

In this PR, we support for dereferencing void pointers as a GNU C
extension. This include two modification:
- In CIRGen, we support to build ReturnStmt with void return type.
- In LowerToLLVM, we support to lower CIR load with void result type to
LLVM.

It's a part of #579, since I would
like to split it to two tasks:
- support pointer arithmetic for function types (#594)
- **support to dereference void pointer (this PR)**

Author: PragmaTwice

clang/lib/CIR/CodeGen/CIRGenExpr.cpp

@@ -2557,9 +2557,18 @@ mlir::Value CIRGenFunction::buildLoadOfScalar(Address Addr, bool Volatile,
     llvm_unreachable("NYI: Special treatment of 3-element vector load");
   }
 
-  mlir::cir::LoadOp Load = builder.create<mlir::cir::LoadOp>(
-      Loc, Addr.getElementType(), Addr.getPointer(), /* deref */ false,
-      Volatile, ::mlir::cir::MemOrderAttr{});
+  auto Ptr = Addr.getPointer();
+  auto ElemTy = Addr.getElementType();
+  if (ElemTy.isa<mlir::cir::VoidType>()) {
+    ElemTy = mlir::cir::IntType::get(builder.getContext(), 8, true);
+    auto ElemPtrTy = mlir::cir::PointerType::get(builder.getContext(), ElemTy);
+    Ptr = builder.create<mlir::cir::CastOp>(Loc, ElemPtrTy,
+                                            mlir::cir::CastKind::bitcast, Ptr);
+  }
+
+  mlir::cir::LoadOp Load =
+      builder.create<mlir::cir::LoadOp>(Loc, ElemTy, Ptr, /* deref */ false,
+                                        Volatile, ::mlir::cir::MemOrderAttr{});
 
   if (isNontemporal) {
     llvm_unreachable("NYI");

clang/lib/CIR/CodeGen/CIRGenStmt.cpp

@@ -487,7 +487,7 @@ mlir::LogicalResult CIRGenFunction::buildReturnStmt(const ReturnStmt &S) {
       // Make sure not to return anything, but evaluate the expression
       // for side effects.
       if (RV) {
-        assert(0 && "not implemented");
+        buildAnyExpr(RV);
       }
     } else if (!RV) {
       // Do nothing (return value is left uninitialized)

clang/test/CIR/CodeGen/pointer-arith-ext.c

@@ -82,9 +82,33 @@ FP f7(FP a, int b) { return a - b; }
 // Similar to f7, just make sure it does not crash.
 FP f7_1(FP a, int b) { return (a -= b); }
 
-// FIXME: add support for the remaining ones.
-// void f8(void *a, int b) { return *(a + b); }
-// void f8_1(void *a, int b) { return a[b]; }
+void f8(void *a, int b) { return *(a + b); }
+// CIR-LABEL: f8
+// CIR: %[[PTR:.*]] = cir.load {{.*}} : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!void>
+// CIR: %[[STRIDE:.*]] = cir.load {{.*}} : !cir.ptr<!s32i>, !s32i
+// CIR: cir.ptr_stride(%[[PTR]] : !cir.ptr<!void>, %[[STRIDE]] : !s32i)
+// CIR: cir.return
+
+// LLVM-LABEL: f8
+// LLVM: %[[PTR:.*]] = load ptr, ptr {{.*}}, align 8
+// LLVM: %[[TOEXT:.*]] = load i32, ptr {{.*}}, align 4
+// LLVM: %[[STRIDE:.*]] = sext i32 %[[TOEXT]] to i64
+// LLVM: getelementptr i8, ptr %[[PTR]], i64 %[[STRIDE]]
+// LLVM: ret void
+
+void f8_1(void *a, int b) { return a[b]; }
+// CIR-LABEL: f8_1
+// CIR: %[[PTR:.*]] = cir.load {{.*}} : !cir.ptr<!cir.ptr<!void>>, !cir.ptr<!void>
+// CIR: %[[STRIDE:.*]] = cir.load {{.*}} : !cir.ptr<!s32i>, !s32i
+// CIR: cir.ptr_stride(%[[PTR]] : !cir.ptr<!void>, %[[STRIDE]] : !s32i)
+// CIR: cir.return
+
+// LLVM-LABEL: f8_1
+// LLVM: %[[PTR:.*]] = load ptr, ptr {{.*}}, align 8
+// LLVM: %[[TOEXT:.*]] = load i32, ptr {{.*}}, align 4
+// LLVM: %[[STRIDE:.*]] = sext i32 %[[TOEXT]] to i64
+// LLVM: getelementptr i8, ptr %[[PTR]], i64 %[[STRIDE]]
+// LLVM: ret void
 
 unsigned char *p(unsigned int x) {
   unsigned char *p;