Fix uninitialized new operator (#298)

* Fix uninitialized new operator

* Fix

* test

Author: ivanradanov

tools/cgeist/Lib/clang-mlir.cc

@@ -1288,9 +1288,6 @@ ValueCategory MLIRScanner::VisitCXXNewExpr(clang::CXXNewExpr *expr) {
     auto shape = std::vector<int64_t>(mt.getShape());
     mlir::Value args[1] = {count};
     arrayCons = alloc = builder.create<mlir::memref::AllocOp>(loc, mt, args);
-    if (expr->hasInitializer() && isa<InitListExpr>(expr->getInitializer()))
-      (void)InitializeValueByInitListExpr(alloc, expr->getInitializer());
-
   } else {
     auto typeSize = getTypeSize(loc, expr->getAllocatedType());
     mlir::Value arg = builder.create<arith::MulIOp>(loc, typeSize, count);
@@ -1306,11 +1303,20 @@ ValueCategory MLIRScanner::VisitCXXNewExpr(clang::CXXNewExpr *expr) {
           alloc);
   }
   assert(alloc);
-
-  if (expr->getConstructExpr()) {
-    VisitConstructCommon(
-        const_cast<CXXConstructExpr *>(expr->getConstructExpr()),
-        /*name*/ nullptr, /*memtype*/ 0, arrayCons, count);
+  if (expr->hasInitializer()) {
+    auto init = expr->getInitializer();
+    if (isa<InitListExpr>(init)) {
+      (void)InitializeValueByInitListExpr(alloc, init);
+    } else if (isa<CXXConstructExpr>(init)) {
+      assert(arrayCons);
+      VisitConstructCommon(
+          const_cast<CXXConstructExpr *>(expr->getConstructExpr()),
+          /*name*/ nullptr, /*memtype*/ 0, arrayCons, count);
+    } else {
+      ValueCategory val = Visit(init);
+      ValueCategory(alloc, /* isReference */ true)
+          .store(loc, builder, val, /* isArray */ false);
+    }
   }
   return ValueCategory(alloc, /*isRefererence*/ false);
 }

tools/cgeist/Test/Verification/new.cpp

@@ -1,6 +1,7 @@
 // RUN: cgeist %s %stdinclude --function=* -S | FileCheck %s
 
 #include <stdio.h>
+#include <new>
 
 struct A {
   float x, y;
@@ -18,3 +19,72 @@ int main(int argc, char const *argv[]) {
   f(a);
   return 0;
 }
+
+extern "C" char *malloc(int asd);
+
+class SimStream {
+public:
+  int n;
+  SimStream(int _n) {
+    n = _n;
+  }
+};
+
+int bar() {
+  // CHECK: func.func @_Z3barv() -> i32 attributes {llvm.linkage = #llvm.linkage<external>} {
+  // CHECK-NEXT:    %[[two:.*]] = arith.constant 2 : i32
+  // CHECK-NEXT:    return %[[two:.*]] : i32
+  SimStream a(2);
+  return a.n;
+}
+
+SimStream *baz() {
+  // CHECK:  func.func @_Z3bazv()
+  // CHECK-NEXT:    %[[thirty:.*]] = arith.constant 30 : i32
+  // CHECK-NEXT:    %[[alloc:.*]] = memref.alloc() : memref<1x1xi32>
+  // CHECK-NEXT:    %[[cast:.*]] = memref.cast %[[alloc]] : memref<1x1xi32> to memref<?x1xi32>
+  // CHECK-NEXT:    affine.store %[[thirty]], %[[alloc]][0, 0] : memref<1x1xi32>
+  // CHECK-NEXT:    return %[[cast]] : memref<?x1xi32>
+  SimStream *b = new SimStream(30);
+  return b;
+}
+
+int *bat() {
+  // CHECK:  func.func @_Z3batv()
+  // CHECK-NEXT:    %[[alloc:.*]] = memref.alloc() : memref<10xi32>
+  // CHECK-NEXT:    %[[cast:.*]] = memref.cast %[[alloc]] : memref<10xi32> to memref<?xi32>
+  // CHECK-NEXT:    return %[[cast]] : memref<?xi32>
+  int *b = new int[10];
+  return b;
+}
+
+int *baf() {
+  // CHECK:  func.func @_Z3bafv()
+  // CHECK-DAG:    %[[three:.*]] = arith.constant 3 : i32
+  // CHECK-DAG:    %[[two:.*]] = arith.constant 2 : i32
+  // CHECK-DAG:    %[[one:.*]] = arith.constant 1 : i32
+  // CHECK-NEXT:    %[[alloc:.*]] = memref.alloc() : memref<3xi32>
+  // CHECK-NEXT:    %[[cast:.*]] = memref.cast %[[alloc]] : memref<3xi32> to memref<?xi32>
+  // CHECK-DAG:    affine.store %[[one]], %alloc[0] : memref<3xi32>
+  // CHECK-DAG:    affine.store %[[two]], %alloc[1] : memref<3xi32>
+  // CHECK-DAG:    affine.store %[[three]], %alloc[2] : memref<3xi32>
+  // CHECK-NEXT:    return %[[cast]] : memref<?xi32>
+  int *b = new int[3] {1, 2, 3};
+  return b;
+}
+
+int foo() {
+  // CHECK:  func.func @_Z3foov()
+  // CHECK-DAG:    %[[one:.*]] = arith.constant 1 : i32
+  // CHECK-DAG:    %[[alloc:.*]] = memref.alloc() : memref<1xi32>
+  // CHECK-NEXT:    %[[v0:.*]] = "polygeist.memref2pointer"(%[[alloc]]) : (memref<1xi32>) -> !llvm.ptr<i8>
+  // CHECK-NEXT:    %[[v1:.*]] = llvm.bitcast %[[v0]] : !llvm.ptr<i8> to !llvm.ptr<i32>
+  // CHECK-NEXT:    llvm.store %[[one]], %[[v1]] : !llvm.ptr<i32>
+  // CHECK-NEXT:    %[[v2:.*]] = affine.load %[[alloc]][0] : memref<1xi32>
+  // CHECK-NEXT:    return %[[v2]] : i32
+  int e = 1;
+  int * __new_start((int *)malloc(sizeof(int)));
+  ::new((void*)__new_start) int(e);
+  return (int) __new_start[0];
+}
+