[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

49

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

 /// Calculate the cost of materializing a 64-bit value. This helper
 /// 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 (AArch64_AM::isAnyMOVWMovAlias(Val, 64))
+    return 1;
+
   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;
 }
 
int AArch64TTIImpl::getIntImmCost(const APInt &Imm, Type *Ty) {
   // Split the constant into 64-bit chunks and calculate the cost for each
   // chunk.
   int Cost = 0;
   for (unsigned ShiftVal = 0; ShiftVal < BitSize; ShiftVal += 64) {
     APInt Tmp = ImmVal.ashr(ShiftVal).sextOrTrunc(64);
     int64_t Val = Tmp.getSExtValue();
     Cost += getIntImmCost(Val);
   }
-  // We need at least one instruction to materialze the constant.
-  return std::max(1, Cost);
+  return Cost;
 }
 
 int AArch64TTIImpl::getIntImmCost(unsigned Opcode, unsigned Idx,
                                   const APInt &Imm, Type *Ty) {
   assert(Ty->isIntegerTy());
 
   unsigned BitSize = Ty->getPrimitiveSizeInBits();
   // There is no cost model for constants with a bit size of 0. Return TCC_Free