[AArch64] Small fix for getIntImmCost

[zatrazz]

Summary

It uses the generic AArch64_IMM::expandMOVImm to get the correct
number of instruction used in immediate materialization.

[efriedma]

Needs a testcase.

lib/Target/AArch64/AArch64TargetTransformInfo.cpp

50

What is this function actually supposed to compute? If it's just the number of instructions an AArch64::MOVi64imm would expand to, I don't understand what a cost of "0" is supposed to mean.

We currently don't have any code to try to count the number of instructions AArch64ExpandPseudo::expandMOVImm will eventually emit. The complete logic is complicated if you're trying to compute whether we'll generate 2, 3, or 4 instructions... and "countLeadingZeros" is a terrible approximation. But I guess that isn't really important for most uses of getIntImmCost anyway.

[zatrazz]

Updated patch based on previous comments. It depends on https://reviews.llvm.org/D58915. I am trying to come up with a testcase to actually test it. The the main difference for the cost analysis is just for some immediate that contains some 16-bit zero or one chunk (which will have the size adjusted from 3 to 2). Since they are not TCC_Free, TCC_Basic, or TCC_Expensive the change does not actually interfere in the further cost analysis.

[efriedma]

I would expect an effect at least in some cases... for example 0xBEEF000000000000 goes from 4 to 1, unless I'm misreading the code.

[zatrazz]

I added a testcase based on test/CodeGen/ARM/immcost.ll.

[efriedma]

LGTM

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
 //
 //===----------------------------------------------------------------------===//
 
+#include "AArch64ExpandImm.h"
 #include "AArch64TargetTransformInfo.h"
 #include "MCTargetDesc/AArch64AddressingModes.h"
 #include "llvm/Analysis/LoopInfo.h"
 #include "llvm/Analysis/TargetTransformInfo.h"
 #include "llvm/CodeGen/BasicTTIImpl.h"
 #include "llvm/CodeGen/CostTable.h"
 #include "llvm/CodeGen/TargetLowering.h"
 #include "llvm/IR/IntrinsicInst.h"

 /// method might only calculate a fraction of a larger immediate. Therefore it
 /// is valid to return a cost of ZERO.
 int AArch64TTIImpl::getIntImmCost(int64_t Val) {
   // Check if the immediate can be encoded within an instruction.
   if (Val == 0 || AArch64_AM::isLogicalImmediate(Val, 64))
     return 0;
 
   if (Val < 0)
     Val = ~Val;
 
   // Calculate how many moves we will need to materialize this constant.
-  unsigned LZ = countLeadingZeros((uint64_t)Val);
-  return (64 - LZ + 15) / 16;
+  SmallVector<AArch64_IMM::ImmInsnModel, 4> Insn;
+  AArch64_IMM::expandMOVImm(Val, 64, Insn);
+  return Insn.size();
 }
 
 /// Calculate the cost of materializing the given constant.
 int AArch64TTIImpl::getIntImmCost(const APInt &Imm, Type *Ty) {
   assert(Ty->isIntegerTy());
 
   unsigned BitSize = Ty->getPrimitiveSizeInBits();
   if (BitSize == 0)

test/CodeGen/AArch64/immcost.ll

+; RUN: llc -mtriple=aarch64-none-linux-gnu %s -o - -O1 -debug-only=consthoist 2>&1 | FileCheck %s
+; REQUIRES: asserts
+
+declare void @g(i64)
+
+; Single ORR.
+; CHECK:     Function: f1
+; CHECK-NOT: Collect constant
+define void @f1(i1 %cond) {
+entry:
+  call void @g(i64 -3)
+  br i1 %cond, label %true, label %ret
+
+true:
+  call void @g(i64 -3)
+  br label %ret
+
+ret:
+  ret void
+}
+
+; Constant is 0xBEEF000000000000, single MOVZ with shift.
+; CHECK:     Function: f2
+; CHECK-NOT: Collect constant
+define void @f2(i1 %cond, i64 %p, i64 %q) {
+entry:
+  %a = and i64 %p, 13758215386640154624
+  call void @g(i64 %a)
+  br i1 %cond, label %true, label %ret
+
+true:
+  %b = and i64 %q, 13758215386640154624
+  call void @g(i64 %b)
+  br label %ret
+
+ret:
+  ret void
+}
+
+; CHECK:     Function: f3
+; CHECK:     Collect constant i64 4294967103 from   %a = and i64 %p, 4294967103 with cost 2
+define void @f3(i1 %cond, i64 %p, i64 %q) {
+entry:
+  %a = and i64 %p, 4294967103
+  call void @g(i64 %a)
+  br i1 %cond, label %true, label %ret
+
+true:
+  %b = and i64 %q, 4294967103
+  call void @g(i64 %b)
+  br label %ret
+
+ret:
+  ret void
+}
+
+; CHECK:     Function: f4
+; Collect constant i64 -4688528683866062848 from   %a = and i64 %p, -4688528683866062848 with cost 2
+define void @f4(i1 %cond, i64 %p, i64 %q) {
+entry:
+  %a = and i64 %p, 13758215389843488768
+  call void @g(i64 %a)
+  br i1 %cond, label %true, label %ret
+
+true:
+  %b = and i64 %q, 13758215389843488768
+  call void @g(i64 %b)
+  br label %ret
+
+ret:
+  ret void
+}
+
+; CHECK:     Function: f5
+; Collect constant i64 88994925642865 from   %a = and i64 %p, 88994925642865 with cost 3
+define void @f5(i1 %cond, i64 %p, i64 %q) {
+entry:
+  %a = and i64 %p, 88994925642865
+  call void @g(i64 %a)
+  br i1 %cond, label %true, label %ret
+
+true:
+  %b = and i64 %q, 88994925642865
+  call void @g(i64 %b)
+  br label %ret
+
+ret:
+  ret void
+}
+
+; CHECK:     Function: f6
+; Collect constant i64 -4688439692143754127 from   %b = and i64 %q, -4688439692143754127 with cost 4
+define void @f6(i1 %cond, i64 %p, i64 %q) {
+entry:
+  %a = and i64 %p, 13758304381565797489
+  call void @g(i64 %a)
+  br i1 %cond, label %true, label %ret
+
+true:
+  %b = and i64 %q, 13758304381565797489
+  call void @g(i64 %b)
+  br label %ret
+
+ret:
+  ret void
+}