maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/mlir/test/Conversion/ComplexToLLVM/convert-to-llvm.mlir

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

147 lines
7.6 KiB
MLIR
Raw Normal View History

[mlir] turn complex-to-llvm into a partial conversion It is no longer necessary to also convert other "standard" ops along with the complex dialect: the element types are now built-in integers or floating point types, and the top-level cast between complex and struct is automatically inserted and removed in progressive lowering. Reviewed By: herhut Differential Revision: https://reviews.llvm.org/D95625
2021-01-29 00:42:41 +08:00
// RUN: mlir-opt %s -convert-complex-to-llvm | FileCheck %s
[mlir] Add Complex dialect. Differential Revision: https://reviews.llvm.org/D94764
2021-01-16 02:53:15 +08:00
[mlir] Fold complex.re(complex.create) and complex.im(complex.create) This extends the folding we already have. A test needs to be adjusted. Differential Revision: https://reviews.llvm.org/D103141
2021-05-26 15:43:26 +08:00
// CHECK-LABEL: func @complex_create
// CHECK-SAME: (%[[REAL0:.*]]: f32, %[[IMAG0:.*]]: f32)
[mlir] Add Complex dialect. Differential Revision: https://reviews.llvm.org/D94764
2021-01-16 02:53:15 +08:00
// CHECK-NEXT: %[[CPLX0:.*]] = llvm.mlir.undef : !llvm.struct<(f32, f32)>
// CHECK-NEXT: %[[CPLX1:.*]] = llvm.insertvalue %[[REAL0]], %[[CPLX0]][0] : !llvm.struct<(f32, f32)>
// CHECK-NEXT: %[[CPLX2:.*]] = llvm.insertvalue %[[IMAG0]], %[[CPLX1]][1] : !llvm.struct<(f32, f32)>
[mlir] Fold complex.re(complex.create) and complex.im(complex.create) This extends the folding we already have. A test needs to be adjusted. Differential Revision: https://reviews.llvm.org/D103141
2021-05-26 15:43:26 +08:00
func @complex_create(%real: f32, %imag: f32) -> complex<f32> {
%cplx2 = complex.create %real, %imag : complex<f32>
return %cplx2 : complex<f32>
}
// CHECK-LABEL: func @complex_extract
// CHECK-SAME: (%[[CPLX:.*]]: complex<f32>)
[mlir] replace llvm.mlir.cast with unrealized_conversion_cast The dialect-specific cast between builtin (ex-standard) types and LLVM dialect types was introduced long time before built-in support for unrealized_conversion_cast. It has a similar purpose, but is restricted to compatible builtin and LLVM dialect types, which may hamper progressive lowering and composition with types from other dialects. Replace llvm.mlir.cast with unrealized_conversion_cast, and drop the operation that became unnecessary. Also make unrealized_conversion_cast legal by default in LLVMConversionTarget as the majority of convesions using it are partial conversions that actually want the casts to persist in the IR. The standard-to-llvm conversion, which is still expected to run last, cleans up the remaining casts standard-to-llvm conversion, which is still expected to run last, cleans up the remaining casts Reviewed By: nicolasvasilache Differential Revision: https://reviews.llvm.org/D105880
2021-07-13 16:55:35 +08:00
// CHECK-NEXT: %[[CAST0:.*]] = unrealized_conversion_cast %[[CPLX]] : complex<f32> to !llvm.struct<(f32, f32)>
[mlir] Fold complex.re(complex.create) and complex.im(complex.create) This extends the folding we already have. A test needs to be adjusted. Differential Revision: https://reviews.llvm.org/D103141
2021-05-26 15:43:26 +08:00
// CHECK-NEXT: %[[REAL:.*]] = llvm.extractvalue %[[CAST0]][0] : !llvm.struct<(f32, f32)>
[mlir] replace llvm.mlir.cast with unrealized_conversion_cast The dialect-specific cast between builtin (ex-standard) types and LLVM dialect types was introduced long time before built-in support for unrealized_conversion_cast. It has a similar purpose, but is restricted to compatible builtin and LLVM dialect types, which may hamper progressive lowering and composition with types from other dialects. Replace llvm.mlir.cast with unrealized_conversion_cast, and drop the operation that became unnecessary. Also make unrealized_conversion_cast legal by default in LLVMConversionTarget as the majority of convesions using it are partial conversions that actually want the casts to persist in the IR. The standard-to-llvm conversion, which is still expected to run last, cleans up the remaining casts standard-to-llvm conversion, which is still expected to run last, cleans up the remaining casts Reviewed By: nicolasvasilache Differential Revision: https://reviews.llvm.org/D105880
2021-07-13 16:55:35 +08:00
// CHECK-NEXT: %[[CAST1:.*]] = unrealized_conversion_cast %[[CPLX]] : complex<f32> to !llvm.struct<(f32, f32)>
[mlir] Fold complex.re(complex.create) and complex.im(complex.create) This extends the folding we already have. A test needs to be adjusted. Differential Revision: https://reviews.llvm.org/D103141
2021-05-26 15:43:26 +08:00
// CHECK-NEXT: %[[IMAG:.*]] = llvm.extractvalue %[[CAST1]][1] : !llvm.struct<(f32, f32)>
func @complex_extract(%cplx: complex<f32>) {
%real1 = complex.re %cplx : complex<f32>
%imag1 = complex.im %cplx : complex<f32>
[mlir] Add Complex dialect. Differential Revision: https://reviews.llvm.org/D94764
2021-01-16 02:53:15 +08:00
return
}
[mlir] turn complex-to-llvm into a partial conversion It is no longer necessary to also convert other "standard" ops along with the complex dialect: the element types are now built-in integers or floating point types, and the top-level cast between complex and struct is automatically inserted and removed in progressive lowering. Reviewed By: herhut Differential Revision: https://reviews.llvm.org/D95625
2021-01-29 00:42:41 +08:00
// CHECK-LABEL: func @complex_addition
[mlir] Add Complex dialect. Differential Revision: https://reviews.llvm.org/D94764
2021-01-16 02:53:15 +08:00
// CHECK-DAG: %[[A_REAL:.*]] = llvm.extractvalue %[[A:.*]][0] : !llvm.struct<(f64, f64)>
// CHECK-DAG: %[[B_REAL:.*]] = llvm.extractvalue %[[B:.*]][0] : !llvm.struct<(f64, f64)>
// CHECK-DAG: %[[A_IMAG:.*]] = llvm.extractvalue %[[A]][1] : !llvm.struct<(f64, f64)>
// CHECK-DAG: %[[B_IMAG:.*]] = llvm.extractvalue %[[B]][1] : !llvm.struct<(f64, f64)>
// CHECK: %[[C0:.*]] = llvm.mlir.undef : !llvm.struct<(f64, f64)>
// CHECK-DAG: %[[C_REAL:.*]] = llvm.fadd %[[A_REAL]], %[[B_REAL]] : f64
// CHECK-DAG: %[[C_IMAG:.*]] = llvm.fadd %[[A_IMAG]], %[[B_IMAG]] : f64
// CHECK: %[[C1:.*]] = llvm.insertvalue %[[C_REAL]], %[[C0]][0] : !llvm.struct<(f64, f64)>
// CHECK: %[[C2:.*]] = llvm.insertvalue %[[C_IMAG]], %[[C1]][1] : !llvm.struct<(f64, f64)>
func @complex_addition() {
%a_re = constant 1.2 : f64
%a_im = constant 3.4 : f64
%a = complex.create %a_re, %a_im : complex<f64>
%b_re = constant 5.6 : f64
%b_im = constant 7.8 : f64
%b = complex.create %b_re, %b_im : complex<f64>
%c = complex.add %a, %b : complex<f64>
return
}
[mlir] turn complex-to-llvm into a partial conversion It is no longer necessary to also convert other "standard" ops along with the complex dialect: the element types are now built-in integers or floating point types, and the top-level cast between complex and struct is automatically inserted and removed in progressive lowering. Reviewed By: herhut Differential Revision: https://reviews.llvm.org/D95625
2021-01-29 00:42:41 +08:00
// CHECK-LABEL: func @complex_substraction
[mlir] Add Complex dialect. Differential Revision: https://reviews.llvm.org/D94764
2021-01-16 02:53:15 +08:00
// CHECK-DAG: %[[A_REAL:.*]] = llvm.extractvalue %[[A:.*]][0] : !llvm.struct<(f64, f64)>
// CHECK-DAG: %[[B_REAL:.*]] = llvm.extractvalue %[[B:.*]][0] : !llvm.struct<(f64, f64)>
// CHECK-DAG: %[[A_IMAG:.*]] = llvm.extractvalue %[[A]][1] : !llvm.struct<(f64, f64)>
// CHECK-DAG: %[[B_IMAG:.*]] = llvm.extractvalue %[[B]][1] : !llvm.struct<(f64, f64)>
// CHECK: %[[C0:.*]] = llvm.mlir.undef : !llvm.struct<(f64, f64)>
// CHECK-DAG: %[[C_REAL:.*]] = llvm.fsub %[[A_REAL]], %[[B_REAL]] : f64
// CHECK-DAG: %[[C_IMAG:.*]] = llvm.fsub %[[A_IMAG]], %[[B_IMAG]] : f64
// CHECK: %[[C1:.*]] = llvm.insertvalue %[[C_REAL]], %[[C0]][0] : !llvm.struct<(f64, f64)>
// CHECK: %[[C2:.*]] = llvm.insertvalue %[[C_IMAG]], %[[C1]][1] : !llvm.struct<(f64, f64)>
func @complex_substraction() {
%a_re = constant 1.2 : f64
%a_im = constant 3.4 : f64
%a = complex.create %a_re, %a_im : complex<f64>
%b_re = constant 5.6 : f64
%b_im = constant 7.8 : f64
%b = complex.create %b_re, %b_im : complex<f64>
%c = complex.sub %a, %b : complex<f64>
return
}
[mlir] Add `complex.abs`, `complex.div` and `complex.mul` to ComplexOps. Differential Revision: https://reviews.llvm.org/D94911
2021-01-19 19:03:13 +08:00
[mlir] turn complex-to-llvm into a partial conversion It is no longer necessary to also convert other "standard" ops along with the complex dialect: the element types are now built-in integers or floating point types, and the top-level cast between complex and struct is automatically inserted and removed in progressive lowering. Reviewed By: herhut Differential Revision: https://reviews.llvm.org/D95625
2021-01-29 00:42:41 +08:00
// CHECK-LABEL: func @complex_div
// CHECK-SAME: %[[LHS:.*]]: complex<f32>, %[[RHS:.*]]: complex<f32>
[mlir] Add `complex.abs`, `complex.div` and `complex.mul` to ComplexOps. Differential Revision: https://reviews.llvm.org/D94911
2021-01-19 19:03:13 +08:00
func @complex_div(%lhs: complex<f32>, %rhs: complex<f32>) -> complex<f32> {
%div = complex.div %lhs, %rhs : complex<f32>
return %div : complex<f32>
}
[mlir] replace llvm.mlir.cast with unrealized_conversion_cast The dialect-specific cast between builtin (ex-standard) types and LLVM dialect types was introduced long time before built-in support for unrealized_conversion_cast. It has a similar purpose, but is restricted to compatible builtin and LLVM dialect types, which may hamper progressive lowering and composition with types from other dialects. Replace llvm.mlir.cast with unrealized_conversion_cast, and drop the operation that became unnecessary. Also make unrealized_conversion_cast legal by default in LLVMConversionTarget as the majority of convesions using it are partial conversions that actually want the casts to persist in the IR. The standard-to-llvm conversion, which is still expected to run last, cleans up the remaining casts standard-to-llvm conversion, which is still expected to run last, cleans up the remaining casts Reviewed By: nicolasvasilache Differential Revision: https://reviews.llvm.org/D105880
2021-07-13 16:55:35 +08:00
// CHECK: %[[CASTED_LHS:.*]] = unrealized_conversion_cast %[[LHS]] : complex<f32> to ![[C_TY:.*>]]
// CHECK: %[[CASTED_RHS:.*]] = unrealized_conversion_cast %[[RHS]] : complex<f32> to ![[C_TY]]
[mlir] turn complex-to-llvm into a partial conversion It is no longer necessary to also convert other "standard" ops along with the complex dialect: the element types are now built-in integers or floating point types, and the top-level cast between complex and struct is automatically inserted and removed in progressive lowering. Reviewed By: herhut Differential Revision: https://reviews.llvm.org/D95625
2021-01-29 00:42:41 +08:00
// CHECK: %[[LHS_RE:.*]] = llvm.extractvalue %[[CASTED_LHS]][0] : ![[C_TY]]
// CHECK: %[[LHS_IM:.*]] = llvm.extractvalue %[[CASTED_LHS]][1] : ![[C_TY]]
// CHECK: %[[RHS_RE:.*]] = llvm.extractvalue %[[CASTED_RHS]][0] : ![[C_TY]]
// CHECK: %[[RHS_IM:.*]] = llvm.extractvalue %[[CASTED_RHS]][1] : ![[C_TY]]
[mlir] Add `complex.abs`, `complex.div` and `complex.mul` to ComplexOps. Differential Revision: https://reviews.llvm.org/D94911
2021-01-19 19:03:13 +08:00
// CHECK: %[[RESULT_0:.*]] = llvm.mlir.undef : ![[C_TY]]
// CHECK-DAG: %[[RHS_RE_SQ:.*]] = llvm.fmul %[[RHS_RE]], %[[RHS_RE]] : f32
// CHECK-DAG: %[[RHS_IM_SQ:.*]] = llvm.fmul %[[RHS_IM]], %[[RHS_IM]] : f32
// CHECK: %[[SQ_NORM:.*]] = llvm.fadd %[[RHS_RE_SQ]], %[[RHS_IM_SQ]] : f32
// CHECK-DAG: %[[REAL_TMP_0:.*]] = llvm.fmul %[[LHS_RE]], %[[RHS_RE]] : f32
// CHECK-DAG: %[[REAL_TMP_1:.*]] = llvm.fmul %[[LHS_IM]], %[[RHS_IM]] : f32
// CHECK: %[[REAL_TMP_2:.*]] = llvm.fadd %[[REAL_TMP_0]], %[[REAL_TMP_1]] : f32
// CHECK-DAG: %[[IMAG_TMP_0:.*]] = llvm.fmul %[[LHS_IM]], %[[RHS_RE]] : f32
// CHECK-DAG: %[[IMAG_TMP_1:.*]] = llvm.fmul %[[LHS_RE]], %[[RHS_IM]] : f32
// CHECK: %[[IMAG_TMP_2:.*]] = llvm.fsub %[[IMAG_TMP_0]], %[[IMAG_TMP_1]] : f32
// CHECK: %[[REAL:.*]] = llvm.fdiv %[[REAL_TMP_2]], %[[SQ_NORM]] : f32
// CHECK: %[[RESULT_1:.*]] = llvm.insertvalue %[[REAL]], %[[RESULT_0]][0] : ![[C_TY]]
// CHECK: %[[IMAG:.*]] = llvm.fdiv %[[IMAG_TMP_2]], %[[SQ_NORM]] : f32
// CHECK: %[[RESULT_2:.*]] = llvm.insertvalue %[[IMAG]], %[[RESULT_1]][1] : ![[C_TY]]
[mlir] turn complex-to-llvm into a partial conversion It is no longer necessary to also convert other "standard" ops along with the complex dialect: the element types are now built-in integers or floating point types, and the top-level cast between complex and struct is automatically inserted and removed in progressive lowering. Reviewed By: herhut Differential Revision: https://reviews.llvm.org/D95625
2021-01-29 00:42:41 +08:00
//
[mlir] replace llvm.mlir.cast with unrealized_conversion_cast The dialect-specific cast between builtin (ex-standard) types and LLVM dialect types was introduced long time before built-in support for unrealized_conversion_cast. It has a similar purpose, but is restricted to compatible builtin and LLVM dialect types, which may hamper progressive lowering and composition with types from other dialects. Replace llvm.mlir.cast with unrealized_conversion_cast, and drop the operation that became unnecessary. Also make unrealized_conversion_cast legal by default in LLVMConversionTarget as the majority of convesions using it are partial conversions that actually want the casts to persist in the IR. The standard-to-llvm conversion, which is still expected to run last, cleans up the remaining casts standard-to-llvm conversion, which is still expected to run last, cleans up the remaining casts Reviewed By: nicolasvasilache Differential Revision: https://reviews.llvm.org/D105880
2021-07-13 16:55:35 +08:00
// CHECK: %[[CASTED_RESULT:.*]] = unrealized_conversion_cast %[[RESULT_2]] : ![[C_TY]] to complex<f32>
[mlir] turn complex-to-llvm into a partial conversion It is no longer necessary to also convert other "standard" ops along with the complex dialect: the element types are now built-in integers or floating point types, and the top-level cast between complex and struct is automatically inserted and removed in progressive lowering. Reviewed By: herhut Differential Revision: https://reviews.llvm.org/D95625
2021-01-29 00:42:41 +08:00
// CHECK: return %[[CASTED_RESULT]] : complex<f32>
[mlir] Add `complex.abs`, `complex.div` and `complex.mul` to ComplexOps. Differential Revision: https://reviews.llvm.org/D94911
2021-01-19 19:03:13 +08:00
[mlir] turn complex-to-llvm into a partial conversion It is no longer necessary to also convert other "standard" ops along with the complex dialect: the element types are now built-in integers or floating point types, and the top-level cast between complex and struct is automatically inserted and removed in progressive lowering. Reviewed By: herhut Differential Revision: https://reviews.llvm.org/D95625
2021-01-29 00:42:41 +08:00
// CHECK-LABEL: func @complex_mul
// CHECK-SAME: %[[LHS:.*]]: complex<f32>, %[[RHS:.*]]: complex<f32>
[mlir] Add `complex.abs`, `complex.div` and `complex.mul` to ComplexOps. Differential Revision: https://reviews.llvm.org/D94911
2021-01-19 19:03:13 +08:00
func @complex_mul(%lhs: complex<f32>, %rhs: complex<f32>) -> complex<f32> {
%mul = complex.mul %lhs, %rhs : complex<f32>
return %mul : complex<f32>
}
[mlir] replace llvm.mlir.cast with unrealized_conversion_cast The dialect-specific cast between builtin (ex-standard) types and LLVM dialect types was introduced long time before built-in support for unrealized_conversion_cast. It has a similar purpose, but is restricted to compatible builtin and LLVM dialect types, which may hamper progressive lowering and composition with types from other dialects. Replace llvm.mlir.cast with unrealized_conversion_cast, and drop the operation that became unnecessary. Also make unrealized_conversion_cast legal by default in LLVMConversionTarget as the majority of convesions using it are partial conversions that actually want the casts to persist in the IR. The standard-to-llvm conversion, which is still expected to run last, cleans up the remaining casts standard-to-llvm conversion, which is still expected to run last, cleans up the remaining casts Reviewed By: nicolasvasilache Differential Revision: https://reviews.llvm.org/D105880
2021-07-13 16:55:35 +08:00
// CHECK: %[[CASTED_LHS:.*]] = unrealized_conversion_cast %[[LHS]] : complex<f32> to ![[C_TY:.*>]]
// CHECK: %[[CASTED_RHS:.*]] = unrealized_conversion_cast %[[RHS]] : complex<f32> to ![[C_TY]]
[mlir] turn complex-to-llvm into a partial conversion It is no longer necessary to also convert other "standard" ops along with the complex dialect: the element types are now built-in integers or floating point types, and the top-level cast between complex and struct is automatically inserted and removed in progressive lowering. Reviewed By: herhut Differential Revision: https://reviews.llvm.org/D95625
2021-01-29 00:42:41 +08:00
// CHECK: %[[LHS_RE:.*]] = llvm.extractvalue %[[CASTED_LHS]][0] : ![[C_TY]]
// CHECK: %[[LHS_IM:.*]] = llvm.extractvalue %[[CASTED_LHS]][1] : ![[C_TY]]
// CHECK: %[[RHS_RE:.*]] = llvm.extractvalue %[[CASTED_RHS]][0] : ![[C_TY]]
// CHECK: %[[RHS_IM:.*]] = llvm.extractvalue %[[CASTED_RHS]][1] : ![[C_TY]]
[mlir] Add `complex.abs`, `complex.div` and `complex.mul` to ComplexOps. Differential Revision: https://reviews.llvm.org/D94911
2021-01-19 19:03:13 +08:00
// CHECK: %[[RESULT_0:.*]] = llvm.mlir.undef : ![[C_TY]]
// CHECK-DAG: %[[REAL_TMP_0:.*]] = llvm.fmul %[[RHS_RE]], %[[LHS_RE]] : f32
// CHECK-DAG: %[[REAL_TMP_1:.*]] = llvm.fmul %[[RHS_IM]], %[[LHS_IM]] : f32
// CHECK: %[[REAL:.*]] = llvm.fsub %[[REAL_TMP_0]], %[[REAL_TMP_1]] : f32
// CHECK-DAG: %[[IMAG_TMP_0:.*]] = llvm.fmul %[[LHS_IM]], %[[RHS_RE]] : f32
// CHECK-DAG: %[[IMAG_TMP_1:.*]] = llvm.fmul %[[LHS_RE]], %[[RHS_IM]] : f32
// CHECK: %[[IMAG:.*]] = llvm.fadd %[[IMAG_TMP_0]], %[[IMAG_TMP_1]] : f32
// CHECK: %[[RESULT_1:.*]] = llvm.insertvalue %[[REAL]], %[[RESULT_0]][0]
// CHECK: %[[RESULT_2:.*]] = llvm.insertvalue %[[IMAG]], %[[RESULT_1]][1]
[mlir] replace llvm.mlir.cast with unrealized_conversion_cast The dialect-specific cast between builtin (ex-standard) types and LLVM dialect types was introduced long time before built-in support for unrealized_conversion_cast. It has a similar purpose, but is restricted to compatible builtin and LLVM dialect types, which may hamper progressive lowering and composition with types from other dialects. Replace llvm.mlir.cast with unrealized_conversion_cast, and drop the operation that became unnecessary. Also make unrealized_conversion_cast legal by default in LLVMConversionTarget as the majority of convesions using it are partial conversions that actually want the casts to persist in the IR. The standard-to-llvm conversion, which is still expected to run last, cleans up the remaining casts standard-to-llvm conversion, which is still expected to run last, cleans up the remaining casts Reviewed By: nicolasvasilache Differential Revision: https://reviews.llvm.org/D105880
2021-07-13 16:55:35 +08:00
// CHECK: %[[CASTED_RESULT:.*]] = unrealized_conversion_cast %[[RESULT_2]] : ![[C_TY]] to complex<f32>
[mlir] turn complex-to-llvm into a partial conversion It is no longer necessary to also convert other "standard" ops along with the complex dialect: the element types are now built-in integers or floating point types, and the top-level cast between complex and struct is automatically inserted and removed in progressive lowering. Reviewed By: herhut Differential Revision: https://reviews.llvm.org/D95625
2021-01-29 00:42:41 +08:00
// CHECK: return %[[CASTED_RESULT]] : complex<f32>
[mlir] Add `complex.abs`, `complex.div` and `complex.mul` to ComplexOps. Differential Revision: https://reviews.llvm.org/D94911
2021-01-19 19:03:13 +08:00
[mlir] turn complex-to-llvm into a partial conversion It is no longer necessary to also convert other "standard" ops along with the complex dialect: the element types are now built-in integers or floating point types, and the top-level cast between complex and struct is automatically inserted and removed in progressive lowering. Reviewed By: herhut Differential Revision: https://reviews.llvm.org/D95625
2021-01-29 00:42:41 +08:00
// CHECK-LABEL: func @complex_abs
// CHECK-SAME: %[[ARG:.*]]: complex<f32>
[mlir] Add `complex.abs`, `complex.div` and `complex.mul` to ComplexOps. Differential Revision: https://reviews.llvm.org/D94911
2021-01-19 19:03:13 +08:00
func @complex_abs(%arg: complex<f32>) -> f32 {
%abs = complex.abs %arg: complex<f32>
return %abs : f32
}
[mlir] replace llvm.mlir.cast with unrealized_conversion_cast The dialect-specific cast between builtin (ex-standard) types and LLVM dialect types was introduced long time before built-in support for unrealized_conversion_cast. It has a similar purpose, but is restricted to compatible builtin and LLVM dialect types, which may hamper progressive lowering and composition with types from other dialects. Replace llvm.mlir.cast with unrealized_conversion_cast, and drop the operation that became unnecessary. Also make unrealized_conversion_cast legal by default in LLVMConversionTarget as the majority of convesions using it are partial conversions that actually want the casts to persist in the IR. The standard-to-llvm conversion, which is still expected to run last, cleans up the remaining casts standard-to-llvm conversion, which is still expected to run last, cleans up the remaining casts Reviewed By: nicolasvasilache Differential Revision: https://reviews.llvm.org/D105880
2021-07-13 16:55:35 +08:00
// CHECK: %[[CASTED_ARG:.*]] = unrealized_conversion_cast %[[ARG]] : complex<f32> to ![[C_TY:.*>]]
[mlir] turn complex-to-llvm into a partial conversion It is no longer necessary to also convert other "standard" ops along with the complex dialect: the element types are now built-in integers or floating point types, and the top-level cast between complex and struct is automatically inserted and removed in progressive lowering. Reviewed By: herhut Differential Revision: https://reviews.llvm.org/D95625
2021-01-29 00:42:41 +08:00
// CHECK: %[[REAL:.*]] = llvm.extractvalue %[[CASTED_ARG]][0] : ![[C_TY]]
// CHECK: %[[IMAG:.*]] = llvm.extractvalue %[[CASTED_ARG]][1] : ![[C_TY]]
[mlir] Add `complex.abs`, `complex.div` and `complex.mul` to ComplexOps. Differential Revision: https://reviews.llvm.org/D94911
2021-01-19 19:03:13 +08:00
// CHECK-DAG: %[[REAL_SQ:.*]] = llvm.fmul %[[REAL]], %[[REAL]] : f32
// CHECK-DAG: %[[IMAG_SQ:.*]] = llvm.fmul %[[IMAG]], %[[IMAG]] : f32
// CHECK: %[[SQ_NORM:.*]] = llvm.fadd %[[REAL_SQ]], %[[IMAG_SQ]] : f32
// CHECK: %[[NORM:.*]] = "llvm.intr.sqrt"(%[[SQ_NORM]]) : (f32) -> f32
[mlir] turn complex-to-llvm into a partial conversion It is no longer necessary to also convert other "standard" ops along with the complex dialect: the element types are now built-in integers or floating point types, and the top-level cast between complex and struct is automatically inserted and removed in progressive lowering. Reviewed By: herhut Differential Revision: https://reviews.llvm.org/D95625
2021-01-29 00:42:41 +08:00
// CHECK: return %[[NORM]] : f32
[mlir] Add `complex.abs`, `complex.div` and `complex.mul` to ComplexOps. Differential Revision: https://reviews.llvm.org/D94911
2021-01-19 19:03:13 +08:00