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.

153 lines
7.9 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>
}
[mlir][complex] Lower complex.constant to LLVM This fixes a regression from 480cd4cb8560532e544fc0c234749912dde759c6 Differential Revision: https://reviews.llvm.org/D118347
2022-01-27 20:08:08 +08:00
// CHECK-LABEL: func @complex_constant
// CHECK-NEXT: llvm.mlir.constant([1.000000e+00, 2.000000e+00]) : !llvm.struct<(f64, f64)>
func @complex_constant() -> complex<f64> {
%cplx2 = complex.constant [1.000000e+00, 2.000000e+00] : complex<f64>
return %cplx2 : complex<f64>
}
[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_extract
// CHECK-SAME: (%[[CPLX:.*]]: complex<f32>)
[mlir] Set the namespace of the BuiltinDialect to 'builtin' Historically the builtin dialect has had an empty namespace. This has unfortunately created a very awkward situation, where many utilities either have to special case the empty namespace, or just don't work at all right now. This revision adds a namespace to the builtin dialect, and starts to cleanup some of the utilities to no longer handle empty namespaces. For now, the assembly form of builtin operations does not require the `builtin.` prefix. (This should likely be re-evaluated though) Differential Revision: https://reviews.llvm.org/D105149
2021-07-29 04:32:47 +08:00
// CHECK-NEXT: %[[CAST0:.*]] = builtin.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:DialectConversion] Restructure how argument/target materializations get invoked The current implementation invokes materializations whenever an input operand does not have a mapping for the desired type, i.e. it requires materialization at the earliest possible point. This conflicts with goal of dialect conversion (and also the current documentation) which states that a materialization is only required if the materialization is supposed to persist after the conversion process has finished. This revision refactors this such that whenever a target materialization "might" be necessary, we insert an unrealized_conversion_cast to act as a temporary materialization. This allows for deferring the invocation of the user materialization hooks until the end of the conversion process, where we actually have a better sense if it's actually necessary. This has several benefits: * In some cases a target materialization hook is no longer necessary When performing a full conversion, there are some situations where a temporary materialization is necessary. Moving forward, these users won't need to provide any target materializations, as the temporary materializations do not require the user to provide materialization hooks. * getRemappedValue can now handle values that haven't been converted yet Before this commit, it wasn't well supported to get the remapped value of a value that hadn't been converted yet (making it difficult/impossible to convert multiple operations in many situations). This commit updates getRemappedValue to properly handle this case by inserting temporary materializations when necessary. Another code-health related benefit is that with this change we can move a majority of the complexity related to materializations to the end of the conversion process, instead of handling adhoc while conversion is happening. Differential Revision: https://reviews.llvm.org/D111620
2021-10-27 10:00:10 +08:00
// CHECK-NEXT: %[[IMAG:.*]] = llvm.extractvalue %[[CAST0]][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_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() {
[MLIR] Replace std ops with arith dialect ops Precursor: https://reviews.llvm.org/D110200 Removed redundant ops from the standard dialect that were moved to the `arith` or `math` dialects. Renamed all instances of operations in the codebase and in tests. Reviewed By: rriddle, jpienaar Differential Revision: https://reviews.llvm.org/D110797
2021-10-13 07:14:57 +08:00
%a_re = arith.constant 1.2 : f64
%a_im = arith.constant 3.4 : f64
[mlir] Add Complex dialect. Differential Revision: https://reviews.llvm.org/D94764
2021-01-16 02:53:15 +08:00
%a = complex.create %a_re, %a_im : complex<f64>
[MLIR] Replace std ops with arith dialect ops Precursor: https://reviews.llvm.org/D110200 Removed redundant ops from the standard dialect that were moved to the `arith` or `math` dialects. Renamed all instances of operations in the codebase and in tests. Reviewed By: rriddle, jpienaar Differential Revision: https://reviews.llvm.org/D110797
2021-10-13 07:14:57 +08:00
%b_re = arith.constant 5.6 : f64
%b_im = arith.constant 7.8 : f64
[mlir] Add Complex dialect. Differential Revision: https://reviews.llvm.org/D94764
2021-01-16 02:53:15 +08:00
%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() {
[MLIR] Replace std ops with arith dialect ops Precursor: https://reviews.llvm.org/D110200 Removed redundant ops from the standard dialect that were moved to the `arith` or `math` dialects. Renamed all instances of operations in the codebase and in tests. Reviewed By: rriddle, jpienaar Differential Revision: https://reviews.llvm.org/D110797
2021-10-13 07:14:57 +08:00
%a_re = arith.constant 1.2 : f64
%a_im = arith.constant 3.4 : f64
[mlir] Add Complex dialect. Differential Revision: https://reviews.llvm.org/D94764
2021-01-16 02:53:15 +08:00
%a = complex.create %a_re, %a_im : complex<f64>
[MLIR] Replace std ops with arith dialect ops Precursor: https://reviews.llvm.org/D110200 Removed redundant ops from the standard dialect that were moved to the `arith` or `math` dialects. Renamed all instances of operations in the codebase and in tests. Reviewed By: rriddle, jpienaar Differential Revision: https://reviews.llvm.org/D110797
2021-10-13 07:14:57 +08:00
%b_re = arith.constant 5.6 : f64
%b_im = arith.constant 7.8 : f64
[mlir] Add Complex dialect. Differential Revision: https://reviews.llvm.org/D94764
2021-01-16 02:53:15 +08:00
%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:DialectConversion] Restructure how argument/target materializations get invoked The current implementation invokes materializations whenever an input operand does not have a mapping for the desired type, i.e. it requires materialization at the earliest possible point. This conflicts with goal of dialect conversion (and also the current documentation) which states that a materialization is only required if the materialization is supposed to persist after the conversion process has finished. This revision refactors this such that whenever a target materialization "might" be necessary, we insert an unrealized_conversion_cast to act as a temporary materialization. This allows for deferring the invocation of the user materialization hooks until the end of the conversion process, where we actually have a better sense if it's actually necessary. This has several benefits: * In some cases a target materialization hook is no longer necessary When performing a full conversion, there are some situations where a temporary materialization is necessary. Moving forward, these users won't need to provide any target materializations, as the temporary materializations do not require the user to provide materialization hooks. * getRemappedValue can now handle values that haven't been converted yet Before this commit, it wasn't well supported to get the remapped value of a value that hadn't been converted yet (making it difficult/impossible to convert multiple operations in many situations). This commit updates getRemappedValue to properly handle this case by inserting temporary materializations when necessary. Another code-health related benefit is that with this change we can move a majority of the complexity related to materializations to the end of the conversion process, instead of handling adhoc while conversion is happening. Differential Revision: https://reviews.llvm.org/D111620
2021-10-27 10:00:10 +08:00
// CHECK-DAG: %[[CASTED_LHS:.*]] = builtin.unrealized_conversion_cast %[[LHS]] : complex<f32> to ![[C_TY:.*>]]
// CHECK-DAG: %[[CASTED_RHS:.*]] = builtin.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] Set the namespace of the BuiltinDialect to 'builtin' Historically the builtin dialect has had an empty namespace. This has unfortunately created a very awkward situation, where many utilities either have to special case the empty namespace, or just don't work at all right now. This revision adds a namespace to the builtin dialect, and starts to cleanup some of the utilities to no longer handle empty namespaces. For now, the assembly form of builtin operations does not require the `builtin.` prefix. (This should likely be re-evaluated though) Differential Revision: https://reviews.llvm.org/D105149
2021-07-29 04:32:47 +08:00
// CHECK: %[[CASTED_RESULT:.*]] = builtin.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:DialectConversion] Restructure how argument/target materializations get invoked The current implementation invokes materializations whenever an input operand does not have a mapping for the desired type, i.e. it requires materialization at the earliest possible point. This conflicts with goal of dialect conversion (and also the current documentation) which states that a materialization is only required if the materialization is supposed to persist after the conversion process has finished. This revision refactors this such that whenever a target materialization "might" be necessary, we insert an unrealized_conversion_cast to act as a temporary materialization. This allows for deferring the invocation of the user materialization hooks until the end of the conversion process, where we actually have a better sense if it's actually necessary. This has several benefits: * In some cases a target materialization hook is no longer necessary When performing a full conversion, there are some situations where a temporary materialization is necessary. Moving forward, these users won't need to provide any target materializations, as the temporary materializations do not require the user to provide materialization hooks. * getRemappedValue can now handle values that haven't been converted yet Before this commit, it wasn't well supported to get the remapped value of a value that hadn't been converted yet (making it difficult/impossible to convert multiple operations in many situations). This commit updates getRemappedValue to properly handle this case by inserting temporary materializations when necessary. Another code-health related benefit is that with this change we can move a majority of the complexity related to materializations to the end of the conversion process, instead of handling adhoc while conversion is happening. Differential Revision: https://reviews.llvm.org/D111620
2021-10-27 10:00:10 +08:00
// CHECK-DAG: %[[CASTED_LHS:.*]] = builtin.unrealized_conversion_cast %[[LHS]] : complex<f32> to ![[C_TY:.*>]]
// CHECK-DAG: %[[CASTED_RHS:.*]] = builtin.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] Set the namespace of the BuiltinDialect to 'builtin' Historically the builtin dialect has had an empty namespace. This has unfortunately created a very awkward situation, where many utilities either have to special case the empty namespace, or just don't work at all right now. This revision adds a namespace to the builtin dialect, and starts to cleanup some of the utilities to no longer handle empty namespaces. For now, the assembly form of builtin operations does not require the `builtin.` prefix. (This should likely be re-evaluated though) Differential Revision: https://reviews.llvm.org/D105149
2021-07-29 04:32:47 +08:00
// CHECK: %[[CASTED_RESULT:.*]] = builtin.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] Set the namespace of the BuiltinDialect to 'builtin' Historically the builtin dialect has had an empty namespace. This has unfortunately created a very awkward situation, where many utilities either have to special case the empty namespace, or just don't work at all right now. This revision adds a namespace to the builtin dialect, and starts to cleanup some of the utilities to no longer handle empty namespaces. For now, the assembly form of builtin operations does not require the `builtin.` prefix. (This should likely be re-evaluated though) Differential Revision: https://reviews.llvm.org/D105149
2021-07-29 04:32:47 +08:00
// CHECK: %[[CASTED_ARG:.*]] = builtin.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