Skip to content

Commit bb489a9

Browse files
nikolaypanchenkonikolaypanchenko
committed
comment changes + conversion test from math -> vcix
1 parent fd5b264 commit bb489a9

File tree

11 files changed

+492
-9
lines changed

11 files changed

+492
-9
lines changed

‎mlir/include/mlir/Dialect/LLVMIR/VCIXOps.td

Lines changed: 28 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -44,7 +44,7 @@ def VCIX_Dialect : Dialect {
4444
}
4545

4646
// Special version for intrinsic version where int attr is zext to i32 or i64
47-
// depending on xlen of the target
47+
// depending on xlen of the target.
4848
def VCIX_VectorOrScalar
4949
: AnyTypeOf<[LLVM_AnyVector, I<64>, I<32>, F<16>, F<32>, F<64>]>;
5050
def VCIX_OpcodeAttr : AnyAttrOf<[I32Attr, I64Attr]>;
@@ -56,13 +56,23 @@ class VCIX_Op<string mnemonic, list<Trait> traits = []>
5656
: LLVM_OpBase<VCIX_Dialect, mnemonic, traits> {
5757
}
5858

59-
def VCIX_BinaryImmOp
60-
: VCIX_Op<"v.iv">,
59+
def VCIX_BinaryImmOp : VCIX_Op<"v.iv">,
6160
Results<(outs LLVM_AnyVector: $res)>,
6261
Arguments<(ins VCIX_OpcodeAttr: $opcode,
6362
LLVM_AnyVector: $vs2,
6463
VCIX_ImmAttr: $imm,
6564
Optional<VCIX_VL>: $vl)> {
65+
let summary = "Binary VCIX operation with an immediate second operand";
66+
let description = [{
67+
Binary VCIX operation with an immediate second operand
68+
69+
Correponds to
70+
```
71+
Mnemonic funct6 vm rs2 rs1 funct3 rd Destination Sources
72+
sf.vc.v.iv 0010-- 0 vs2 simm 011 vd vector vd simm[4:0], vector vs2
73+
```
74+
}];
75+
6676
string llvmBuilder = [{
6777
llvm::Type *xlen =getXlenType($opcode, moduleTranslation);
6878
llvm::Value *opcodeConst = mlir::LLVM::detail::getLLVMConstant(
@@ -79,13 +89,26 @@ def VCIX_BinaryImmOp
7989
}];
8090
}
8191

82-
def VCIX_BinaryOp
83-
: VCIX_Op<"v.sv">,
92+
def VCIX_BinaryOp : VCIX_Op<"v.sv">,
8493
Results<(outs LLVM_AnyVector: $res)>,
8594
Arguments<(ins VCIX_OpcodeAttr: $opcode,
8695
LLVM_AnyVector: $vs2,
8796
VCIX_VectorOrScalar: $op,
8897
Optional<VCIX_VL>: $vl)> {
98+
let summary = "Binary VCIX operation";
99+
let description = [{
100+
Binary VCIX operation with an integer scalar, or floating pointer scalar or
101+
vector second operand
102+
103+
Correponds to
104+
```
105+
Mnemonic funct6 vm rs2 rs1 funct3 rd Destination Sources
106+
sf.vc.v.vv 0010-- 0 vs2 vs1 000 vd vector vd vector vs1, vector vs2
107+
sf.vc.v.xv 0010-- 0 vs2 xs1 100 vd vector vd scalar xs1, vector vs2
108+
sf.vc.v.fv 0010-- 0 vs2 fs1 101 vd vector vd scalar fs1, vector vs2
109+
```
110+
}];
111+
89112
string llvmBuilder = [{
90113
llvm::Type *xlen = getXlenType($opcode, moduleTranslation);
91114
llvm::Value *opcodeConst = mlir::LLVM::detail::getLLVMConstant(

‎mlir/include/mlir/Target/LLVMIR/Dialect/VCIX/VCIXToLLVMIRTranslation.h

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -19,7 +19,7 @@ class DialectRegistry;
1919
class MLIRContext;
2020

2121
/// Register the VCIX dialect and the translation from it to the LLVM IR in the
22-
/// given registry;
22+
/// given registry.
2323
void registerVCIXDialectTranslation(DialectRegistry &registry);
2424

2525
/// Register the VCIX dialect and the translation from it in the registry

‎mlir/lib/Dialect/LLVMIR/IR/VCIXDialect.cpp

Lines changed: 0 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -35,7 +35,6 @@ using namespace vcix;
3535
// VCIXDialect initialization, type parsing, and registration.
3636
//===----------------------------------------------------------------------===//
3737

38-
// TODO: This should be the llvm.rocdl dialect once this is supported.
3938
void VCIXDialect::initialize() {
4039
addOperations<
4140
#define GET_OP_LIST

‎mlir/lib/Target/LLVMIR/CMakeLists.txt

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -58,8 +58,8 @@ add_mlir_translation_library(MLIRToLLVMIRTranslationRegistration
5858
MLIROpenACCToLLVMIRTranslation
5959
MLIROpenMPToLLVMIRTranslation
6060
MLIRROCDLToLLVMIRTranslation
61-
MLIRVCIXToLLVMIRTranslation
6261
MLIRSPIRVToLLVMIRTranslation
62+
MLIRVCIXToLLVMIRTranslation
6363
)
6464

6565
add_mlir_translation_library(MLIRTargetLLVMIRImport

‎mlir/lib/Target/LLVMIR/Dialect/CMakeLists.txt

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -9,6 +9,6 @@ add_subdirectory(NVVM)
99
add_subdirectory(OpenACC)
1010
add_subdirectory(OpenMP)
1111
add_subdirectory(ROCDL)
12-
add_subdirectory(VCIX)
1312
add_subdirectory(SPIRV)
13+
add_subdirectory(VCIX)
1414
add_subdirectory(X86Vector)

‎mlir/test/Conversion/MathToVCIX/math-to-vcix.mlir

Lines changed: 171 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,171 @@
1+
// RUN: mlir-opt --split-input-file --verify-diagnostics --test-math-to-vcix %s -o - | FileCheck %s
2+
3+
// CHECK-LABEL: func.func @cos(
4+
// CHECK-SAME: %[[VAL_0:.*]]: vector<[8]xf32>,
5+
// CHECK-SAME: %[[VAL_1:.*]]: i64) -> vector<[8]xf32> {
6+
// CHECK: %[[VAL_2:.*]] = arith.constant 9 : i64
7+
// CHECK: %[[VAL_3:.*]] = "vcix.v.iv"(%[[VAL_0]], %[[VAL_2]]) <{imm = 0 : i32, opcode = 0 : i64}> : (vector<[8]xf32>, i64) -> vector<[8]xf32>
8+
// CHECK: return %[[VAL_3]] : vector<[8]xf32>
9+
// CHECK: }
10+
func.func @cos(%a: vector<[8] x f32>, %rvl: i64) -> vector<[8] x f32> {
11+
%res = math.cos %a : vector<[8] x f32>
12+
return %res : vector<[8] x f32>
13+
}
14+
15+
// CHECK-LABEL: func.func @cos_req_legalization(
16+
// CHECK-SAME: %[[VAL_0:.*]]: vector<[32]xf32>,
17+
// CHECK-SAME: %[[VAL_1:.*]]: i64) -> vector<[32]xf32> {
18+
// CHECK: %[[VAL_2:.*]] = arith.constant 9 : i64
19+
// CHECK: %[[VAL_3:.*]] = arith.constant dense<0.000000e+00> : vector<[32]xf32>
20+
// CHECK: %[[VAL_4:.*]] = vector.scalable.extract %[[VAL_0]][0] : vector<[16]xf32> from vector<[32]xf32>
21+
// CHECK: %[[VAL_5:.*]] = "vcix.v.iv"(%[[VAL_4]], %[[VAL_2]]) <{imm = 0 : i32, opcode = 0 : i64}> : (vector<[16]xf32>, i64) -> vector<[16]xf32>
22+
// CHECK: %[[VAL_6:.*]] = vector.scalable.insert %[[VAL_5]], %[[VAL_3]][0] : vector<[16]xf32> into vector<[32]xf32>
23+
// CHECK: %[[VAL_7:.*]] = vector.scalable.extract %[[VAL_0]][16] : vector<[16]xf32> from vector<[32]xf32>
24+
// CHECK: %[[VAL_8:.*]] = "vcix.v.iv"(%[[VAL_7]], %[[VAL_2]]) <{imm = 0 : i32, opcode = 0 : i64}> : (vector<[16]xf32>, i64) -> vector<[16]xf32>
25+
// CHECK: %[[VAL_9:.*]] = vector.scalable.insert %[[VAL_8]], %[[VAL_6]][16] : vector<[16]xf32> into vector<[32]xf32>
26+
// CHECK: return %[[VAL_9]] : vector<[32]xf32>
27+
// CHECK: }
28+
func.func @cos_req_legalization(%a: vector<[32] x f32>, %rvl: i64) -> vector<[32] x f32> {
29+
%res = math.cos %a : vector<[32] x f32>
30+
return %res : vector<[32] x f32>
31+
}
32+
33+
// CHECK-LABEL: func.func @cos_fixed(
34+
// CHECK-SAME: %[[VAL_0:.*]]: vector<8xf32>,
35+
// CHECK-SAME: %[[VAL_1:.*]]: i64) -> vector<8xf32> {
36+
// CHECK: %[[VAL_2:.*]] = "vcix.v.iv"(%[[VAL_0]]) <{imm = 0 : i32, opcode = 0 : i64}> : (vector<8xf32>) -> vector<8xf32>
37+
// CHECK: return %[[VAL_2]] : vector<8xf32>
38+
// CHECK: }
39+
func.func @cos_fixed(%a: vector<8 x f32>, %rvl: i64) -> vector<8 x f32> {
40+
%res = math.cos %a : vector<8 x f32>
41+
return %res : vector<8 x f32>
42+
}
43+
44+
// CHECK-LABEL: func.func @sin(
45+
// CHECK-SAME: %[[VAL_0:.*]]: vector<[8]xf32>,
46+
// CHECK-SAME: %[[VAL_1:.*]]: i64) -> vector<[8]xf32> {
47+
// CHECK: %[[VAL_2:.*]] = arith.constant 9 : i64
48+
// CHECK: %[[VAL_3:.*]] = "vcix.v.sv"(%[[VAL_0]], %[[VAL_0]], %[[VAL_2]]) <{opcode = 0 : i64}> : (vector<[8]xf32>, vector<[8]xf32>, i64) -> vector<[8]xf32>
49+
// CHECK: return %[[VAL_3]] : vector<[8]xf32>
50+
// CHECK: }
51+
func.func @sin(%a: vector<[8] x f32>, %rvl: i64) -> vector<[8] x f32> {
52+
%res = math.sin %a : vector<[8] x f32>
53+
return %res : vector<[8] x f32>
54+
}
55+
56+
// CHECK-LABEL: func.func @sin_req_legalization(
57+
// CHECK-SAME: %[[VAL_0:.*]]: vector<[32]xf32>,
58+
// CHECK-SAME: %[[VAL_1:.*]]: i64) -> vector<[32]xf32> {
59+
// CHECK: %[[VAL_2:.*]] = arith.constant 9 : i64
60+
// CHECK: %[[VAL_3:.*]] = arith.constant dense<0.000000e+00> : vector<[32]xf32>
61+
// CHECK: %[[VAL_4:.*]] = vector.scalable.extract %[[VAL_0]][0] : vector<[16]xf32> from vector<[32]xf32>
62+
// CHECK: %[[VAL_5:.*]] = "vcix.v.sv"(%[[VAL_4]], %[[VAL_4]], %[[VAL_2]]) <{opcode = 0 : i64}> : (vector<[16]xf32>, vector<[16]xf32>, i64) -> vector<[16]xf32>
63+
// CHECK: %[[VAL_6:.*]] = vector.scalable.insert %[[VAL_5]], %[[VAL_3]][0] : vector<[16]xf32> into vector<[32]xf32>
64+
// CHECK: %[[VAL_7:.*]] = vector.scalable.extract %[[VAL_0]][16] : vector<[16]xf32> from vector<[32]xf32>
65+
// CHECK: %[[VAL_8:.*]] = "vcix.v.sv"(%[[VAL_7]], %[[VAL_7]], %[[VAL_2]]) <{opcode = 0 : i64}> : (vector<[16]xf32>, vector<[16]xf32>, i64) -> vector<[16]xf32>
66+
// CHECK: %[[VAL_9:.*]] = vector.scalable.insert %[[VAL_8]], %[[VAL_6]][16] : vector<[16]xf32> into vector<[32]xf32>
67+
// CHECK: return %[[VAL_9]] : vector<[32]xf32>
68+
// CHECK: }
69+
func.func @sin_req_legalization(%a: vector<[32] x f32>, %rvl: i64) -> vector<[32] x f32> {
70+
%res = math.sin %a : vector<[32] x f32>
71+
return %res : vector<[32] x f32>
72+
}
73+
74+
// CHECK-LABEL: func.func @sin_fixed(
75+
// CHECK-SAME: %[[VAL_0:.*]]: vector<8xf32>,
76+
// CHECK-SAME: %[[VAL_1:.*]]: i64) -> vector<8xf32> {
77+
// CHECK: %[[VAL_2:.*]] = "vcix.v.sv"(%[[VAL_0]], %[[VAL_0]]) <{opcode = 0 : i64}> : (vector<8xf32>, vector<8xf32>) -> vector<8xf32>
78+
// CHECK: return %[[VAL_2]] : vector<8xf32>
79+
// CHECK: }
80+
func.func @sin_fixed(%a: vector<8 x f32>, %rvl: i64) -> vector<8 x f32> {
81+
%res = math.sin %a : vector<8 x f32>
82+
return %res : vector<8 x f32>
83+
}
84+
85+
// CHECK-LABEL: func.func @tan(
86+
// CHECK-SAME: %[[VAL_0:.*]]: vector<[8]xf32>,
87+
// CHECK-SAME: %[[VAL_1:.*]]: i64) -> vector<[8]xf32> {
88+
// CHECK: %[[VAL_2:.*]] = arith.constant 0.000000e+00 : f32
89+
// CHECK: %[[VAL_3:.*]] = arith.constant 9 : i64
90+
// CHECK: %[[VAL_4:.*]] = "vcix.v.sv"(%[[VAL_0]], %[[VAL_2]], %[[VAL_3]]) <{opcode = 0 : i64}> : (vector<[8]xf32>, f32, i64) -> vector<[8]xf32>
91+
// CHECK: return %[[VAL_4]] : vector<[8]xf32>
92+
// CHECK: }
93+
func.func @tan(%a: vector<[8] x f32>, %rvl: i64) -> vector<[8] x f32> {
94+
%res = math.tan %a : vector<[8] x f32>
95+
return %res : vector<[8] x f32>
96+
}
97+
98+
// CHECK-LABEL: func.func @tan_req_legalization(
99+
// CHECK-SAME: %[[VAL_0:.*]]: vector<[32]xf32>,
100+
// CHECK-SAME: %[[VAL_1:.*]]: i64) -> vector<[32]xf32> {
101+
// CHECK: %[[VAL_2:.*]] = arith.constant 0.000000e+00 : f32
102+
// CHECK: %[[VAL_3:.*]] = arith.constant 9 : i64
103+
// CHECK: %[[VAL_4:.*]] = arith.constant dense<0.000000e+00> : vector<[32]xf32>
104+
// CHECK: %[[VAL_5:.*]] = vector.scalable.extract %[[VAL_0]][0] : vector<[16]xf32> from vector<[32]xf32>
105+
// CHECK: %[[VAL_6:.*]] = "vcix.v.sv"(%[[VAL_5]], %[[VAL_2]], %[[VAL_3]]) <{opcode = 0 : i64}> : (vector<[16]xf32>, f32, i64) -> vector<[16]xf32>
106+
// CHECK: %[[VAL_7:.*]] = vector.scalable.insert %[[VAL_6]], %[[VAL_4]][0] : vector<[16]xf32> into vector<[32]xf32>
107+
// CHECK: %[[VAL_8:.*]] = vector.scalable.extract %[[VAL_0]][16] : vector<[16]xf32> from vector<[32]xf32>
108+
// CHECK: %[[VAL_9:.*]] = "vcix.v.sv"(%[[VAL_8]], %[[VAL_2]], %[[VAL_3]]) <{opcode = 0 : i64}> : (vector<[16]xf32>, f32, i64) -> vector<[16]xf32>
109+
// CHECK: %[[VAL_10:.*]] = vector.scalable.insert %[[VAL_9]], %[[VAL_7]][16] : vector<[16]xf32> into vector<[32]xf32>
110+
// CHECK: return %[[VAL_10]] : vector<[32]xf32>
111+
// CHECK: }
112+
func.func @tan_req_legalization(%a: vector<[32] x f32>, %rvl: i64) -> vector<[32] x f32> {
113+
%res = math.tan %a : vector<[32] x f32>
114+
return %res : vector<[32] x f32>
115+
}
116+
117+
// CHECK-LABEL: func.func @tan_fixed(
118+
// CHECK-SAME: %[[VAL_0:.*]]: vector<8xf32>,
119+
// CHECK-SAME: %[[VAL_1:.*]]: i64) -> vector<8xf32> {
120+
// CHECK: %[[VAL_2:.*]] = arith.constant 0.000000e+00 : f32
121+
// CHECK: %[[VAL_3:.*]] = "vcix.v.sv"(%[[VAL_0]], %[[VAL_2]]) <{opcode = 0 : i64}> : (vector<8xf32>, f32) -> vector<8xf32>
122+
// CHECK: return %[[VAL_3]] : vector<8xf32>
123+
// CHECK: }
124+
func.func @tan_fixed(%a: vector<8 x f32>, %rvl: i64) -> vector<8 x f32> {
125+
%res = math.tan %a : vector<8 x f32>
126+
return %res : vector<8 x f32>
127+
}
128+
129+
// CHECK-LABEL: func.func @log(
130+
// CHECK-SAME: %[[VAL_0:.*]]: vector<[8]xf32>,
131+
// CHECK-SAME: %[[VAL_1:.*]]: i64) -> vector<[8]xf32> {
132+
// CHECK: %[[VAL_2:.*]] = arith.constant 0 : i32
133+
// CHECK: %[[VAL_3:.*]] = arith.constant 9 : i64
134+
// CHECK: %[[VAL_4:.*]] = "vcix.v.sv"(%[[VAL_0]], %[[VAL_2]], %[[VAL_3]]) <{opcode = 0 : i64}> : (vector<[8]xf32>, i32, i64) -> vector<[8]xf32>
135+
// CHECK: return %[[VAL_4]] : vector<[8]xf32>
136+
// CHECK: }
137+
func.func @log(%a: vector<[8] x f32>, %rvl: i64) -> vector<[8] x f32> {
138+
%res = math.log %a : vector<[8] x f32>
139+
return %res : vector<[8] x f32>
140+
}
141+
142+
// CHECK-LABEL: func.func @log_req_legalization(
143+
// CHECK-SAME: %[[VAL_0:.*]]: vector<[32]xf32>,
144+
// CHECK-SAME: %[[VAL_1:.*]]: i64) -> vector<[32]xf32> {
145+
// CHECK: %[[VAL_2:.*]] = arith.constant 0 : i32
146+
// CHECK: %[[VAL_3:.*]] = arith.constant 9 : i64
147+
// CHECK: %[[VAL_4:.*]] = arith.constant dense<0.000000e+00> : vector<[32]xf32>
148+
// CHECK: %[[VAL_5:.*]] = vector.scalable.extract %[[VAL_0]][0] : vector<[16]xf32> from vector<[32]xf32>
149+
// CHECK: %[[VAL_6:.*]] = "vcix.v.sv"(%[[VAL_5]], %[[VAL_2]], %[[VAL_3]]) <{opcode = 0 : i64}> : (vector<[16]xf32>, i32, i64) -> vector<[16]xf32>
150+
// CHECK: %[[VAL_7:.*]] = vector.scalable.insert %[[VAL_6]], %[[VAL_4]][0] : vector<[16]xf32> into vector<[32]xf32>
151+
// CHECK: %[[VAL_8:.*]] = vector.scalable.extract %[[VAL_0]][16] : vector<[16]xf32> from vector<[32]xf32>
152+
// CHECK: %[[VAL_9:.*]] = "vcix.v.sv"(%[[VAL_8]], %[[VAL_2]], %[[VAL_3]]) <{opcode = 0 : i64}> : (vector<[16]xf32>, i32, i64) -> vector<[16]xf32>
153+
// CHECK: %[[VAL_10:.*]] = vector.scalable.insert %[[VAL_9]], %[[VAL_7]][16] : vector<[16]xf32> into vector<[32]xf32>
154+
// CHECK: return %[[VAL_10]] : vector<[32]xf32>
155+
// CHECK: }
156+
func.func @log_req_legalization(%a: vector<[32] x f32>, %rvl: i64) -> vector<[32] x f32> {
157+
%res = math.log %a : vector<[32] x f32>
158+
return %res : vector<[32] x f32>
159+
}
160+
161+
// CHECK-LABEL: func.func @log_fixed(
162+
// CHECK-SAME: %[[VAL_0:.*]]: vector<8xf32>,
163+
// CHECK-SAME: %[[VAL_1:.*]]: i64) -> vector<8xf32> {
164+
// CHECK: %[[VAL_2:.*]] = arith.constant 0 : i32
165+
// CHECK: %[[VAL_3:.*]] = "vcix.v.sv"(%[[VAL_0]], %[[VAL_2]]) <{opcode = 0 : i64}> : (vector<8xf32>, i32) -> vector<8xf32>
166+
// CHECK: return %[[VAL_3]] : vector<8xf32>
167+
// CHECK: }
168+
func.func @log_fixed(%a: vector<8 x f32>, %rvl: i64) -> vector<8 x f32> {
169+
%res = math.log %a : vector<8 x f32>
170+
return %res : vector<8 x f32>
171+
}

‎mlir/test/lib/Conversion/CMakeLists.txt

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1,3 +1,4 @@
11
add_subdirectory(FuncToLLVM)
2+
add_subdirectory(MathToVCIX)
23
add_subdirectory(OneToNTypeConversion)
34
add_subdirectory(VectorToSPIRV)

‎mlir/test/lib/Conversion/MathToVCIX/CMakeLists.txt

Lines changed: 15 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,15 @@
1+
# Exclude tests from libMLIR.so
2+
add_mlir_library(MLIRTestMathToVCIX
3+
TestMathToVCIXConversion.cpp
4+
5+
EXCLUDE_FROM_LIBMLIR
6+
7+
LINK_LIBS PUBLIC
8+
MLIRArithDialect
9+
MLIRFuncDialect
10+
MLIRMathDialect
11+
MLIRVCIXDialect
12+
MLIRVectorDialect
13+
MLIRPass
14+
MLIRTransforms
15+
)

0 commit comments

Comments
 (0)