Skip to content

Commit a6a15c3

Browse files
ghehglanza
ghehg
authored and
lanza
committed
[CIR][CIRGen][Builtin][Neon] Lower neon_vmax_v and neon_vmaxq_v (#1239)
This implementation is different from OG in the sense we chose to use CIR op which eventually lowers to generic LLVM intrinsics instead of llvm.aarch64.neon intrinsics But down to the ASM level, [they are identical ](https://godbolt.org/z/Gbbos9z6Y).
1 parent 2c521be commit a6a15c3

File tree

2 files changed

+209
-122
lines changed

2 files changed

+209
-122
lines changed

‎clang/lib/CIR/CodeGen/CIRGenBuiltinAArch64.cpp‎

Lines changed: 9 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -3928,8 +3928,15 @@ CIRGenFunction::emitAArch64BuiltinExpr(unsigned BuiltinID, const CallExpr *E,
39283928
getLoc(E->getExprLoc()));
39293929
}
39303930
case NEON::BI__builtin_neon_vmax_v:
3931-
case NEON::BI__builtin_neon_vmaxq_v:
3932-
llvm_unreachable("NEON::BI__builtin_neon_vmaxq_v NYI");
3931+
case NEON::BI__builtin_neon_vmaxq_v: {
3932+
mlir::Location loc = getLoc(E->getExprLoc());
3933+
Ops[0] = builder.createBitcast(Ops[0], ty);
3934+
Ops[1] = builder.createBitcast(Ops[1], ty);
3935+
if (cir::isFPOrFPVectorTy(ty)) {
3936+
return builder.create<cir::FMaximumOp>(loc, Ops[0], Ops[1]);
3937+
}
3938+
return builder.create<cir::BinOp>(loc, cir::BinOpKind::Max, Ops[0], Ops[1]);
3939+
}
39333940
case NEON::BI__builtin_neon_vmaxh_f16: {
39343941
llvm_unreachable("NEON::BI__builtin_neon_vmaxh_f16 NYI");
39353942
}

‎clang/test/CIR/CodeGen/AArch64/neon.c‎

Lines changed: 200 additions & 120 deletions
Original file line numberDiff line numberDiff line change
@@ -4270,132 +4270,207 @@ uint64x2_t test_vrshlq_u64(uint64x2_t a, int64x2_t b) {
42704270
// return vsliq_n_p64(a, b, 0);
42714271
// }
42724272

4273-
// NYI-LABEL: @test_vmax_s8(
4274-
// NYI: [[VMAX_I:%.*]] = call <8 x i8> @llvm.aarch64.neon.smax.v8i8(<8 x i8> %a, <8 x i8> %b)
4275-
// NYI: ret <8 x i8> [[VMAX_I]]
4276-
// int8x8_t test_vmax_s8(int8x8_t a, int8x8_t b) {
4277-
// return vmax_s8(a, b);
4278-
// }
4273+
int8x8_t test_vmax_s8(int8x8_t a, int8x8_t b) {
4274+
return vmax_s8(a, b);
42794275

4280-
// NYI-LABEL: @test_vmax_s16(
4281-
// NYI: [[TMP0:%.*]] = bitcast <4 x i16> %a to <8 x i8>
4282-
// NYI: [[TMP1:%.*]] = bitcast <4 x i16> %b to <8 x i8>
4283-
// NYI: [[VMAX2_I:%.*]] = call <4 x i16> @llvm.aarch64.neon.smax.v4i16(<4 x i16> %a, <4 x i16> %b)
4284-
// NYI: ret <4 x i16> [[VMAX2_I]]
4285-
// int16x4_t test_vmax_s16(int16x4_t a, int16x4_t b) {
4286-
// return vmax_s16(a, b);
4287-
// }
4276+
// CIR-LABEL: vmax_s8
4277+
// CIR: cir.binop(max, {{%.*}}, {{%.*}}) : !cir.vector<!s8i x 8>
42884278

4289-
// NYI-LABEL: @test_vmax_s32(
4290-
// NYI: [[TMP0:%.*]] = bitcast <2 x i32> %a to <8 x i8>
4291-
// NYI: [[TMP1:%.*]] = bitcast <2 x i32> %b to <8 x i8>
4292-
// NYI: [[VMAX2_I:%.*]] = call <2 x i32> @llvm.aarch64.neon.smax.v2i32(<2 x i32> %a, <2 x i32> %b)
4293-
// NYI: ret <2 x i32> [[VMAX2_I]]
4294-
// int32x2_t test_vmax_s32(int32x2_t a, int32x2_t b) {
4295-
// return vmax_s32(a, b);
4296-
// }
4279+
// LLVM-LABEL: test_vmax_s8
4280+
// LLVM-SAME: (<8 x i8> [[a:%.*]], <8 x i8> [[b:%.*]])
4281+
// LLVM: [[VMAX_I:%.*]] = call <8 x i8> @llvm.smax.v8i8(<8 x i8> [[a]], <8 x i8> [[b]])
4282+
// LLVM: ret <8 x i8> [[VMAX_I]]
4283+
}
42974284

4298-
// NYI-LABEL: @test_vmax_u8(
4299-
// NYI: [[VMAX_I:%.*]] = call <8 x i8> @llvm.aarch64.neon.umax.v8i8(<8 x i8> %a, <8 x i8> %b)
4300-
// NYI: ret <8 x i8> [[VMAX_I]]
4301-
// uint8x8_t test_vmax_u8(uint8x8_t a, uint8x8_t b) {
4302-
// return vmax_u8(a, b);
4303-
// }
4285+
int16x4_t test_vmax_s16(int16x4_t a, int16x4_t b) {
4286+
return vmax_s16(a, b);
43044287

4305-
// NYI-LABEL: @test_vmax_u16(
4306-
// NYI: [[TMP0:%.*]] = bitcast <4 x i16> %a to <8 x i8>
4307-
// NYI: [[TMP1:%.*]] = bitcast <4 x i16> %b to <8 x i8>
4308-
// NYI: [[VMAX2_I:%.*]] = call <4 x i16> @llvm.aarch64.neon.umax.v4i16(<4 x i16> %a, <4 x i16> %b)
4309-
// NYI: ret <4 x i16> [[VMAX2_I]]
4310-
// uint16x4_t test_vmax_u16(uint16x4_t a, uint16x4_t b) {
4311-
// return vmax_u16(a, b);
4312-
// }
4288+
// CIR-LABEL: vmax_s16
4289+
// CIR: cir.binop(max, {{%.*}}, {{%.*}}) : !cir.vector<!s16i x 4>
43134290

4314-
// NYI-LABEL: @test_vmax_u32(
4315-
// NYI: [[TMP0:%.*]] = bitcast <2 x i32> %a to <8 x i8>
4316-
// NYI: [[TMP1:%.*]] = bitcast <2 x i32> %b to <8 x i8>
4317-
// NYI: [[VMAX2_I:%.*]] = call <2 x i32> @llvm.aarch64.neon.umax.v2i32(<2 x i32> %a, <2 x i32> %b)
4318-
// NYI: ret <2 x i32> [[VMAX2_I]]
4319-
// uint32x2_t test_vmax_u32(uint32x2_t a, uint32x2_t b) {
4320-
// return vmax_u32(a, b);
4321-
// }
4291+
// LLVM-LABEL: test_vmax_s16
4292+
// LLVM-SAME: (<4 x i16> [[a:%.*]], <4 x i16> [[b:%.*]])
4293+
// LLVM: [[TMP0:%.*]] = bitcast <4 x i16> [[a]] to <8 x i8>
4294+
// LLVM: [[TMP1:%.*]] = bitcast <4 x i16> [[b]] to <8 x i8>
4295+
// LLVM: [[VMAX2_I:%.*]] = call <4 x i16> @llvm.smax.v4i16(<4 x i16> [[a]], <4 x i16> [[b]])
4296+
// LLVM: ret <4 x i16> [[VMAX2_I]]
4297+
}
43224298

4323-
// NYI-LABEL: @test_vmax_f32(
4324-
// NYI: [[TMP0:%.*]] = bitcast <2 x float> %a to <8 x i8>
4325-
// NYI: [[TMP1:%.*]] = bitcast <2 x float> %b to <8 x i8>
4326-
// NYI: [[VMAX2_I:%.*]] = call <2 x float> @llvm.aarch64.neon.fmax.v2f32(<2 x float> %a, <2 x float> %b)
4327-
// NYI: ret <2 x float> [[VMAX2_I]]
4328-
// float32x2_t test_vmax_f32(float32x2_t a, float32x2_t b) {
4329-
// return vmax_f32(a, b);
4330-
// }
4299+
int32x2_t test_vmax_s32(int32x2_t a, int32x2_t b) {
4300+
return vmax_s32(a, b);
43314301

4332-
// NYI-LABEL: @test_vmaxq_s8(
4333-
// NYI: [[VMAX_I:%.*]] = call <16 x i8> @llvm.aarch64.neon.smax.v16i8(<16 x i8> %a, <16 x i8> %b)
4334-
// NYI: ret <16 x i8> [[VMAX_I]]
4335-
// int8x16_t test_vmaxq_s8(int8x16_t a, int8x16_t b) {
4336-
// return vmaxq_s8(a, b);
4337-
// }
4302+
// CIR-LABEL: vmax_s32
4303+
// CIR: cir.binop(max, {{%.*}}, {{%.*}}) : !cir.vector<!s32i x 2>
43384304

4339-
// NYI-LABEL: @test_vmaxq_s16(
4340-
// NYI: [[TMP0:%.*]] = bitcast <8 x i16> %a to <16 x i8>
4341-
// NYI: [[TMP1:%.*]] = bitcast <8 x i16> %b to <16 x i8>
4342-
// NYI: [[VMAX2_I:%.*]] = call <8 x i16> @llvm.aarch64.neon.smax.v8i16(<8 x i16> %a, <8 x i16> %b)
4343-
// NYI: ret <8 x i16> [[VMAX2_I]]
4344-
// int16x8_t test_vmaxq_s16(int16x8_t a, int16x8_t b) {
4345-
// return vmaxq_s16(a, b);
4346-
// }
4305+
// LLVM-LABEL: test_vmax_s32
4306+
// LLVM-SAME: (<2 x i32> [[a:%.*]], <2 x i32> [[b:%.*]])
4307+
// LLVM: [[TMP0:%.*]] = bitcast <2 x i32> [[a]] to <8 x i8>
4308+
// LLVM: [[TMP1:%.*]] = bitcast <2 x i32> [[b]] to <8 x i8>
4309+
// LLVM: [[VMAX2_I:%.*]] = call <2 x i32> @llvm.smax.v2i32(<2 x i32> [[a]], <2 x i32> [[b]])
4310+
// LLVM: ret <2 x i32> [[VMAX2_I]]
4311+
}
43474312

4348-
// NYI-LABEL: @test_vmaxq_s32(
4349-
// NYI: [[TMP0:%.*]] = bitcast <4 x i32> %a to <16 x i8>
4350-
// NYI: [[TMP1:%.*]] = bitcast <4 x i32> %b to <16 x i8>
4351-
// NYI: [[VMAX2_I:%.*]] = call <4 x i32> @llvm.aarch64.neon.smax.v4i32(<4 x i32> %a, <4 x i32> %b)
4352-
// NYI: ret <4 x i32> [[VMAX2_I]]
4353-
// int32x4_t test_vmaxq_s32(int32x4_t a, int32x4_t b) {
4354-
// return vmaxq_s32(a, b);
4355-
// }
4313+
uint8x8_t test_vmax_u8(uint8x8_t a, uint8x8_t b) {
4314+
return vmax_u8(a, b);
43564315

4357-
// NYI-LABEL: @test_vmaxq_u8(
4358-
// NYI: [[VMAX_I:%.*]] = call <16 x i8> @llvm.aarch64.neon.umax.v16i8(<16 x i8> %a, <16 x i8> %b)
4359-
// NYI: ret <16 x i8> [[VMAX_I]]
4360-
// uint8x16_t test_vmaxq_u8(uint8x16_t a, uint8x16_t b) {
4361-
// return vmaxq_u8(a, b);
4362-
// }
4316+
// CIR-LABEL: vmax_u8
4317+
// CIR: cir.binop(max, {{%.*}}, {{%.*}}) : !cir.vector<!u8i x 8>
43634318

4364-
// NYI-LABEL: @test_vmaxq_u16(
4365-
// NYI: [[TMP0:%.*]] = bitcast <8 x i16> %a to <16 x i8>
4366-
// NYI: [[TMP1:%.*]] = bitcast <8 x i16> %b to <16 x i8>
4367-
// NYI: [[VMAX2_I:%.*]] = call <8 x i16> @llvm.aarch64.neon.umax.v8i16(<8 x i16> %a, <8 x i16> %b)
4368-
// NYI: ret <8 x i16> [[VMAX2_I]]
4369-
// uint16x8_t test_vmaxq_u16(uint16x8_t a, uint16x8_t b) {
4370-
// return vmaxq_u16(a, b);
4371-
// }
4319+
// LLVM-LABEL: test_vmax_u8
4320+
// LLVM-SAME: (<8 x i8> [[a:%.*]], <8 x i8> [[b:%.*]])
4321+
// LLVM: [[VMAX_I:%.*]] = call <8 x i8> @llvm.umax.v8i8(<8 x i8> [[a]], <8 x i8> [[b]])
4322+
// LLVM: ret <8 x i8> [[VMAX_I]]
4323+
}
43724324

4373-
// NYI-LABEL: @test_vmaxq_u32(
4374-
// NYI: [[TMP0:%.*]] = bitcast <4 x i32> %a to <16 x i8>
4375-
// NYI: [[TMP1:%.*]] = bitcast <4 x i32> %b to <16 x i8>
4376-
// NYI: [[VMAX2_I:%.*]] = call <4 x i32> @llvm.aarch64.neon.umax.v4i32(<4 x i32> %a, <4 x i32> %b)
4377-
// NYI: ret <4 x i32> [[VMAX2_I]]
4378-
// uint32x4_t test_vmaxq_u32(uint32x4_t a, uint32x4_t b) {
4379-
// return vmaxq_u32(a, b);
4380-
// }
4325+
uint16x4_t test_vmax_u16(uint16x4_t a, uint16x4_t b) {
4326+
return vmax_u16(a, b);
43814327

4382-
// NYI-LABEL: @test_vmaxq_f32(
4383-
// NYI: [[TMP0:%.*]] = bitcast <4 x float> %a to <16 x i8>
4384-
// NYI: [[TMP1:%.*]] = bitcast <4 x float> %b to <16 x i8>
4385-
// NYI: [[VMAX2_I:%.*]] = call <4 x float> @llvm.aarch64.neon.fmax.v4f32(<4 x float> %a, <4 x float> %b)
4386-
// NYI: ret <4 x float> [[VMAX2_I]]
4387-
// float32x4_t test_vmaxq_f32(float32x4_t a, float32x4_t b) {
4388-
// return vmaxq_f32(a, b);
4389-
// }
4328+
// CIR-LABEL: vmax_u16
4329+
// CIR: cir.binop(max, {{%.*}}, {{%.*}}) : !cir.vector<!u16i x 4>
43904330

4391-
// NYI-LABEL: @test_vmaxq_f64(
4392-
// NYI: [[TMP0:%.*]] = bitcast <2 x double> %a to <16 x i8>
4393-
// NYI: [[TMP1:%.*]] = bitcast <2 x double> %b to <16 x i8>
4394-
// NYI: [[VMAX2_I:%.*]] = call <2 x double> @llvm.aarch64.neon.fmax.v2f64(<2 x double> %a, <2 x double> %b)
4395-
// NYI: ret <2 x double> [[VMAX2_I]]
4396-
// float64x2_t test_vmaxq_f64(float64x2_t a, float64x2_t b) {
4397-
// return vmaxq_f64(a, b);
4398-
// }
4331+
// LLVM-LABEL: test_vmax_u16
4332+
// LLVM-SAME: (<4 x i16> [[a:%.*]], <4 x i16> [[b:%.*]])
4333+
// LLVM: [[TMP0:%.*]] = bitcast <4 x i16> [[a]] to <8 x i8>
4334+
// LLVM: [[TMP1:%.*]] = bitcast <4 x i16> [[b]] to <8 x i8>
4335+
// LLVM: [[VMAX2_I:%.*]] = call <4 x i16> @llvm.umax.v4i16(<4 x i16> [[a]], <4 x i16> [[b]])
4336+
// LLVM: ret <4 x i16> [[VMAX2_I]]
4337+
}
4338+
4339+
uint32x2_t test_vmax_u32(uint32x2_t a, uint32x2_t b) {
4340+
return vmax_u32(a, b);
4341+
4342+
// CIR-LABEL: vmax_u32
4343+
// CIR: cir.binop(max, {{%.*}}, {{%.*}}) : !cir.vector<!u32i x 2>
4344+
4345+
// LLVM-LABEL: test_vmax_u32
4346+
// LLVM-SAME: (<2 x i32> [[a:%.*]], <2 x i32> [[b:%.*]])
4347+
// LLVM: [[TMP0:%.*]] = bitcast <2 x i32> [[a]] to <8 x i8>
4348+
// LLVM: [[TMP1:%.*]] = bitcast <2 x i32> [[b]] to <8 x i8>
4349+
// LLVM: [[VMAX2_I:%.*]] = call <2 x i32> @llvm.umax.v2i32(<2 x i32> [[a]], <2 x i32> [[b]])
4350+
// LLVM: ret <2 x i32> [[VMAX2_I]]
4351+
}
4352+
4353+
float32x2_t test_vmax_f32(float32x2_t a, float32x2_t b) {
4354+
return vmax_f32(a, b);
4355+
4356+
// CIR-LABEL: vmax_f32
4357+
// CIR: cir.fmaximum {{%.*}}, {{%.*}} : !cir.vector<!cir.float x 2>
4358+
4359+
// LLVM-LABEL: test_vmax_f32
4360+
// LLVM-SAME: (<2 x float> [[a:%.*]], <2 x float> [[b:%.*]])
4361+
// LLVM: [[TMP0:%.*]] = bitcast <2 x float> [[a]] to <8 x i8>
4362+
// LLVM: [[TMP1:%.*]] = bitcast <2 x float> [[b]] to <8 x i8>
4363+
// LLVM: [[VMAX2_I:%.*]] = call <2 x float> @llvm.maximum.v2f32(<2 x float> [[a]], <2 x float> [[b]])
4364+
// LLVM: ret <2 x float> [[VMAX2_I]]
4365+
}
4366+
4367+
int8x16_t test_vmaxq_s8(int8x16_t a, int8x16_t b) {
4368+
return vmaxq_s8(a, b);
4369+
4370+
// CIR-LABEL: vmaxq_s8
4371+
// CIR: cir.binop(max, {{%.*}}, {{%.*}}) : !cir.vector<!s8i x 16>
4372+
4373+
// LLVM-LABEL: test_vmaxq_s8
4374+
// LLVM-SAME: (<16 x i8> [[a:%.*]], <16 x i8> [[b:%.*]])
4375+
// LLVM: [[VMAX_I:%.*]] = call <16 x i8> @llvm.smax.v16i8(<16 x i8> [[a]], <16 x i8> [[b]])
4376+
// LLVM: ret <16 x i8> [[VMAX_I]]
4377+
}
4378+
4379+
int16x8_t test_vmaxq_s16(int16x8_t a, int16x8_t b) {
4380+
return vmaxq_s16(a, b);
4381+
4382+
// CIR-LABEL: vmaxq_s16
4383+
// CIR: cir.binop(max, {{%.*}}, {{%.*}}) : !cir.vector<!s16i x 8>
4384+
4385+
// LLVM-LABEL: test_vmaxq_s16
4386+
// LLVM-SAME: (<8 x i16> [[a:%.*]], <8 x i16> [[b:%.*]])
4387+
// LLVM: [[TMP0:%.*]] = bitcast <8 x i16> [[a]] to <16 x i8>
4388+
// LLVM: [[TMP1:%.*]] = bitcast <8 x i16> [[b]] to <16 x i8>
4389+
// LLVM: [[VMAX2_I:%.*]] = call <8 x i16> @llvm.smax.v8i16(<8 x i16> [[a]], <8 x i16> [[b]])
4390+
// LLVM: ret <8 x i16> [[VMAX2_I]]
4391+
}
4392+
4393+
int32x4_t test_vmaxq_s32(int32x4_t a, int32x4_t b) {
4394+
return vmaxq_s32(a, b);
4395+
4396+
// CIR-LABEL: vmaxq_s32
4397+
// CIR: cir.binop(max, {{%.*}}, {{%.*}}) : !cir.vector<!s32i x 4>
4398+
4399+
// LLVM-LABEL: test_vmaxq_s32
4400+
// LLVM-SAME: (<4 x i32> [[a:%.*]], <4 x i32> [[b:%.*]])
4401+
// LLVM: [[TMP0:%.*]] = bitcast <4 x i32> [[a]] to <16 x i8>
4402+
// LLVM: [[TMP1:%.*]] = bitcast <4 x i32> [[b]] to <16 x i8>
4403+
// LLVM: [[VMAX2_I:%.*]] = call <4 x i32> @llvm.smax.v4i32(<4 x i32> [[a]], <4 x i32> [[b]])
4404+
// LLVM: ret <4 x i32> [[VMAX2_I]]
4405+
}
4406+
4407+
uint8x16_t test_vmaxq_u8(uint8x16_t a, uint8x16_t b) {
4408+
return vmaxq_u8(a, b);
4409+
4410+
// CIR-LABEL: vmaxq_u8
4411+
// CIR: cir.binop(max, {{%.*}}, {{%.*}}) : !cir.vector<!u8i x 16>
4412+
4413+
// LLVM-LABEL: test_vmaxq_u8
4414+
// LLVM-SAME: (<16 x i8> [[a:%.*]], <16 x i8> [[b:%.*]])
4415+
// LLVM: [[VMAX_I:%.*]] = call <16 x i8> @llvm.umax.v16i8(<16 x i8> [[a]], <16 x i8> [[b]])
4416+
// LLVM: ret <16 x i8> [[VMAX_I]]
4417+
}
4418+
4419+
uint16x8_t test_vmaxq_u16(uint16x8_t a, uint16x8_t b) {
4420+
return vmaxq_u16(a, b);
4421+
4422+
// CIR-LABEL: vmaxq_u16
4423+
// CIR: cir.binop(max, {{%.*}}, {{%.*}}) : !cir.vector<!u16i x 8>
4424+
4425+
// LLVM-LABEL: test_vmaxq_u16
4426+
// LLVM-SAME: (<8 x i16> [[a:%.*]], <8 x i16> [[b:%.*]])
4427+
// LLVM: [[TMP0:%.*]] = bitcast <8 x i16> [[a]] to <16 x i8>
4428+
// LLVM: [[TMP1:%.*]] = bitcast <8 x i16> [[b]] to <16 x i8>
4429+
// LLVM: [[VMAX2_I:%.*]] = call <8 x i16> @llvm.umax.v8i16(<8 x i16> [[a]], <8 x i16> [[b]])
4430+
// LLVM: ret <8 x i16> [[VMAX2_I]]
4431+
}
4432+
4433+
uint32x4_t test_vmaxq_u32(uint32x4_t a, uint32x4_t b) {
4434+
return vmaxq_u32(a, b);
4435+
4436+
// CIR-LABEL: vmaxq_u32
4437+
// CIR: cir.binop(max, {{%.*}}, {{%.*}}) : !cir.vector<!u32i x 4>
4438+
4439+
// LLVM-LABEL: test_vmaxq_u32
4440+
// LLVM-SAME: (<4 x i32> [[a:%.*]], <4 x i32> [[b:%.*]])
4441+
// LLVM: [[TMP0:%.*]] = bitcast <4 x i32> [[a]] to <16 x i8>
4442+
// LLVM: [[TMP1:%.*]] = bitcast <4 x i32> [[b]] to <16 x i8>
4443+
// LLVM: [[VMAX2_I:%.*]] = call <4 x i32> @llvm.umax.v4i32(<4 x i32> [[a]], <4 x i32> [[b]])
4444+
// LLVM: ret <4 x i32> [[VMAX2_I]]
4445+
}
4446+
4447+
float32x4_t test_vmaxq_f32(float32x4_t a, float32x4_t b) {
4448+
return vmaxq_f32(a, b);
4449+
4450+
// CIR-LABEL: vmaxq_f32
4451+
// CIR: cir.fmaximum {{%.*}}, {{%.*}} : !cir.vector<!cir.float x 4>
4452+
4453+
// LLVM-LABEL: test_vmaxq_f32
4454+
// LLVM-SAME: (<4 x float> [[a:%.*]], <4 x float> [[b:%.*]])
4455+
// LLVM: [[TMP0:%.*]] = bitcast <4 x float> [[a]] to <16 x i8>
4456+
// LLVM: [[TMP1:%.*]] = bitcast <4 x float> [[b]] to <16 x i8>
4457+
// LLVM: [[VMAX2_I:%.*]] = call <4 x float> @llvm.maximum.v4f32(<4 x float> [[a]], <4 x float> [[b]])
4458+
// LLVM: ret <4 x float> [[VMAX2_I]]
4459+
}
4460+
4461+
float64x2_t test_vmaxq_f64(float64x2_t a, float64x2_t b) {
4462+
return vmaxq_f64(a, b);
4463+
4464+
// CIR-LABEL: vmaxq_f64
4465+
// CIR: cir.fmaximum {{%.*}}, {{%.*}} : !cir.vector<!cir.double x 2>
4466+
4467+
// LLVM-LABEL: test_vmaxq_f64
4468+
// LLVM-SAME: (<2 x double> [[a:%.*]], <2 x double> [[b:%.*]])
4469+
// LLVM: [[TMP0:%.*]] = bitcast <2 x double> [[a]] to <16 x i8>
4470+
// LLVM: [[TMP1:%.*]] = bitcast <2 x double> [[b]] to <16 x i8>
4471+
// LLVM: [[VMAX2_I:%.*]] = call <2 x double> @llvm.maximum.v2f64(<2 x double> [[a]], <2 x double> [[b]])
4472+
// LLVM: ret <2 x double> [[VMAX2_I]]
4473+
}
43994474

44004475
int8x8_t test_vmin_s8(int8x8_t a, int8x8_t b) {
44014476
return vmin_s8(a, b);
@@ -18586,14 +18661,19 @@ float64_t test_vaddvq_f64(float64x2_t a) {
1858618661
// return vabd_f64(a, b);
1858718662
// }
1858818663

18589-
// NYI-LABEL: @test_vmax_f64(
18590-
// NYI: [[TMP0:%.*]] = bitcast <1 x double> %a to <8 x i8>
18591-
// NYI: [[TMP1:%.*]] = bitcast <1 x double> %b to <8 x i8>
18592-
// NYI: [[VMAX2_I:%.*]] = call <1 x double> @llvm.aarch64.neon.fmax.v1f64(<1 x double> %a, <1 x double> %b)
18593-
// NYI: ret <1 x double> [[VMAX2_I]]
18594-
// float64x1_t test_vmax_f64(float64x1_t a, float64x1_t b) {
18595-
// return vmax_f64(a, b);
18596-
// }
18664+
float64x1_t test_vmax_f64(float64x1_t a, float64x1_t b) {
18665+
return vmax_f64(a, b);
18666+
18667+
// CIR-LABEL: vmax_f64
18668+
// CIR: cir.fmaximum {{%.*}}, {{%.*}} : !cir.vector<!cir.double x 1>
18669+
18670+
// LLVM-LABEL: test_vmax_f64
18671+
// LLVM-SAME: (<1 x double> [[a:%.*]], <1 x double> [[b:%.*]])
18672+
// LLVM: [[TMP0:%.*]] = bitcast <1 x double> [[a]] to <8 x i8>
18673+
// LLVM: [[TMP1:%.*]] = bitcast <1 x double> [[b]] to <8 x i8>
18674+
// LLVM: [[VMAX2_I:%.*]] = call <1 x double> @llvm.maximum.v1f64(<1 x double> [[a]], <1 x double> [[b]])
18675+
// LLVM: ret <1 x double> [[VMAX2_I]]
18676+
}
1859718677

1859818678
// NYI-LABEL: @test_vmaxnm_f64(
1859918679
// NYI: [[TMP0:%.*]] = bitcast <1 x double> %a to <8 x i8>

0 commit comments

Comments
 (0)