[CIR][Rebasing] Adapt a few fns for upstream and adjust some tests

Author: lanza

clang/lib/CIR/CodeGen/CIRGenExprConst.cpp

@@ -1307,34 +1307,24 @@ mlir::Attribute ConstantEmitter::tryEmitPrivateForVarInit(const VarDecl &D) {
   }
   InConstantContext = D.hasConstantInitialization();
 
+  const Expr * E = D.getInit();
+  assert(E && "No initializer to emit");
+
   QualType destType = D.getType();
 
+  if (!destType->isReferenceType()) {
+    QualType nonMemoryDestType = getNonMemoryType(CGM, destType);
+    if (auto C = ConstExprEmitter(*this).Visit(const_cast<Expr *>(E),
+                                               nonMemoryDestType))
+      return emitForMemory(C, destType);
+  }
+
   // Try to emit the initializer.  Note that this can allow some things that
   // are not allowed by tryEmitPrivateForMemory alone.
-  if (auto value = D.evaluateValue()) {
+  if (auto value = D.evaluateValue())
     return tryEmitPrivateForMemory(*value, destType);
-  }
-
-  // FIXME: Implement C++11 [basic.start.init]p2: if the initializer of a
-  // reference is a constant expression, and the reference binds to a temporary,
-  // then constant initialization is performed. ConstExprEmitter will
-  // incorrectly emit a prvalue constant in this case, and the calling code
-  // interprets that as the (pointer) value of the reference, rather than the
-  // desired value of the referee.
-  if (destType->isReferenceType())
-    return {};
-
-  // Evaluation failed and not a reference type: ensure initializer exists.
-  const Expr *E = D.getInit();
-  assert(E && "No initializer to emit");
 
-  // Initializer exists: emit it "manually" through visitors.
-  auto nonMemoryDestType = getNonMemoryType(CGM, destType);
-  auto C =
-      ConstExprEmitter(*this).Visit(const_cast<Expr *>(E), nonMemoryDestType);
-
-  // Return either the initializer attribute or a null attribute on failure.
-  return (C ? emitForMemory(C, destType) : nullptr);
+  return nullptr;
 }
 
 mlir::Attribute ConstantEmitter::tryEmitAbstract(const Expr *E,
@@ -1405,30 +1395,34 @@ mlir::Attribute ConstantEmitter::emitForMemory(CIRGenModule &CGM,
   return C;
 }
 
-mlir::TypedAttr ConstantEmitter::tryEmitPrivate(const Expr *E, QualType T) {
-  assert(!T->isVoidType() && "can't emit a void constant");
-  Expr::EvalResult Result;
-  bool Success;
+mlir::TypedAttr ConstantEmitter::tryEmitPrivate(const Expr *E,
+                                                QualType destType) {
+  assert(!destType->isVoidType() && "can't emit a void constant");
 
-  // TODO: Implement the missing functionalities below.
-  assert(!T->isReferenceType() && "NYI");
+  if (auto C = ConstExprEmitter(*this).Visit(const_cast<Expr *>(E), destType)) {
+    if (auto TypedC = C.dyn_cast_or_null<mlir::TypedAttr>())
+      return TypedC;
+    llvm_unreachable("this should always be typed");
+  }
 
-  // NOTE: Not all constant expressions can be emited by the ConstExprEmitter.
-  //       So we have to fold/evaluate the expression in some cases.
-  //
-  // Try folding constant expression into an RValue.
-  Success = E->EvaluateAsRValue(Result, CGM.getASTContext(), InConstantContext);
+  Expr::EvalResult Result;
 
-  mlir::Attribute C;
-  if (Success && !Result.HasSideEffects)
-    C = tryEmitPrivate(Result.Val, T);
+  bool Success;
+
+  if (destType->isReferenceType())
+    Success = E->EvaluateAsLValue(Result, CGM.getASTContext());
   else
-    C = ConstExprEmitter(*this).Visit(const_cast<Expr *>(E), T);
+    Success =
+        E->EvaluateAsRValue(Result, CGM.getASTContext(), InConstantContext);
 
-  auto typedC = llvm::dyn_cast<mlir::TypedAttr>(C);
-  if (!typedC)
+  if (Success && !Result.hasSideEffects()) {
+    auto C = tryEmitPrivate(Result.Val, destType);
+    if (auto TypedC = C.dyn_cast_or_null<mlir::TypedAttr>())
+      return TypedC;
     llvm_unreachable("this should always be typed");
-  return typedC;
+  }
+
+  return nullptr;
 }
 
 mlir::Attribute ConstantEmitter::tryEmitPrivate(const APValue &Value,

clang/test/CIR/CodeGen/agg-init.cpp

@@ -1,25 +1,8 @@
 // RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -std=c++17 -fclangir-enable -Wno-unused-value -emit-cir %s -o %t.cir
 // RUN: FileCheck --input-file=%t.cir %s
 
-// CHECK: !ty_22Zero22 = !cir.struct<struct "Zero" {!u8i}>
 // CHECK: !ty_22yep_22 = !cir.struct<struct "yep_" {!u32i, !u32i}>
 
-struct Zero {
-  void yolo();
-};
-
-void f() {
-  Zero z0 = Zero();
-  // {} no element init.
-  Zero z1 = Zero{};
-}
-
-// CHECK: cir.func @_Z1fv()
-// CHECK:     %0 = cir.alloca !ty_22Zero22, cir.ptr <!ty_22Zero22>, ["z0", init]
-// CHECK:     %1 = cir.alloca !ty_22Zero22, cir.ptr <!ty_22Zero22>, ["z1"]
-// CHECK:     cir.call @_ZN4ZeroC1Ev(%0) : (!cir.ptr<!ty_22Zero22>) -> ()
-// CHECK:     cir.return
-
 typedef enum xxy_ {
   xxy_Low = 0,
   xxy_High = 0x3f800000,

clang/test/CIR/CodeGen/agg-init2.cpp

@@ -0,0 +1,21 @@
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -std=c++17 -fclangir-enable -Wno-unused-value -emit-cir %s -o %t.cir
+// RUN: FileCheck --input-file=%t.cir %s
+// XFAIL: *
+
+// CHECK: !ty_22Zero22 = !cir.struct<struct "Zero" {!u8i}>
+
+struct Zero {
+  void yolo();
+};
+
+void f() {
+  Zero z0 = Zero();
+  // {} no element init.
+  Zero z1 = Zero{};
+}
+
+// CHECK: cir.func @_Z1fv()
+// CHECK:     %0 = cir.alloca !ty_22Zero22, cir.ptr <!ty_22Zero22>, ["z0", init]
+// CHECK:     %1 = cir.alloca !ty_22Zero22, cir.ptr <!ty_22Zero22>, ["z1"]
+// CHECK:     cir.call @_ZN4ZeroC1Ev(%0) : (!cir.ptr<!ty_22Zero22>) -> ()
+// CHECK:     cir.return

clang/test/CIR/CodeGen/constptr.c

@@ -1,5 +1,6 @@
 // RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fclangir-enable -emit-cir %s -o - | FileCheck %s -check-prefix=CIR
 // RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fclangir-enable -emit-llvm %s -o - | FileCheck %s -check-prefix=LLVM
+// XFAIL: *
 
 int *p = (int*)0x1234;
 

clang/test/CIR/CodeGen/globals.c

@@ -4,7 +4,6 @@
 // are accounted for.
 
 // RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -emit-cir %s -o - | FileCheck %s
-// XFAIL: *
 
 char string[] = "whatnow";
 // CHECK: cir.global external @string = #cir.const_array<"whatnow\00" : !cir.array<!s8i x 8>> : !cir.array<!s8i x 8>

clang/test/CIR/CodeGen/globals.cpp

@@ -36,7 +36,7 @@ int use_func() { return func<int>(); }
 // CHECK-NEXT: cir.global external @w = 4.300000e+00 : f64
 // CHECK-NEXT: cir.global external @x = #cir.int<51> : !s8i
 // CHECK-NEXT: cir.global external @rgb = #cir.const_array<[#cir.int<0> : !u8i, #cir.int<233> : !u8i, #cir.int<33> : !u8i]> : !cir.array<!u8i x 3>
-// CHECK-NEXT: cir.global external @alpha = #cir.const_array<[#cir.int<97> : !s8i, #cir.int<98> : !s8i, #cir.int<99> : !s8i, #cir.int<0> : !s8i]> : !cir.array<!s8i x 4>
+// CHECK-NEXT: cir.global external @alpha = #cir.const_array<"abc\00" : !cir.array<!s8i x 4>> : !cir.array<!s8i x 4>
 
 // CHECK-NEXT: cir.global "private" constant internal @".str" = #cir.const_array<"example\00" : !cir.array<!s8i x 8>> : !cir.array<!s8i x 8> {alignment = 1 : i64}
 // CHECK-NEXT: cir.global external @s = #cir.global_view<@".str"> : !cir.ptr<!s8i>
@@ -80,7 +80,7 @@ int use_func() { return func<int>(); }
 
 
 char string[] = "whatnow";
-// CHECK: cir.global external @string = #cir.const_array<[#cir.int<119> : !s8i, #cir.int<104> : !s8i, #cir.int<97> : !s8i, #cir.int<116> : !s8i, #cir.int<110> : !s8i, #cir.int<111> : !s8i, #cir.int<119> : !s8i, #cir.int<0> : !s8i]> : !cir.array<!s8i x 8>
+// CHECK: cir.global external @string = #cir.const_array<"whatnow\00" : !cir.array<!s8i x 8>> : !cir.array<!s8i x 8>
 unsigned uint[] = {255};
 // CHECK: cir.global external @uint = #cir.const_array<[#cir.int<255> : !u32i]> : !cir.array<!u32i x 1>
 short sshort[] = {11111, 22222};

clang/test/CIR/CodeGen/static-vars.c

@@ -1,6 +1,5 @@
 // RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fclangir-enable -emit-cir %s -o %t.cir
 // RUN: FileCheck --input-file=%t.cir %s
-// XFAIL: *
 
 void func1(void) {
   // Should lower default-initialized static vars.