[CIR] Implement support for __real__ operator on complex rvalue (#1832)

Implement support for __real__ operator on complex rvalue

Issue #1819

Author: AmrDeveloper

clang/lib/CIR/CodeGen/CIRGenCall.cpp

@@ -723,8 +723,12 @@ RValue CIRGenFunction::emitCall(const CIRGenFunctionInfo &CallInfo,
 
       return RValue::get(Results[0]);
     }
-    default:
-      llvm_unreachable("NYI");
+    case cir::TEK_Complex: {
+      mlir::ResultRange results = theCall->getOpResults();
+      assert(!results.empty() &&
+             "Expected at least one result for complex rvalue");
+      return RValue::getComplex(results[0]);
+    }
     }
   }();
 

clang/lib/CIR/CodeGen/CIRGenExprScalar.cpp

@@ -2054,16 +2054,18 @@ mlir::Value ScalarExprEmitter::VisitReal(const UnaryOperator *E) {
 
   Expr *Op = E->getSubExpr();
   if (Op->getType()->isAnyComplexType()) {
+    mlir::Location Loc = CGF.getLoc(E->getExprLoc());
+
     // If it's an l-value, load through the appropriate subobject l-value.
     // Note that we have to ask E because Op might be an l-value that
     // this won't work for, e.g. an Obj-C property.
     if (E->isGLValue()) {
-      mlir::Location Loc = CGF.getLoc(E->getExprLoc());
       mlir::Value Complex = CGF.emitComplexExpr(Op);
       return CGF.builder.createComplexReal(Loc, Complex);
     }
+
     // Otherwise, calculate and project.
-    llvm_unreachable("NYI");
+    return Builder.createComplexReal(Loc, CGF.emitComplexExpr(Op));
   }
 
   return Visit(Op);

clang/test/CIR/CodeGen/complex.cpp

@@ -61,3 +61,27 @@ void complex_abstract_condition(bool cond, int _Complex a, int _Complex b) {
 // LLVM: [[END_BB]]:
 // LLVM: %[[RESULT_VAL:.*]] = phi { i32, i32 } [ %[[TMP_B]], %[[FALSE_BB]] ], [ %[[TMP_A]], %[[TRUE_BB]] ]
 // LLVM: store { i32, i32 } %[[RESULT_VAL]], ptr %[[RESULT]], align 4
+
+int _Complex complex_real_operator_on_rvalue() {
+  int real = __real__ complex_real_operator_on_rvalue();
+  return {};
+}
+
+// CIR: %[[RET_ADDR:.*]] = cir.alloca !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>, ["__retval"]
+// CIR: %[[REAL_ADDR:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["real", init]
+// CIR: %[[CALL:.*]] = cir.call @_Z31complex_real_operator_on_rvaluev() : () -> !cir.complex<!s32i>
+// CIR: %[[REAL:.*]] = cir.complex.real %[[CALL]] : !cir.complex<!s32i> -> !s32i
+// CIR: cir.store{{.*}} %[[REAL]], %[[REAL_ADDR]] : !s32i, !cir.ptr<!s32i>
+// CIR: %[[RET_COMPLEX:.*]] = cir.const #cir.complex<#cir.int<0> : !s32i, #cir.int<0> : !s32i> : !cir.complex<!s32i>
+// CIR: cir.store{{.*}} %[[RET_COMPLEX]], %[[RET_ADDR]] : !cir.complex<!s32i>, !cir.ptr<!cir.complex<!s32i>>
+// CIR: %[[TMP_RET:.*]] = cir.load %[[RET_ADDR]] : !cir.ptr<!cir.complex<!s32i>>, !cir.complex<!s32i>
+// CIR: cir.return %[[TMP_RET]] : !cir.complex<!s32i>
+
+// LLVM: %[[RET_ADDR:.*]] = alloca { i32, i32 }, i64 1, align 4
+// LLVM: %[[REAL_ADDR:.*]] = alloca i32, i64 1, align 4
+// LLVM: %[[CALL:.*]] = call { i32, i32 } @_Z31complex_real_operator_on_rvaluev()
+// LLVM: %[[REAL:.*]] = extractvalue { i32, i32 } %[[CALL]], 0
+// LLVM: store i32 %[[REAL]], ptr %[[REAL_ADDR]], align 4
+// LLVM: store { i32, i32 } zeroinitializer, ptr %[[RET_ADDR]], align 4
+// LLVM: %[[TMP_RET:.*]] = load { i32, i32 }, ptr %[[RET_ADDR]], align 4
+// LLVM: ret { i32, i32 } %[[TMP_RET]]