[Flang] Add a factory class for creating Complex Ops (#1266)

Use the factory class in the FIRBuilder.
Add unit tests for the factory class function and the convert function
of the Complex class.

Reviewed By: clementval, rovka

Differential Revision: https://reviews.llvm.org/D114125

Co-authored-by: Jean Perier <[email protected]>
Co-authored-by: Eric Schweitz <[email protected]>

Author: 3 people

flang/include/flang/Optimizer/Builder/Complex.h

@@ -29,8 +29,8 @@ class Complex {
   enum class Part { Real = 0, Imag = 1 };
 
   /// Get the Complex Type. Determine the type. Do not create MLIR operations.
-  mlir::Type getComplexPartType(mlir::Value cplx);
-  mlir::Type getComplexPartType(mlir::Type complexType);
+  mlir::Type getComplexPartType(mlir::Value cplx) const;
+  mlir::Type getComplexPartType(mlir::Type complexType) const;
 
   /// Complex operation creation. They create MLIR operations.
   mlir::Value createComplex(fir::KindTy kind, mlir::Value real,
@@ -40,6 +40,7 @@ class Complex {
   mlir::Value createComplex(mlir::Type complexType, mlir::Value real,
                             mlir::Value imag);
 
+  /// Returns the Real/Imag part of \p cplx
   mlir::Value extractComplexPart(mlir::Value cplx, bool isImagPart) {
     return isImagPart ? extract<Part::Imag>(cplx) : extract<Part::Real>(cplx);
   }

flang/include/flang/Optimizer/Builder/FIRBuilder.h

@@ -62,7 +62,9 @@ class FirOpBuilder : public mlir::OpBuilder {
   /// The LHS and RHS are not always in agreement in terms of
   /// type. In some cases, the disagreement is between COMPLEX and other scalar
   /// types. In that case, the conversion must insert/extract out of a COMPLEX
-  /// value to have the proper semantics and be strongly typed.
+  /// value to have the proper semantics and be strongly typed. For e.g for
+  /// converting an integer/real to a complex, the real part is filled using
+  /// the integer/real after type conversion and the imaginary part is zero.
   mlir::Value convertWithSemantics(mlir::Location loc, mlir::Type toTy,
                                    mlir::Value val);
 

flang/lib/Optimizer/Builder/Complex.cpp

@@ -12,20 +12,20 @@
 // Complex Factory implementation
 //===----------------------------------------------------------------------===//
 
-mlir::Type fir::factory::Complex::getComplexPartType(mlir::Type complexType) {
+mlir::Type
+fir::factory::Complex::getComplexPartType(mlir::Type complexType) const {
   return builder.getRealType(complexType.cast<fir::ComplexType>().getFKind());
 }
 
-mlir::Type fir::factory::Complex::getComplexPartType(mlir::Value cplx) {
+mlir::Type fir::factory::Complex::getComplexPartType(mlir::Value cplx) const {
   return getComplexPartType(cplx.getType());
 }
 
 mlir::Value fir::factory::Complex::createComplex(fir::KindTy kind,
                                                  mlir::Value real,
                                                  mlir::Value imag) {
   auto complexTy = fir::ComplexType::get(builder.getContext(), kind);
-  mlir::Value und = builder.create<fir::UndefOp>(loc, complexTy);
-  return insert<Part::Imag>(insert<Part::Real>(und, real), imag);
+  return createComplex(complexTy, real, imag);
 }
 
 mlir::Value fir::factory::Complex::createComplex(mlir::Type cplxTy,

flang/unittests/Optimizer/Builder/ComplexTest.cpp

@@ -33,24 +33,26 @@ struct ComplexTest : public testing::Test {
     helper = std::make_unique<fir::factory::Complex>(*firBuilder, loc);
 
     // Init commonly used types
-    realTy = mlir::FloatType::getF32(&context);
-    cType1 = fir::ComplexType::get(&context, 4);
+    realTy1 = mlir::FloatType::getF32(&context);
+    complexTy1 = fir::ComplexType::get(&context, 4);
+    integerTy1 = mlir::IntegerType::get(&context, 32);
 
-    // Init commonly used numbers
-    rOne = firBuilder->createRealConstant(loc, realTy, 1u);
-    rTwo = firBuilder->createRealConstant(loc, realTy, 2u);
-    rThree = firBuilder->createRealConstant(loc, realTy, 3u);
-    rFour = firBuilder->createRealConstant(loc, realTy, 4u);
+    // Create commonly used reals
+    rOne = firBuilder->createRealConstant(loc, realTy1, 1u);
+    rTwo = firBuilder->createRealConstant(loc, realTy1, 2u);
+    rThree = firBuilder->createRealConstant(loc, realTy1, 3u);
+    rFour = firBuilder->createRealConstant(loc, realTy1, 4u);
   }
 
   mlir::MLIRContext context;
   std::unique_ptr<fir::KindMapping> kindMap;
   std::unique_ptr<fir::FirOpBuilder> firBuilder;
   std::unique_ptr<fir::factory::Complex> helper;
 
-  // Commonly used real/complex types
-  mlir::FloatType realTy;
-  fir::ComplexType cType1;
+  // Commonly used real/complex/integer types
+  mlir::FloatType realTy1;
+  fir::ComplexType complexTy1;
+  mlir::IntegerType integerTy1;
 
   // Commonly used real numbers
   mlir::Value rOne;
@@ -60,7 +62,7 @@ struct ComplexTest : public testing::Test {
 };
 
 TEST_F(ComplexTest, verifyTypes) {
-  mlir::Value cVal1 = helper->createComplex(cType1, rOne, rTwo);
+  mlir::Value cVal1 = helper->createComplex(complexTy1, rOne, rTwo);
   mlir::Value cVal2 = helper->createComplex(4, rOne, rTwo);
   EXPECT_TRUE(fir::isa_complex(cVal1.getType()));
   EXPECT_TRUE(fir::isa_complex(cVal2.getType()));
@@ -71,10 +73,10 @@ TEST_F(ComplexTest, verifyTypes) {
   mlir::Value imag1 = helper->extractComplexPart(cVal1, /*isImagPart=*/true);
   mlir::Value real2 = helper->extractComplexPart(cVal2, /*isImagPart=*/false);
   mlir::Value imag2 = helper->extractComplexPart(cVal2, /*isImagPart=*/true);
-  EXPECT_EQ(realTy, real1.getType());
-  EXPECT_EQ(realTy, imag1.getType());
-  EXPECT_EQ(realTy, real2.getType());
-  EXPECT_EQ(realTy, imag2.getType());
+  EXPECT_EQ(realTy1, real1.getType());
+  EXPECT_EQ(realTy1, imag1.getType());
+  EXPECT_EQ(realTy1, real2.getType());
+  EXPECT_EQ(realTy1, imag2.getType());
 
   mlir::Value cVal3 =
       helper->insertComplexPart(cVal1, rThree, /*isImagPart=*/false);
@@ -83,3 +85,16 @@ TEST_F(ComplexTest, verifyTypes) {
   EXPECT_TRUE(fir::isa_complex(cVal4.getType()));
   EXPECT_TRUE(fir::isa_real(helper->getComplexPartType(cVal4)));
 }
+
+TEST_F(ComplexTest, verifyConvertWithSemantics) {
+  auto loc = firBuilder->getUnknownLoc();
+  rOne = firBuilder->createRealConstant(loc, realTy1, 1u);
+  // Convert real to complex
+  mlir::Value v1 = firBuilder->convertWithSemantics(loc, complexTy1, rOne);
+  EXPECT_TRUE(fir::isa_complex(v1.getType()));
+
+  // Convert complex to integer
+  mlir::Value v2 = firBuilder->convertWithSemantics(loc, integerTy1, v1);
+  EXPECT_TRUE(v2.getType().isa<mlir::IntegerType>());
+  EXPECT_TRUE(mlir::dyn_cast<fir::ConvertOp>(v2.getDefiningOp()));
+}