Implement correct cost for SVE bitcasts

[alban.bridonneau]

Summary

We have some bitcasts which we know will be simplified,
so their cost is zero.

[david-arm]

Looks like a nice improvement @alban.bridonneau! Just had one minor comment on the tests ...

llvm/test/Analysis/CostModel/AArch64/sve-bitcast.ll

10

Hi @alban.bridonneau, I think it's also worth adding tests for the inverse case i.e. bitcast <vscale x 2 x half> -> bitcast <vscale x 2 x i16>. The operations should also be free I think.

[alban.bridonneau]

Adding test cases for float to integer bitcasts

[alban.bridonneau]

llvm/test/Analysis/CostModel/AArch64/sve-bitcast.ll

10

Done. I also added the corresponding costs in the TTI

[david-arm]

LGTM! Thanks for the changes @alban.bridonneau.

llvm/lib/Target/AArch64/AArch64TargetTransformInfo.cpp

 //===-- AArch64TargetTransformInfo.cpp - AArch64 specific TTI -------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
InstructionCost AArch64TTIImpl::getCastInstrCost(unsigned Opcode, Type *Dst,
 
   EVT SrcTy = TLI->getValueType(DL, Src);
   EVT DstTy = TLI->getValueType(DL, Dst);
 
   if (!SrcTy.isSimple() || !DstTy.isSimple())
     return AdjustCost(
         BaseT::getCastInstrCost(Opcode, Dst, Src, CCH, CostKind, I));
 
   static const TypeConversionCostTblEntry
   ConversionTbl[] = {
     { ISD::TRUNCATE, MVT::v4i16, MVT::v4i32,  1 },
     { ISD::TRUNCATE, MVT::v4i32, MVT::v4i64,  0 },
     { ISD::TRUNCATE, MVT::v8i8,  MVT::v8i32,  3 },
     { ISD::TRUNCATE, MVT::v16i8, MVT::v16i32, 6 },
 
     // Truncations on nxvmiN
     { ISD::TRUNCATE, MVT::nxv2i1, MVT::nxv2i16, 1 },
ConversionTbl[] = {
     { ISD::FP_EXTEND, MVT::nxv4f64, MVT::nxv4f16, 2},
     { ISD::FP_EXTEND, MVT::nxv8f64, MVT::nxv8f16, 4},
 
     // Extend from nxvmf32 to nxvmf64.
     { ISD::FP_EXTEND, MVT::nxv2f64, MVT::nxv2f32, 1},
     { ISD::FP_EXTEND, MVT::nxv4f64, MVT::nxv4f32, 2},
     { ISD::FP_EXTEND, MVT::nxv8f64, MVT::nxv8f32, 6},
 
+    // Bitcasts
+    { ISD::BITCAST, MVT::nxv2f16, MVT::nxv2i16, 0 },
+    { ISD::BITCAST, MVT::nxv4f16, MVT::nxv4i16, 0 },
+    { ISD::BITCAST, MVT::nxv2f32, MVT::nxv2i32, 0 },
   };
 
   if (const auto *Entry = ConvertCostTableLookup(ConversionTbl, ISD,
                                                  DstTy.getSimpleVT(),
                                                  SrcTy.getSimpleVT()))
     return AdjustCost(Entry->Cost);
 
   return AdjustCost(

llvm/test/Analysis/CostModel/AArch64/sve-bitcast.ll

 ; RUN: opt -mtriple=aarch64-linux-gnu -mattr=+sve -cost-model -analyze < %s | FileCheck %s
 
+define <vscale x 2 x i64> @test_nxv2i64(<vscale x 2 x double> %a) {
+; CHECK-LABEL: test_nxv2i64
 ; CHECK: Found an estimated cost of 0 for instruction:   %b = bitcast <vscale x 2 x double> %a to <vscale x 2 x i64>
-
-define <vscale x 2 x i64> @foo(<vscale x 2 x double> %a, i32 %x) {
   %b = bitcast <vscale x 2 x double> %a to <vscale x 2 x i64>
   ret <vscale x 2 x i64> %b
 }
+
+define <vscale x 2 x half> @test_nxv2i16(<vscale x 2 x i16> %a) {
+; CHECK-LABEL: test_nxv2i16
+; CHECK: Found an estimated cost of 0 for instruction:   %b = bitcast <vscale x 2 x i16> %a to <vscale x 2 x half>
+  %b = bitcast <vscale x 2 x i16> %a to <vscale x 2 x half>
+  ret <vscale x 2 x half> %b
+}
+
+define <vscale x 4 x half> @test_nxv4i16(<vscale x 4 x i16> %a) {
+; CHECK-LABEL: test_nxv4i16
+; CHECK: Found an estimated cost of 0 for instruction:   %b = bitcast <vscale x 4 x i16> %a to <vscale x 4 x half>
+  %b = bitcast <vscale x 4 x i16> %a to <vscale x 4 x half>
+  ret <vscale x 4 x half> %b
+}
+
+define <vscale x 2 x float> @test_nxv2i32(<vscale x 2 x i32> %a) {
+; CHECK-LABEL: test_nxv2i32
+; CHECK: Found an estimated cost of 0 for instruction:   %b = bitcast <vscale x 2 x i32> %a to <vscale x 2 x float>
+  %b = bitcast <vscale x 2 x i32> %a to <vscale x 2 x float>
+  ret <vscale x 2 x float> %b
+}