Split cir.complex.extract into cir.complex.real and cir.complex.imag

Author: Lancern

clang/include/clang/CIR/Dialect/IR/CIROps.td

@@ -993,45 +993,54 @@ def CmpOp : CIR_Op<"cmp", [Pure, SameTypeOperands]> {
 }
 
 //===----------------------------------------------------------------------===//
-// ComplexExtractOp
+// ComplexRealOp and ComplexImagOp
 //===----------------------------------------------------------------------===//
 
-def ComplexComponent_Real : I32EnumAttrCase<"real", 1>;
-def ComplexComponent_Imag : I32EnumAttrCase<"imag", 2>;
+def ComplexRealOp : CIR_Op<"complex.real", [Pure]> {
+  let summary = "Extract the real part of a complex value";
+  let description = [{
+    `cir.complex.real` operation takes an operand of complex type and returns
+    the real part of it.
 
-def ComplexComponent : I32EnumAttr<
-    "ComplexComponent", "complex number component",
-    [ComplexComponent_Real, ComplexComponent_Imag]> {
-  let cppNamespace = "::mlir::cir";
+    Example:
+
+    ```mlir
+    !complex = !cir.complex<!cir.float>
+    %0 = cir.const(#cir.complex<#cir.fp<1.0>, #cir.fp<2.0>> : !complex) : !complex
+    %1 = cir.complex.real(%0 : !complex) : !cir.float
+    ```
+  }];
+
+  let results = (outs CIR_AnyType:$result);
+  let arguments = (ins CIR_ComplexType:$operand);
+
+  let assemblyFormat = [{
+    `(` $operand `:` qualified(type($operand)) `)` `:` type($result) attr-dict
+  }];
+
+  let hasVerifier = 1;
 }
 
-def ComplexExtractOp : CIR_Op<"complex.extract", [Pure]> {
-  let summary = "Extract a specified part of a complex number.";
+def ComplexImagOp : CIR_Op<"complex.imag", [Pure]> {
+  let summary = "Extract the imaginary part of a complex value";
   let description = [{
-    `cir.complex.extract` operation reads a component of the operand complex
-    number value.
-
-    The parameter `$component` specifies which component to extract. If it is
-    `real`, the real part of the complex number will be extracted. If it is
-    `imag`, the imaginary part of the complex number will be extracted.
+    `cir.complex.imag` operation takes an operand of complex type and returns
+    the imaginary part of it.
 
     Example:
 
     ```mlir
-    !fcmp = !cir.complex<!cir.float>
-    %0 = cir.const(#cir.complex<#cir.fp<1.0>, #cir.fp<2.0>> : !fcmp) : !fcmp
-    %1 = cir.complex.extract(real, %0 : !fcmp) : !cir.float
-    %2 = cir.complex.extract(imag, %0 : !fcmp) : !cir.float
+    !complex = !cir.complex<!cir.float>
+    %0 = cir.const(#cir.complex<#cir.fp<1.0>, #cir.fp<2.0>> : !complex) : !complex
+    %1 = cir.complex.imag(%0 : !complex) : !cir.float
     ```
   }];
 
   let results = (outs CIR_AnyType:$result);
-  let arguments = (ins Arg<ComplexComponent, "component to extract">:$component,
-                       CIR_ComplexType:$operand);
+  let arguments = (ins CIR_ComplexType:$operand);
 
   let assemblyFormat = [{
-    `(` $component `,` $operand `:` qualified(type($operand)) `)`
-    `:` type($result) attr-dict
+    `(` $operand `:` qualified(type($operand)) `)` `:` type($result) attr-dict
   }];
 
   let hasVerifier = 1;

clang/lib/CIR/CodeGen/CIRGenBuilder.h

@@ -845,13 +845,16 @@ class CIRGenBuilderTy : public CIRBaseBuilderTy {
     return createNot(createPtrToBoolCast(ptr));
   }
 
-  mlir::Value createComplexExtract(mlir::Location loc,
-                                   mlir::cir::ComplexComponent component,
-                                   mlir::Value operand) {
+  mlir::Value createComplexReal(mlir::Location loc, mlir::Value operand) {
     auto operandComplexTy = operand.getType().cast<mlir::cir::ComplexType>();
     auto resultTy = operandComplexTy.getElementTy();
-    return create<mlir::cir::ComplexExtractOp>(loc, resultTy, component,
-                                               operand);
+    return create<mlir::cir::ComplexRealOp>(loc, resultTy, operand);
+  }
+
+  mlir::Value createComplexImag(mlir::Location loc, mlir::Value operand) {
+    auto operandComplexTy = operand.getType().cast<mlir::cir::ComplexType>();
+    auto resultTy = operandComplexTy.getElementTy();
+    return create<mlir::cir::ComplexImagOp>(loc, resultTy, operand);
   }
 
   mlir::Value createComplexIsZero(mlir::Location loc, mlir::Value operand) {

clang/lib/CIR/CodeGen/CIRGenExprScalar.cpp

@@ -1659,8 +1659,7 @@ mlir::Value ScalarExprEmitter::VisitCastExpr(CastExpr *CE) {
   case CK_FloatingComplexToReal:
   case CK_IntegralComplexToReal: {
     auto Src = Visit(const_cast<Expr *>(E));
-    return Builder.createComplexExtract(CGF.getLoc(CE->getSourceRange()),
-                                        mlir::cir::ComplexComponent::real, Src);
+    return Builder.createComplexReal(CGF.getLoc(CE->getSourceRange()), Src);
   }
   case CK_FloatingComplexToBoolean:
   case CK_IntegralComplexToBoolean: {

clang/lib/CIR/Dialect/IR/CIRDialect.cpp

@@ -523,13 +523,21 @@ LogicalResult CastOp::verify() {
 }
 
 //===----------------------------------------------------------------------===//
-// ComplexExtractOp
+// ComplexRealOp and ComplexImagOp
 //===----------------------------------------------------------------------===//
 
-LogicalResult ComplexExtractOp::verify() {
+LogicalResult ComplexRealOp::verify() {
   if (getType() != getOperand().getType().getElementTy()) {
-    emitOpError()
-        << "cir.complex.extract result type does not match operand type";
+    emitOpError() << "cir.complex.real result type does not match operand type";
+    return failure();
+  }
+
+  return success();
+}
+
+LogicalResult ComplexImagOp::verify() {
+  if (getType() != getOperand().getType().getElementTy()) {
+    emitOpError() << "cir.complex.imag result type does not match operand type";
     return failure();
   }
 

clang/test/CIR/CodeGen/complex.c

@@ -54,7 +54,7 @@ float complex_to_element(float _Complex x) {
 }
 
 // CHECK: cir.func @complex_to_element(%{{.+}}: !cir.complex<!cir.float> loc({{.+}})) -> !cir.float
-// CHECK:   %{{.+}} = cir.complex.extract(real, %{{.+}} : !cir.complex<!cir.float>) : !cir.float
+// CHECK:   %{{.+}} = cir.complex.real(%{{.+}} : !cir.complex<!cir.float>) : !cir.float
 // CHECK: }
 
 _Bool complex_to_bool(float _Complex x) {