diff --git a/mlir/lib/Conversion/ComplexToLibm/ComplexToLibm.cpp b/mlir/lib/Conversion/ComplexToLibm/ComplexToLibm.cpp
--- a/mlir/lib/Conversion/ComplexToLibm/ComplexToLibm.cpp
+++ b/mlir/lib/Conversion/ComplexToLibm/ComplexToLibm.cpp
@@ -18,12 +18,14 @@
 namespace {
 // Pattern to convert scalar complex operations to calls to libm functions.
 // Additionally the libm function signatures are declared.
-template <typename Op>
+template <typename Op, typename FuncResolver>
 struct ScalarOpToLibmCall : public OpRewritePattern<Op> {
 public:
   using OpRewritePattern<Op>::OpRewritePattern;
-  ScalarOpToLibmCall<Op>(MLIRContext *context, StringRef floatFunc,
-                         StringRef doubleFunc, PatternBenefit benefit)
+  ScalarOpToLibmCall<Op, FuncResolver>(MLIRContext *context,
+                                       StringRef floatFunc,
+                                       StringRef doubleFunc,
+                                       PatternBenefit benefit)
       : OpRewritePattern<Op>(context, benefit), floatFunc(floatFunc),
         doubleFunc(doubleFunc){};
 
@@ -32,20 +34,41 @@
 private:
   std::string floatFunc, doubleFunc;
 };
+
+// Functor to resolve the function name corresponding to the given complex type.
+struct ComplexTypeFuncResolver {
+  std::string operator()(Type type, std::string doubleFunc,
+                         std::string floatFunc) const {
+    auto complexType = type.cast<ComplexType>();
+    auto elementType = complexType.getElementType();
+    if (!elementType.isa<Float32Type, Float64Type>())
+      return nullptr;
+
+    return elementType.getIntOrFloatBitWidth() == 64 ? doubleFunc : floatFunc;
+  }
+};
+
+// Functor to resolve the function name corresponding to the given float type.
+struct FloatTypeFuncResolver {
+  std::string operator()(Type type, std::string doubleFunc,
+                         std::string floatFunc) const {
+    auto elementType = type.cast<FloatType>();
+    if (!elementType.isa<Float32Type, Float64Type>())
+      return nullptr;
+
+    return elementType.getIntOrFloatBitWidth() == 64 ? doubleFunc : floatFunc;
+  }
+};
 } // namespace
 
-template <typename Op>
-LogicalResult
-ScalarOpToLibmCall<Op>::matchAndRewrite(Op op,
-                                        PatternRewriter &rewriter) const {
+template <typename Op, typename FuncResolver>
+LogicalResult ScalarOpToLibmCall<Op, FuncResolver>::matchAndRewrite(
+    Op op, PatternRewriter &rewriter) const {
   auto module = SymbolTable::getNearestSymbolTable(op);
-  auto type = op.getType().template cast<ComplexType>();
-  Type elementType = type.getElementType();
-  if (!elementType.isa<Float32Type, Float64Type>())
+  auto name = FuncResolver()(op.getType(), doubleFunc, floatFunc);
+  if (name.empty())
     return failure();
 
-  auto name =
-      elementType.getIntOrFloatBitWidth() == 64 ? doubleFunc : floatFunc;
   auto opFunc = dyn_cast_or_null<SymbolOpInterface>(
       SymbolTable::lookupSymbolIn(module, name));
   // Forward declare function if it hasn't already been
@@ -60,25 +83,28 @@
   }
   assert(isa<FunctionOpInterface>(SymbolTable::lookupSymbolIn(module, name)));
 
-  rewriter.replaceOpWithNewOp<func::CallOp>(op, name, type, op->getOperands());
+  rewriter.replaceOpWithNewOp<func::CallOp>(op, name, op.getType(),
+                                            op->getOperands());
 
   return success();
 }
 
 void mlir::populateComplexToLibmConversionPatterns(RewritePatternSet &patterns,
                                                    PatternBenefit benefit) {
-  patterns.add<ScalarOpToLibmCall<complex::PowOp>>(patterns.getContext(),
-                                                   "cpowf", "cpow", benefit);
-  patterns.add<ScalarOpToLibmCall<complex::SqrtOp>>(patterns.getContext(),
-                                                    "csqrtf", "csqrt", benefit);
-  patterns.add<ScalarOpToLibmCall<complex::TanhOp>>(patterns.getContext(),
-                                                    "ctanhf", "ctanh", benefit);
-  patterns.add<ScalarOpToLibmCall<complex::CosOp>>(patterns.getContext(),
-                                                   "ccosf", "ccos", benefit);
-  patterns.add<ScalarOpToLibmCall<complex::SinOp>>(patterns.getContext(),
-                                                   "csinf", "csin", benefit);
-  patterns.add<ScalarOpToLibmCall<complex::ConjOp>>(patterns.getContext(),
-                                                    "conjf", "conj", benefit);
+  patterns.add<ScalarOpToLibmCall<complex::PowOp, ComplexTypeFuncResolver>>(
+      patterns.getContext(), "cpowf", "cpow", benefit);
+  patterns.add<ScalarOpToLibmCall<complex::SqrtOp, ComplexTypeFuncResolver>>(
+      patterns.getContext(), "csqrtf", "csqrt", benefit);
+  patterns.add<ScalarOpToLibmCall<complex::TanhOp, ComplexTypeFuncResolver>>(
+      patterns.getContext(), "ctanhf", "ctanh", benefit);
+  patterns.add<ScalarOpToLibmCall<complex::CosOp, ComplexTypeFuncResolver>>(
+      patterns.getContext(), "ccosf", "ccos", benefit);
+  patterns.add<ScalarOpToLibmCall<complex::SinOp, ComplexTypeFuncResolver>>(
+      patterns.getContext(), "csinf", "csin", benefit);
+  patterns.add<ScalarOpToLibmCall<complex::ConjOp, ComplexTypeFuncResolver>>(
+      patterns.getContext(), "conjf", "conj", benefit);
+  patterns.add<ScalarOpToLibmCall<complex::AbsOp, FloatTypeFuncResolver>>(
+      patterns.getContext(), "cabsf", "cabs", benefit);
 }
 
 namespace {
@@ -96,7 +122,8 @@
 
   ConversionTarget target(getContext());
   target.addLegalDialect<func::FuncDialect>();
-  target.addIllegalOp<complex::PowOp, complex::SqrtOp, complex::TanhOp>();
+  target.addIllegalOp<complex::PowOp, complex::SqrtOp, complex::TanhOp,
+                      complex::AbsOp>();
   if (failed(applyPartialConversion(module, target, std::move(patterns))))
     signalPassFailure();
 }
diff --git a/mlir/test/Conversion/ComplexToLibm/convert-to-libm.mlir b/mlir/test/Conversion/ComplexToLibm/convert-to-libm.mlir
--- a/mlir/test/Conversion/ComplexToLibm/convert-to-libm.mlir
+++ b/mlir/test/Conversion/ComplexToLibm/convert-to-libm.mlir
@@ -9,6 +9,7 @@
 // CHECK-DAG: @ccos(complex<f64>) -> complex<f64>
 // CHECK-DAG: @csin(complex<f64>) -> complex<f64>
 // CHECK-DAG: @conj(complex<f64>) -> complex<f64>
+// CHECK-DAG: @cabs(complex<f64>) -> f64
 
 // CHECK-LABEL: func @cpow_caller
 // CHECK-SAME: %[[FLOAT:.*]]: complex<f32>
@@ -80,4 +81,16 @@
   %double_result = complex.conj %double : complex<f64>
   // CHECK: return %[[FLOAT_RESULT]], %[[DOUBLE_RESULT]]
   return %float_result, %double_result : complex<f32>, complex<f64>
+}
+
+// CHECK-LABEL: func @cabs_caller
+// CHECK-SAME: %[[FLOAT:.*]]: complex<f32>
+// CHECK-SAME: %[[DOUBLE:.*]]: complex<f64>
+func.func @cabs_caller(%float: complex<f32>, %double: complex<f64>) -> (f32, f64)  {
+  // CHECK: %[[FLOAT_RESULT:.*]] = call @cabsf(%[[FLOAT]])
+  %float_result = complex.abs %float : complex<f32>
+  // CHECK: %[[DOUBLE_RESULT:.*]] = call @cabs(%[[DOUBLE]])
+  %double_result = complex.abs %double : complex<f64>
+  // CHECK: return %[[FLOAT_RESULT]], %[[DOUBLE_RESULT]]
+  return %float_result, %double_result : f32, f64
 }
\ No newline at end of file