[TTI] Remove getOperationCost

[samparker]

Summary

This API call has been used recently with, a very valid, expectation that it would do something useful but it doesn't actually query any backend information. So, remove this method and merge its functionality into getUserCost. As well as that, also use getCastInstrCost to get a proper cost from the backend for the concerned instructions which compensates for the removal of the BasicTTI layer. The next step would be to use other useful API calls in getUserCost too.

[lebedev.ri]

llvm/test/Analysis/CostModel/X86/costmodel.ll

11 ↗

(On Diff #250167)

Changes here look wrong to me

[samparker]

llvm/test/Analysis/CostModel/X86/costmodel.ll

11 ↗

(On Diff #250167)

I was suspicious, but since these should now be the costs reported by the backend so I'd like to get some clarification. I'm assuming it's instead just returning a default cost.

[dmgreen]

llvm/include/llvm/Analysis/TargetTransformInfoImpl.h

92

This code is missing now?

Or at least the IntToPtr code was copied over, the PtrToInt wasn't and has become a cast.

[samparker]

llvm/include/llvm/Analysis/TargetTransformInfoImpl.h

92

Ah, I was intending to merge all the casts and so I've actually missed IntToPtr. This almost certainly the reason for the change, so I'll have a look at the default costs of casts.

[samparker]

Ah, I love reminding myself why I don't like working in this area... I still can't figure out why we need TTIImpl, BasicTTIImpl, TargetLoweringInfo and then the target-specific TTIs too, and worse, why the generic parts seem to produce different results given the same values! So the code in TargetTransformInfoImpl still needs to try to special-case int/ptr conversions (instead of BasicTTI), as well as sext/zext because of the interactions with the inline cost model... I'd welcome some education of the hows and whys of these layers! Anyway, the int/ptr conversion costs are back to their original values.

[reames]

You're mixing a bit much in this patch for it to be easily reviewable. I see a couple of small NFCs which should be pulled out landed, and then the patch rebased. 1) Pulling out static_cast in the getIntrinsicCost and 2) conversion of if chain to switch.

llvm/include/llvm/CodeGen/BasicTTIImpl.h

720–729

You appear to have dropped the bitcast equal size case.

[samparker]

Thanks @reames. I extracted out the couple of NFCs that you suggested. This patch also sinks int/ptr conversions into the default implementation of TargetTransformInfo so that the free costs can be calculated when only given the DataLayout.

[lebedev.ri]

Sanity check: i believe, as per llvm::TargetTransformInfo::getInstructionCost(),
there are three cost-models:

• throughput model (getInstructionThroughput())
• latency model (getInstructionLatency())
• size model (getUserCost())

I'm not sure what getOperationCost() is supposed to represent,
so i'm not sure how it's code should be redistributed should it be deleted.

llvm/include/llvm/Analysis/TargetTransformInfo.h

281–282

\c get*Cost

this isn't specific to getGEPCost at all

llvm/include/llvm/Analysis/TargetTransformInfoImpl.h

867–870

This is unreachable

[spatel]

In D76124#1929051, @lebedev.ri wrote:

Sanity check: i believe, as per llvm::TargetTransformInfo::getInstructionCost(),
there are three cost-models:

• throughput model (getInstructionThroughput())
• latency model (getInstructionLatency())
• size model (getUserCost())

I'm not sure what getOperationCost() is supposed to represent,
so i'm not sure how it's code should be redistributed should it be deleted.

It's likely that nobody knows at this point. Anything we can do to clean up and simplify these classes is welcome, but it probably requires cleaning up the user classes too because they've come to expect different meanings for these various vaguely/wrongly named APIs. Example in R43591:
https://bugs.llvm.org/show_bug.cgi?id=43591

[lebedev.ri]

ACK, what a mess.

[samparker]

Anything we can do to clean up and simplify these classes is welcome, but it probably requires cleaning up the user classes too

@spatel my aim for this patch was to hoist the getOperationCost functionality into its only user 'getUserCost', while also providing the backends a better chance of conveying costs. I know I've got a couple of comments from @lebedev.ri to see to, but do see any fundamental issues with this change?

[spatel]

In D76124#1943194, @samparker wrote:

Anything we can do to clean up and simplify these classes is welcome, but it probably requires cleaning up the user classes too

@spatel my aim for this patch was to hoist the getOperationCost functionality into its only user 'getUserCost', while also providing the backends a better chance of conveying costs. I know I've got a couple of comments from @lebedev.ri to see to, but do see any fundamental issues with this change?

Nope - looks like a valid confusion reduction step to me. Are we ok with the SystemZ change? cc @uweigand @jonpa

[samparker]

Removed a chunk of comments and folded more instructions into the switch statement.

[spatel]

Thought about this a bit more...

The SystemZ test shows a result that seems unlikely to be intended. The most obvious place where that will have an impact is SimplifyCFG.
I suspect we'll end up causing regressions and be on an endless revert/fix cycle as those get noticed.

Can we limit this patch to an NFC cleanup of the API (even if that means propagating a known wrong answer)?

After that, I'd look at correcting SimplifyCFG. That pass is using what is now defined as the cost size model, but that's not what it was intended to be as SimplifyCFG evolved:

/// Compute an abstract "cost" of speculating the given instruction,
/// which is assumed to be safe to speculate. TCC_Free means cheap,
/// TCC_Basic means less cheap, and TCC_Expensive means prohibitively
/// expensive.
static unsigned ComputeSpeculationCost(const User *I,
                                       const TargetTransformInfo &TTI) {
  assert(isSafeToSpeculativelyExecute(I) &&
         "Instruction is not safe to speculatively execute!");
  return TTI.getUserCost(I);
}

This should be the throughput cost and possibly a size cost add-on to limit damage?

[samparker]

Can we limit this patch to an NFC cleanup of the API (even if that means propagating a known wrong answer)?

I would certainly like to avoid the commit-revert cycle you describe! I will try, but I fear creating a true NFC will be hard but I'll have a go, at least I should be able to get rid of the test change relatively easily.

[uweigand]

Looking simply at the SystemZ test case change, for the icmp/[zs]ext case (fun1/fun2), we actually need three instructions (compare, load zero, conditional move), so the change seems reasonable.

For the fun5 case, we actually can do the extension in a single instruction if the input is already in a register, so that change looks wrong. On the other hand, if I understand correctly, with the new approach after this patch we actually have greater control in the backend TTI and could fix that case there?

Then overall I guess I'd be OK with this.

[samparker]

Thanks for taking a look @uweigand, but I've now removed the change that affected the SystemZ test. I'll like to re-add it after this patch. There's also other parts that I'd like to change, like returning the actual cost reported, instead of sometimes only returning the result if it's 'free'. There's also cases where two API calls are used in an attempt to get a 'free' answer. I'm hoping that with some continued refactoring and reorganising, we can reduce the number of calls and further empower the backends.

[samparker]

Ping.

[spatel]

Is this NFC now? I added some sanity tests for x86 here:
rGa2bb19c
...but this patch doesn't apply to master cleanly, so I could not verify if that wiggles or not.

llvm/include/llvm/Analysis/TargetTransformInfoImpl.h

890–892

I know we're in some intermediate phase of rewriting this, but this seems backwards.
getCastInstrCost() returns a raw unsigned value, so do we want to check for that and convert to an enum cost here (and below for the extend opcodes)?

if (getCastInstrCost(Opcode, Ty, OpTy, dyn_cast<Instruction>(U)) == 0)
    return TargetTransformInfo::TCC_Free;

[samparker]

llvm/include/llvm/Analysis/TargetTransformInfoImpl.h

890–892

Ok, I'll rebase this and take a look.

[samparker]

Thanks @spatel for adding those extra tests, they highlighted changes around bitcasts:

; CHECK-NEXT: Cost Model: Found an estimated cost of 1 for instruction: %r = bitcast double %x to i64
Printing analysis 'Cost Model Analysis' for function 'bitcast_f64_i64':
note: possible intended match here
Cost Model: Found an estimated cost of 0 for instruction: %r = bitcast double %x to i64

; CHECK-NEXT: Cost Model: Found an estimated cost of 1 for instruction: %r = bitcast i64 %x to double
Printing analysis 'Cost Model Analysis' for function 'bitcast_i64_f64':
note: possible intended match here
Cost Model: Found an estimated cost of 0 for instruction: %r = bitcast i64 %x to double

So now 'TargetTTI' is not queried for bitcasts, unlike trunc and ptr conversions. Though I'm still very hesitate to say this is an NFC, because of the various layers and ordering of the calls, I think it is now trending that way.

[spatel]

llvm/include/llvm/Analysis/TargetTransformInfoImpl.h

876

The earlier review comment shifted, but I think it still applies. The GEP opcode is always handled above here, right?

893

This still isn't clear to me (let me know if I'm misunderstanding and/or reading too much into this).

getCastInstrCost() returns some integer value as a cost. Do we really want to use the "TCC_Free" enum value as an alias for "0" in the comparison statement? If we are going to use that definition, then do we need to update the documentation comments to specify that TCC_Free is a designated return value and fixed at zero?

[samparker]

llvm/include/llvm/Analysis/TargetTransformInfoImpl.h

876

Ah, I've messed this up rebasing.

893

My immediate response was, 'isn't that the purpose of an enum?' But I now I think I know what you mean, though I don't feel that it really matters here and isn't out-of-line with how this layer already operates. Maybe it could be addressed at the same time as fixing the unsigned/int mess..? Also, the next step here will be to return the raw value anyway, without the condition, to get a more accurate answer.

[spatel]

llvm/include/llvm/Analysis/TargetTransformInfoImpl.h

893

Yes, I assumed that we were trying to move away from the bogus enum values, so it seemed backwards to create another use of those. If that's just a temporary splotch on the way to the better fix, it's ok with me.

[samparker]

Removed duplicate handling of GEPs.

[spatel]

LGTM, but give this a couple of days to see if anyone that commented earlier has more feedback.
I'm not sure what the policy is if another reviewer explicitly requests changes (ping @reames).
https://llvm.org/docs/CodeReview.html

[RKSimon]

@reames - please can you review - phab has you as the blocking reviewer

[samparker]

Polite ping for @reames as I'll be committing this in 24 hours, thanks.

llvm/include/llvm/Analysis/TargetTransformInfo.h

public:
   /// skipped by renaming the registers in the CPU, but they still are encoded
   /// and thus wouldn't be considered 'free' here.
   enum TargetCostConstants {
     TCC_Free = 0,     ///< Expected to fold away in lowering.
     TCC_Basic = 1,    ///< The cost of a typical 'add' instruction.
     TCC_Expensive = 4 ///< The cost of a 'div' instruction on x86.
   };
 
-  /// Estimate the cost of a specific operation when lowered.
-  ///
-  /// Note that this is designed to work on an arbitrary synthetic opcode, and
-  /// thus work for hypothetical queries before an instruction has even been
-  /// formed. However, this does *not* work for GEPs, and must not be called
-  /// for a GEP instruction. Instead, use the dedicated getGEPCost interface as
-  /// analyzing a GEP's cost required more information.
-  ///
-  /// Typically only the result type is required, and the operand type can be
-  /// omitted. However, if the opcode is one of the cast instructions, the
-  /// operand type is required.
-  ///
-  /// The returned cost is defined in terms of \c TargetCostConstants, see its
-  /// comments for a detailed explanation of the cost values.
-  int getOperationCost(unsigned Opcode, Type *Ty, Type *OpTy = nullptr) const;
-
   /// Estimate the cost of a GEP operation when lowered.
-  ///
-  /// The contract for this function is the same as \c getOperationCost except
-  /// that it supports an interface that provides extra information specific to
-  /// the GEP operation.
   int getGEPCost(Type *PointeeType, const Value *Ptr,
                  ArrayRef<const Value *> Operands) const;
 
   /// Estimate the cost of a EXT operation when lowered.
-  ///
-  /// The contract for this function is the same as \c getOperationCost except
-  /// that it supports an interface that provides extra information specific to
-  /// the EXT operation.
   int getExtCost(const Instruction *I, const Value *Src) const;
 
   /// Estimate the cost of a function call when lowered.
   ///
-  /// The contract for this is the same as \c getOperationCost except that it
-  /// supports an interface that provides extra information specific to call
-  /// instructions.
-  ///
   /// This is the most basic query for estimating call cost: it only knows the
   /// function type and (potentially) the number of arguments at the call site.
   /// The latter is only interesting for varargs function types.
   int getCallCost(FunctionType *FTy, int NumArgs = -1,
                   const User *U = nullptr) const;
 
   /// Estimate the cost of calling a specific function when lowered.
   ///
public:
   /// table.
   unsigned getEstimatedNumberOfCaseClusters(const SwitchInst &SI,
                                             unsigned &JTSize,
                                             ProfileSummaryInfo *PSI,
                                             BlockFrequencyInfo *BFI) const;
 
   /// Estimate the cost of a given IR user when lowered.
   ///
   /// This can estimate the cost of either a ConstantExpr or Instruction when
-  /// lowered. It has two primary advantages over the \c getOperationCost and
-  /// \c getGEPCost above, and one significant disadvantage: it can only be
-  /// used when the IR construct has already been formed.
-  ///
-  /// The advantages are that it can inspect the SSA use graph to reason more
-  /// accurately about the cost. For example, all-constant-GEPs can often be
-  /// folded into a load or other instruction, but if they are used in some
-  /// other context they may not be folded. This routine can distinguish such
-  /// cases.
+  /// lowered.
   ///
   /// \p Operands is a list of operands which can be a result of transformations
   /// of the current operands. The number of the operands on the list must equal
   /// to the number of the current operands the IR user has. Their order on the
   /// list must be the same as the order of the current operands the IR user
   /// has.
   ///
   /// The returned cost is defined in terms of \c TargetCostConstants, see its
private:
 
   std::unique_ptr<Concept> TTIImpl;
 };
 
 class TargetTransformInfo::Concept {
 public:
   virtual ~Concept() = 0;
   virtual const DataLayout &getDataLayout() const = 0;
-  virtual int getOperationCost(unsigned Opcode, Type *Ty, Type *OpTy) = 0;
   virtual int getGEPCost(Type *PointeeType, const Value *Ptr,
                          ArrayRef<const Value *> Operands) = 0;
   virtual int getExtCost(const Instruction *I, const Value *Src) = 0;
   virtual int getCallCost(FunctionType *FTy, int NumArgs, const User *U) = 0;
   virtual int getCallCost(const Function *F, int NumArgs, const User *U) = 0;
   virtual int getCallCost(const Function *F,
                           ArrayRef<const Value *> Arguments, const User *U) = 0;
   virtual unsigned getInliningThresholdMultiplier() = 0;

 public:
   Model(T Impl) : Impl(std::move(Impl)) {}
   ~Model() override {}
 
   const DataLayout &getDataLayout() const override {
     return Impl.getDataLayout();
   }
 
-  int getOperationCost(unsigned Opcode, Type *Ty, Type *OpTy) override {
-    return Impl.getOperationCost(Opcode, Ty, OpTy);
-  }
   int getGEPCost(Type *PointeeType, const Value *Ptr,
                  ArrayRef<const Value *> Operands) override {
     return Impl.getGEPCost(PointeeType, Ptr, Operands);
   }
   int getExtCost(const Instruction *I, const Value *Src) override {
     return Impl.getExtCost(I, Src);
   }
   int getCallCost(FunctionType *FTy, int NumArgs, const User *U) override {

llvm/include/llvm/Analysis/TargetTransformInfoImpl.h

 public:
   // Provide value semantics. MSVC requires that we spell all of these out.
   TargetTransformInfoImplBase(const TargetTransformInfoImplBase &Arg)
       : DL(Arg.DL) {}
   TargetTransformInfoImplBase(TargetTransformInfoImplBase &&Arg) : DL(Arg.DL) {}
 
   const DataLayout &getDataLayout() const { return DL; }
 
-  unsigned getOperationCost(unsigned Opcode, Type *Ty, Type *OpTy) {
-    switch (Opcode) {
-    default:
-      // By default, just classify everything as 'basic'.
-      return TTI::TCC_Basic;
-
-    case Instruction::GetElementPtr:
-      llvm_unreachable("Use getGEPCost for GEP operations!");
-
-    case Instruction::BitCast:
-      assert(OpTy && "Cast instructions must provide the operand type");
-      if (Ty == OpTy || (Ty->isPointerTy() && OpTy->isPointerTy()))
-        // Identity and pointer-to-pointer casts are free.
-        return TTI::TCC_Free;
-
-      // Otherwise, the default basic cost is used.
-      return TTI::TCC_Basic;
-
-    case Instruction::Freeze:
-      // Freeze operation is free because it should be lowered into a register
-      // use without any register copy in assembly code.
-      return TTI::TCC_Free;
-
-    case Instruction::FDiv:
-    case Instruction::FRem:
-    case Instruction::SDiv:
-    case Instruction::SRem:
-    case Instruction::UDiv:
-    case Instruction::URem:
-      return TTI::TCC_Expensive;
-
-    case Instruction::IntToPtr: {
-      // An inttoptr cast is free so long as the input is a legal integer type
-      // which doesn't contain values outside the range of a pointer.
-      unsigned OpSize = OpTy->getScalarSizeInBits();
-      if (DL.isLegalInteger(OpSize) &&
-          OpSize <= DL.getPointerTypeSizeInBits(Ty))
-        return TTI::TCC_Free;
-
-      // Otherwise it's not a no-op.
-      return TTI::TCC_Basic;
-    }
-    case Instruction::PtrToInt: {
-      // A ptrtoint cast is free so long as the result is large enough to store
-      // the pointer, and a legal integer type.
-      unsigned DestSize = Ty->getScalarSizeInBits();
-      if (DL.isLegalInteger(DestSize) &&
-          DestSize >= DL.getPointerTypeSizeInBits(OpTy))
-        return TTI::TCC_Free;
-
-      // Otherwise it's not a no-op.
-      return TTI::TCC_Basic;
-    }
-    case Instruction::Trunc:
-      // trunc to a native type is free (assuming the target has compare and
-      // shift-right of the same width).
-      if (DL.isLegalInteger(DL.getTypeSizeInBits(Ty)))
-        return TTI::TCC_Free;
-
-      return TTI::TCC_Basic;
-    }
-  }
-
   int getGEPCost(Type *PointeeType, const Value *Ptr,
                  ArrayRef<const Value *> Operands) {
     // In the basic model, we just assume that all-constant GEPs will be folded
     // into their uses via addressing modes.
     for (unsigned Idx = 0, Size = Operands.size(); Idx != Size; ++Idx)
       if (!isa<Constant>(Operands[Idx]))
         return TTI::TCC_Basic;
 
public:
   }
 
   unsigned getShuffleCost(TTI::ShuffleKind Kind, Type *Ty, int Index,
                           Type *SubTp) {
     return 1;
   }
 
   unsigned getCastInstrCost(unsigned Opcode, Type *Dst, Type *Src,
-                            const Instruction *I) { return 1; }
+                            const Instruction *I) {
+    switch (Opcode) {
+    default:
+      break;
+    case Instruction::IntToPtr: {
+      unsigned SrcSize = Src->getScalarSizeInBits();
+      if (DL.isLegalInteger(SrcSize) &&
+          SrcSize <= DL.getPointerTypeSizeInBits(Dst))
+        return 0;
+      break;
+    }
+    case Instruction::PtrToInt: {
+      unsigned DstSize = Dst->getScalarSizeInBits();
+      if (DL.isLegalInteger(DstSize) &&
+          DstSize >= DL.getPointerTypeSizeInBits(Src))
+        return 0;
+      break;
+    }
+    case Instruction::BitCast:
+      if (Dst == Src || (Dst->isPointerTy() && Src->isPointerTy()))
+        // Identity and pointer-to-pointer casts are free.
+        return 0;
+      break;
+    case Instruction::Trunc:
+      // trunc to a native type is free (assuming the target has compare and
+      // shift-right of the same width).
+      if (DL.isLegalInteger(DL.getTypeSizeInBits(Dst)))
+        return 0;
+      break;
+    }
+    return 1;
+  }
 
   unsigned getExtractWithExtendCost(unsigned Opcode, Type *Dst,
                                     VectorType *VecTy, unsigned Index) {
     return 1;
   }
 
   unsigned getCFInstrCost(unsigned Opcode) { return 1; }
 
unsigned getIntrinsicCost(Intrinsic::ID IID, Type *RetTy,
     SmallVector<Type *, 8> ParamTys;
     ParamTys.reserve(Arguments.size());
     for (unsigned Idx = 0, Size = Arguments.size(); Idx != Size; ++Idx)
       ParamTys.push_back(Arguments[Idx]->getType());
     return static_cast<T *>(this)->getIntrinsicCost(IID, RetTy, ParamTys, U);
   }
 
   unsigned getUserCost(const User *U, ArrayRef<const Value *> Operands) {
-    if (isa<PHINode>(U))
-      return TTI::TCC_Free; // Model all PHI nodes as free.
-
-    if (isa<ExtractValueInst>(U))
-      return TTI::TCC_Free; // Model all ExtractValue nodes as free.
-
-    if (isa<FreezeInst>(U))
-      return TTI::TCC_Free; // Model all Freeze nodes as free.
-
-    // Static alloca doesn't generate target instructions.
-    if (auto *A = dyn_cast<AllocaInst>(U))
-      if (A->isStaticAlloca())
-        return TTI::TCC_Free;
-
     auto *TargetTTI = static_cast<T *>(this);
-
-    if (const GEPOperator *GEP = dyn_cast<GEPOperator>(U))
-      return TargetTTI->getGEPCost(GEP->getSourceElementType(),
-                                   GEP->getPointerOperand(),
-                                   Operands.drop_front());
-
     if (auto CS = ImmutableCallSite(U)) {
       const Function *F = CS.getCalledFunction();
       if (!F) {
         // Just use the called value type.
         Type *FTy = CS.getCalledValue()->getType()->getPointerElementType();
         return TargetTTI->getCallCost(cast<FunctionType>(FTy),
                                       CS.arg_size(), U);
       }
 
       SmallVector<const Value *, 8> Arguments(CS.arg_begin(), CS.arg_end());
       return TargetTTI->getCallCost(F, Arguments, U);
     }
 
-    if (isa<SExtInst>(U) || isa<ZExtInst>(U) || isa<FPExtInst>(U))
-      // The old behaviour of generally treating extensions of icmp to be free
-      // has been removed. A target that needs it should override getUserCost().
-      return TargetTTI->getExtCost(cast<Instruction>(U), Operands.back());
-
-    return TargetTTI->getOperationCost(Operator::getOpcode(U), U->getType(),
-        U->getNumOperands() == 1 ? U->getOperand(0)->getType() : nullptr);
+    Type *Ty = U->getType();
+    Type *OpTy =
+      U->getNumOperands() == 1 ? U->getOperand(0)->getType() : nullptr;
+    unsigned Opcode = Operator::getOpcode(U);
+    switch (Opcode) {
+    default:
+      break;
+    case Instruction::PHI:
+    case Instruction::ExtractValue:
+    case Instruction::Freeze:
+      return TTI::TCC_Free;
+    case Instruction::Alloca:
+      if (cast<AllocaInst>(U)->isStaticAlloca())
+        return TTI::TCC_Free;
+      break;
+    case Instruction::GetElementPtr: {
+      const GEPOperator *GEP = cast<GEPOperator>(U);
+      return TargetTTI->getGEPCost(GEP->getSourceElementType(),
+                                   GEP->getPointerOperand(),
+                                   Operands.drop_front());
+    }
+    case Instruction::FDiv:
+    case Instruction::FRem:
+    case Instruction::SDiv:
+    case Instruction::SRem:
+    case Instruction::UDiv:
+    case Instruction::URem:
+      return TTI::TCC_Expensive;
+    case Instruction::IntToPtr:
+    case Instruction::PtrToInt:
+      if (getCastInstrCost(Opcode, Ty, OpTy, dyn_cast<Instruction>(U)) ==
+          TargetTransformInfo::TCC_Free)
+        return 0;
+      return TargetTTI->getCastInstrCost(Opcode, Ty, OpTy,
+                                         dyn_cast<Instruction>(U));
+    case Instruction::FPExt:
+    case Instruction::SExt:
+    case Instruction::ZExt:
+      if (TargetTTI->getExtCost(cast<Instruction>(U), Operands.back()) ==
+          TargetTransformInfo::TCC_Free)
+        return 0;
+      break;
+    case Instruction::BitCast:
+    case Instruction::Trunc:
+      return TargetTTI->getCastInstrCost(Opcode, Ty, OpTy,
+                                         cast<Instruction>(U));
+    }
+    // By default, just classify everything as 'basic'.
+    return TTI::TCC_Basic;
   }
 
   int getInstructionLatency(const Instruction *I) {
     SmallVector<const Value *, 4> Operands(I->value_op_begin(),
                                            I->value_op_end());
     if (getUserCost(I, Operands) == TTI::TCC_Free)
       return 0;
 

llvm/include/llvm/CodeGen/BasicTTIImpl.h

unsigned getFPOpCost(Type *Ty) {
     // general.
     const TargetLoweringBase *TLI = getTLI();
     EVT VT = TLI->getValueType(DL, Ty);
     if (TLI->isOperationLegalOrCustomOrPromote(ISD::FADD, VT))
       return TargetTransformInfo::TCC_Basic;
     return TargetTransformInfo::TCC_Expensive;
   }
 
-  unsigned getOperationCost(unsigned Opcode, Type *Ty, Type *OpTy) {
-    const TargetLoweringBase *TLI = getTLI();
-    switch (Opcode) {
-    default: break;
-    case Instruction::Trunc:
-      if (TLI->isTruncateFree(OpTy, Ty))
-        return TargetTransformInfo::TCC_Free;
-      return TargetTransformInfo::TCC_Basic;
-    case Instruction::ZExt:
-      if (TLI->isZExtFree(OpTy, Ty))
-        return TargetTransformInfo::TCC_Free;
-      return TargetTransformInfo::TCC_Basic;
-
-    case Instruction::AddrSpaceCast:
-      if (TLI->isFreeAddrSpaceCast(OpTy->getPointerAddressSpace(),
-                                   Ty->getPointerAddressSpace()))
-        return TargetTransformInfo::TCC_Free;
-      return TargetTransformInfo::TCC_Basic;
-    }
-
-    return BaseT::getOperationCost(Opcode, Ty, OpTy);
-  }
-
   unsigned getInliningThresholdMultiplier() { return 1; }
 
   int getInlinerVectorBonusPercent() { return 150; }
 
   void getUnrollingPreferences(Loop *L, ScalarEvolution &SE,
                                TTI::UnrollingPreferences &UP) {
     // This unrolling functionality is target independent, but to provide some
     // motivation for its intended use, for x86:
default:
       break;
     case Instruction::Trunc:
       // Check for NOOP conversions.
       if (TLI->isTruncateFree(SrcLT.second, DstLT.second))
         return 0;
       LLVM_FALLTHROUGH;
     case Instruction::BitCast:
       // Bitcast between types that are legalized to the same type are free.
       if (SrcLT.first == DstLT.first && SrcSize == DstSize)
         return 0;
       break;
     case Instruction::ZExt:
       if (TLI->isZExtFree(SrcLT.second, DstLT.second))
         return 0;
       break;
     case Instruction::AddrSpaceCast:
       if (TLI->isFreeAddrSpaceCast(Src->getPointerAddressSpace(),
                                    Dst->getPointerAddressSpace()))
         return 0;
       break;
     }
 
     // If this is a zext/sext of a load, return 0 if the corresponding
     // extending load exists on target.
     if ((Opcode == Instruction::ZExt || Opcode == Instruction::SExt) &&
         I && isa<LoadInst>(I->getOperand(0))) {

llvm/lib/Analysis/TargetTransformInfo.cpp

 TargetTransformInfo::TargetTransformInfo(TargetTransformInfo &&Arg)
     : TTIImpl(std::move(Arg.TTIImpl)) {}
 
 TargetTransformInfo &TargetTransformInfo::operator=(TargetTransformInfo &&RHS) {
   TTIImpl = std::move(RHS.TTIImpl);
   return *this;
 }
 
-int TargetTransformInfo::getOperationCost(unsigned Opcode, Type *Ty,
-                                          Type *OpTy) const {
-  int Cost = TTIImpl->getOperationCost(Opcode, Ty, OpTy);
-  assert(Cost >= 0 && "TTI should not produce negative costs!");
-  return Cost;
-}
-
 int TargetTransformInfo::getCallCost(FunctionType *FTy, int NumArgs,
                                      const User *U) const {
   int Cost = TTIImpl->getCallCost(FTy, NumArgs, U);
   assert(Cost >= 0 && "TTI should not produce negative costs!");
   return Cost;
 }
 
 int TargetTransformInfo::getCallCost(const Function *F,