[CostModel] Model all `extractvalue`s as free.

[lebedev.ri]

Summary

As disscussed in https://reviews.llvm.org/D65148#1606412,
extractvalue don't actually generate any code,
so we should treat them as free.

[greened]

LGTM, though are we sure this is true for all targets? The comments in the referenced patch only consider X86. I'm pretty sure it is true for common architectures like AArch64 but I'm not as sure for more exotic things.

[lebedev.ri]

In D66098#1627477, @greened wrote:

LGTM, though are we sure this is true for all targets? The comments in the referenced patch only consider X86. I'm pretty sure it is true for common architectures like AArch64 but I'm not as sure for more exotic things.

I have asked the exact same question before:

In D65148#1625432, @craig.topper wrote:

In D65148#1624962, @lebedev.ri wrote:

In D65148#1624762, @craig.topper wrote:

Did anything happen with the extractvalue cost suggestion?

I was planning to look into that, and i just did. Some observations:

1. I'm not sure we can literally treat any extractvalue as free, it clearly isn't: https://godbolt.org/z/6wIxAa

For the short cases, the mov belongs to the return not the extractvalue. For the large cases all of that code is the result of passing an array by value.

So it seems to be the right thing to do..

[greened]

In D66098#1629828, @lebedev.ri wrote:

In D66098#1627477, @greened wrote:

LGTM, though are we sure this is true for all targets? The comments in the referenced patch only consider X86. I'm pretty sure it is true for common architectures like AArch64 but I'm not as sure for more exotic things.

I have asked the exact same question before:

In D65148#1625432, @craig.topper wrote:

In D65148#1624962, @lebedev.ri wrote:

In D65148#1624762, @craig.topper wrote:

Did anything happen with the extractvalue cost suggestion?

I was planning to look into that, and i just did. Some observations:

1. I'm not sure we can literally treat any extractvalue as free, it clearly isn't: https://godbolt.org/z/6wIxAa

For the short cases, the mov belongs to the return not the extractvalue. For the large cases all of that code is the result of passing an array by value.

So it seems to be the right thing to do..

Well, my point is that thread only considers X86. Are we sure this is true for all targets?

[lebedev.ri]

Can anyone from non-X86 comment if this assumption still holds for those arches?
I suspect it does, but would be good to confirm.

[jmolloy]

I can't think of a counterexample for the other architectures I know about.

[lebedev.ri]

In D66098#1648808, @jmolloy wrote:

I can't think of a counterexample for the other architectures I know about.

That is reassuring, and in-line with other comments.
Does anyone feel confident-enough about it to review/stamp?

[jmolloy]

I think I'm happy to stamp. I can't think of why this patch might be wrong, and it's easy to back out if someone finds a counterexample. LGTM.

[dmgreen]

I ran some ARM and AArch64 tests, which agreed that this is OK for those architectures (although they are probably already covered by what James said above).

[lebedev.ri]

In D66098#1650630, @jmolloy wrote:

I think I'm happy to stamp. I can't think of why this patch might be wrong, and it's easy to back out if someone finds a counterexample. LGTM.

In D66098#1650646, @dmgreen wrote:

I ran some ARM and AArch64 tests, which agreed that this is OK for those architectures (although they are probably already covered by what James said above).

Thank you for the review!

llvm/trunk/include/llvm/Analysis/TargetTransformInfoImpl.h

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.
+
     // Static alloca doesn't generate target instructions.
     if (auto *A = dyn_cast<AllocaInst>(U))
       if (A->isStaticAlloca())
         return TTI::TCC_Free;
 
     if (const GEPOperator *GEP = dyn_cast<GEPOperator>(U)) {
       return static_cast<T *>(this)->getGEPCost(GEP->getSourceElementType(),
                                                 GEP->getPointerOperand(),

llvm/trunk/lib/Analysis/TargetTransformInfo.cpp

case Instruction::InsertElement: {
     const InsertElementInst * IE = cast<InsertElementInst>(I);
     ConstantInt *CI = dyn_cast<ConstantInt>(IE->getOperand(2));
     unsigned Idx = -1;
     if (CI)
       Idx = CI->getZExtValue();
     return getVectorInstrCost(I->getOpcode(),
                                    IE->getType(), Idx);
   }
+  case Instruction::ExtractValue:
+    return 0; // Model all ExtractValue nodes as free.
   case Instruction::ShuffleVector: {
     const ShuffleVectorInst *Shuffle = cast<ShuffleVectorInst>(I);
     Type *Ty = Shuffle->getType();
     Type *SrcTy = Shuffle->getOperand(0)->getType();
 
     // TODO: Identify and add costs for insert subvector, etc.
     int SubIndex;
     if (Shuffle->isExtractSubvectorMask(SubIndex))

llvm/trunk/test/Analysis/CostModel/AArch64/aggregates.ll

 ; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
 ; RUN: opt < %s -mtriple=aarch64-unknown-linux-gnu -cost-model -cost-kind=throughput -analyze | FileCheck %s --check-prefixes=ALL,THROUGHPUT
 ; RUN: opt < %s -mtriple=aarch64-unknown-linux-gnu -cost-model -cost-kind=latency -analyze | FileCheck %s --check-prefixes=ALL,LATENCY
 ; RUN: opt < %s -mtriple=aarch64-unknown-linux-gnu -cost-model -cost-kind=code-size -analyze | FileCheck %s --check-prefixes=ALL,CODESIZE
 
 define i32 @extract_first_i32({i32, i32} %agg) {
 ; THROUGHPUT-LABEL: 'extract_first_i32'
-; THROUGHPUT-NEXT:  Cost Model: Unknown cost for instruction: %r = extractvalue { i32, i32 } %agg, 0
+; THROUGHPUT-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: %r = extractvalue { i32, i32 } %agg, 0
 ; THROUGHPUT-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: ret i32 %r
 ;
 ; LATENCY-LABEL: 'extract_first_i32'
-; LATENCY-NEXT:  Cost Model: Found an estimated cost of 1 for instruction: %r = extractvalue { i32, i32 } %agg, 0
+; LATENCY-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: %r = extractvalue { i32, i32 } %agg, 0
 ; LATENCY-NEXT:  Cost Model: Found an estimated cost of 1 for instruction: ret i32 %r
 ;
 ; CODESIZE-LABEL: 'extract_first_i32'
-; CODESIZE-NEXT:  Cost Model: Found an estimated cost of 1 for instruction: %r = extractvalue { i32, i32 } %agg, 0
+; CODESIZE-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: %r = extractvalue { i32, i32 } %agg, 0
 ; CODESIZE-NEXT:  Cost Model: Found an estimated cost of 1 for instruction: ret i32 %r
 ;
   %r = extractvalue {i32, i32} %agg, 0
   ret i32 %r
 }
 
 define i32 @extract_second_i32({i32, i32} %agg) {
 ; THROUGHPUT-LABEL: 'extract_second_i32'
-; THROUGHPUT-NEXT:  Cost Model: Unknown cost for instruction: %r = extractvalue { i32, i32 } %agg, 1
+; THROUGHPUT-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: %r = extractvalue { i32, i32 } %agg, 1
 ; THROUGHPUT-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: ret i32 %r
 ;
 ; LATENCY-LABEL: 'extract_second_i32'
-; LATENCY-NEXT:  Cost Model: Found an estimated cost of 1 for instruction: %r = extractvalue { i32, i32 } %agg, 1
+; LATENCY-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: %r = extractvalue { i32, i32 } %agg, 1
 ; LATENCY-NEXT:  Cost Model: Found an estimated cost of 1 for instruction: ret i32 %r
 ;
 ; CODESIZE-LABEL: 'extract_second_i32'
-; CODESIZE-NEXT:  Cost Model: Found an estimated cost of 1 for instruction: %r = extractvalue { i32, i32 } %agg, 1
+; CODESIZE-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: %r = extractvalue { i32, i32 } %agg, 1
 ; CODESIZE-NEXT:  Cost Model: Found an estimated cost of 1 for instruction: ret i32 %r
 ;
   %r = extractvalue {i32, i32} %agg, 1
   ret i32 %r
 }
 
 define i32 @extract_i32({i32, i1} %agg) {
 ; THROUGHPUT-LABEL: 'extract_i32'
-; THROUGHPUT-NEXT:  Cost Model: Unknown cost for instruction: %r = extractvalue { i32, i1 } %agg, 0
+; THROUGHPUT-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: %r = extractvalue { i32, i1 } %agg, 0
 ; THROUGHPUT-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: ret i32 %r
 ;
 ; LATENCY-LABEL: 'extract_i32'
-; LATENCY-NEXT:  Cost Model: Found an estimated cost of 1 for instruction: %r = extractvalue { i32, i1 } %agg, 0
+; LATENCY-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: %r = extractvalue { i32, i1 } %agg, 0
 ; LATENCY-NEXT:  Cost Model: Found an estimated cost of 1 for instruction: ret i32 %r
 ;
 ; CODESIZE-LABEL: 'extract_i32'
-; CODESIZE-NEXT:  Cost Model: Found an estimated cost of 1 for instruction: %r = extractvalue { i32, i1 } %agg, 0
+; CODESIZE-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: %r = extractvalue { i32, i1 } %agg, 0
 ; CODESIZE-NEXT:  Cost Model: Found an estimated cost of 1 for instruction: ret i32 %r
 ;
   %r = extractvalue {i32, i1} %agg, 0
   ret i32 %r
 }
 
 define i1 @extract_i1({i32, i1} %agg) {
 ; THROUGHPUT-LABEL: 'extract_i1'
-; THROUGHPUT-NEXT:  Cost Model: Unknown cost for instruction: %r = extractvalue { i32, i1 } %agg, 1
+; THROUGHPUT-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: %r = extractvalue { i32, i1 } %agg, 1
 ; THROUGHPUT-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: ret i1 %r
 ;
 ; LATENCY-LABEL: 'extract_i1'
-; LATENCY-NEXT:  Cost Model: Found an estimated cost of 1 for instruction: %r = extractvalue { i32, i1 } %agg, 1
+; LATENCY-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: %r = extractvalue { i32, i1 } %agg, 1
 ; LATENCY-NEXT:  Cost Model: Found an estimated cost of 1 for instruction: ret i1 %r
 ;
 ; CODESIZE-LABEL: 'extract_i1'
-; CODESIZE-NEXT:  Cost Model: Found an estimated cost of 1 for instruction: %r = extractvalue { i32, i1 } %agg, 1
+; CODESIZE-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: %r = extractvalue { i32, i1 } %agg, 1
 ; CODESIZE-NEXT:  Cost Model: Found an estimated cost of 1 for instruction: ret i1 %r
 ;
   %r = extractvalue {i32, i1} %agg, 1
   ret i1 %r
 }
 
 define float @extract_float({i32, float} %agg) {
 ; THROUGHPUT-LABEL: 'extract_float'
-; THROUGHPUT-NEXT:  Cost Model: Unknown cost for instruction: %r = extractvalue { i32, float } %agg, 1
+; THROUGHPUT-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: %r = extractvalue { i32, float } %agg, 1
 ; THROUGHPUT-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: ret float %r
 ;
 ; LATENCY-LABEL: 'extract_float'
-; LATENCY-NEXT:  Cost Model: Found an estimated cost of 3 for instruction: %r = extractvalue { i32, float } %agg, 1
+; LATENCY-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: %r = extractvalue { i32, float } %agg, 1
 ; LATENCY-NEXT:  Cost Model: Found an estimated cost of 1 for instruction: ret float %r
 ;
 ; CODESIZE-LABEL: 'extract_float'
-; CODESIZE-NEXT:  Cost Model: Found an estimated cost of 1 for instruction: %r = extractvalue { i32, float } %agg, 1
+; CODESIZE-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: %r = extractvalue { i32, float } %agg, 1
 ; CODESIZE-NEXT:  Cost Model: Found an estimated cost of 1 for instruction: ret float %r
 ;
   %r = extractvalue {i32, float} %agg, 1
   ret float %r
 }
 
 define [42 x i42] @extract_array({i32, [42 x i42]} %agg) {
 ; THROUGHPUT-LABEL: 'extract_array'
-; THROUGHPUT-NEXT:  Cost Model: Unknown cost for instruction: %r = extractvalue { i32, [42 x i42] } %agg, 1
+; THROUGHPUT-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: %r = extractvalue { i32, [42 x i42] } %agg, 1
 ; THROUGHPUT-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: ret [42 x i42] %r
 ;
 ; LATENCY-LABEL: 'extract_array'
-; LATENCY-NEXT:  Cost Model: Found an estimated cost of 1 for instruction: %r = extractvalue { i32, [42 x i42] } %agg, 1
+; LATENCY-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: %r = extractvalue { i32, [42 x i42] } %agg, 1
 ; LATENCY-NEXT:  Cost Model: Found an estimated cost of 1 for instruction: ret [42 x i42] %r
 ;
 ; CODESIZE-LABEL: 'extract_array'
-; CODESIZE-NEXT:  Cost Model: Found an estimated cost of 1 for instruction: %r = extractvalue { i32, [42 x i42] } %agg, 1
+; CODESIZE-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: %r = extractvalue { i32, [42 x i42] } %agg, 1
 ; CODESIZE-NEXT:  Cost Model: Found an estimated cost of 1 for instruction: ret [42 x i42] %r
 ;
   %r = extractvalue {i32, [42 x i42]} %agg, 1
   ret [42 x i42] %r
 }
 
 define <42 x i42> @extract_vector({i32, <42 x i42>} %agg) {
 ; THROUGHPUT-LABEL: 'extract_vector'
-; THROUGHPUT-NEXT:  Cost Model: Unknown cost for instruction: %r = extractvalue { i32, <42 x i42> } %agg, 1
+; THROUGHPUT-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: %r = extractvalue { i32, <42 x i42> } %agg, 1
 ; THROUGHPUT-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: ret <42 x i42> %r
 ;
 ; LATENCY-LABEL: 'extract_vector'
-; LATENCY-NEXT:  Cost Model: Found an estimated cost of 1 for instruction: %r = extractvalue { i32, <42 x i42> } %agg, 1
+; LATENCY-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: %r = extractvalue { i32, <42 x i42> } %agg, 1
 ; LATENCY-NEXT:  Cost Model: Found an estimated cost of 1 for instruction: ret <42 x i42> %r
 ;
 ; CODESIZE-LABEL: 'extract_vector'
-; CODESIZE-NEXT:  Cost Model: Found an estimated cost of 1 for instruction: %r = extractvalue { i32, <42 x i42> } %agg, 1
+; CODESIZE-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: %r = extractvalue { i32, <42 x i42> } %agg, 1
 ; CODESIZE-NEXT:  Cost Model: Found an estimated cost of 1 for instruction: ret <42 x i42> %r
 ;
   %r = extractvalue {i32, <42 x i42>} %agg, 1
   ret <42 x i42> %r
 }
 
 %T1 = type { i32, float, <4 x i1> }
 
 define %T1 @extract_struct({i32, %T1} %agg) {
 ; THROUGHPUT-LABEL: 'extract_struct'
-; THROUGHPUT-NEXT:  Cost Model: Unknown cost for instruction: %r = extractvalue { i32, %T1 } %agg, 1
+; THROUGHPUT-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: %r = extractvalue { i32, %T1 } %agg, 1
 ; THROUGHPUT-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: ret %T1 %r
 ;
 ; LATENCY-LABEL: 'extract_struct'
-; LATENCY-NEXT:  Cost Model: Found an estimated cost of 1 for instruction: %r = extractvalue { i32, %T1 } %agg, 1
+; LATENCY-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: %r = extractvalue { i32, %T1 } %agg, 1
 ; LATENCY-NEXT:  Cost Model: Found an estimated cost of 1 for instruction: ret %T1 %r
 ;
 ; CODESIZE-LABEL: 'extract_struct'
-; CODESIZE-NEXT:  Cost Model: Found an estimated cost of 1 for instruction: %r = extractvalue { i32, %T1 } %agg, 1
+; CODESIZE-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: %r = extractvalue { i32, %T1 } %agg, 1
 ; CODESIZE-NEXT:  Cost Model: Found an estimated cost of 1 for instruction: ret %T1 %r
 ;
   %r = extractvalue {i32, %T1} %agg, 1
   ret %T1 %r
 }

llvm/trunk/test/Analysis/CostModel/X86/aggregates.ll

 ; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py
 ; RUN: opt < %s -mtriple=x86_64-unknown-linux-gnu -cost-model -cost-kind=throughput -analyze | FileCheck %s --check-prefixes=ALL,THROUGHPUT
 ; RUN: opt < %s -mtriple=x86_64-unknown-linux-gnu -cost-model -cost-kind=latency -analyze | FileCheck %s --check-prefixes=ALL,LATENCY
 ; RUN: opt < %s -mtriple=x86_64-unknown-linux-gnu -cost-model -cost-kind=code-size -analyze | FileCheck %s --check-prefixes=ALL,CODESIZE
 
 define i32 @extract_first_i32({i32, i32} %agg) {
 ; THROUGHPUT-LABEL: 'extract_first_i32'
-; THROUGHPUT-NEXT:  Cost Model: Unknown cost for instruction: %r = extractvalue { i32, i32 } %agg, 0
+; THROUGHPUT-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: %r = extractvalue { i32, i32 } %agg, 0
 ; THROUGHPUT-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: ret i32 %r
 ;
 ; LATENCY-LABEL: 'extract_first_i32'
-; LATENCY-NEXT:  Cost Model: Found an estimated cost of 1 for instruction: %r = extractvalue { i32, i32 } %agg, 0
+; LATENCY-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: %r = extractvalue { i32, i32 } %agg, 0
 ; LATENCY-NEXT:  Cost Model: Found an estimated cost of 1 for instruction: ret i32 %r
 ;
 ; CODESIZE-LABEL: 'extract_first_i32'
-; CODESIZE-NEXT:  Cost Model: Found an estimated cost of 1 for instruction: %r = extractvalue { i32, i32 } %agg, 0
+; CODESIZE-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: %r = extractvalue { i32, i32 } %agg, 0
 ; CODESIZE-NEXT:  Cost Model: Found an estimated cost of 1 for instruction: ret i32 %r
 ;
   %r = extractvalue {i32, i32} %agg, 0
   ret i32 %r
 }
 
 define i32 @extract_second_i32({i32, i32} %agg) {
 ; THROUGHPUT-LABEL: 'extract_second_i32'
-; THROUGHPUT-NEXT:  Cost Model: Unknown cost for instruction: %r = extractvalue { i32, i32 } %agg, 1
+; THROUGHPUT-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: %r = extractvalue { i32, i32 } %agg, 1
 ; THROUGHPUT-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: ret i32 %r
 ;
 ; LATENCY-LABEL: 'extract_second_i32'
-; LATENCY-NEXT:  Cost Model: Found an estimated cost of 1 for instruction: %r = extractvalue { i32, i32 } %agg, 1
+; LATENCY-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: %r = extractvalue { i32, i32 } %agg, 1
 ; LATENCY-NEXT:  Cost Model: Found an estimated cost of 1 for instruction: ret i32 %r
 ;
 ; CODESIZE-LABEL: 'extract_second_i32'
-; CODESIZE-NEXT:  Cost Model: Found an estimated cost of 1 for instruction: %r = extractvalue { i32, i32 } %agg, 1
+; CODESIZE-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: %r = extractvalue { i32, i32 } %agg, 1
 ; CODESIZE-NEXT:  Cost Model: Found an estimated cost of 1 for instruction: ret i32 %r
 ;
   %r = extractvalue {i32, i32} %agg, 1
   ret i32 %r
 }
 
 define i32 @extract_i32({i32, i1} %agg) {
 ; THROUGHPUT-LABEL: 'extract_i32'
-; THROUGHPUT-NEXT:  Cost Model: Unknown cost for instruction: %r = extractvalue { i32, i1 } %agg, 0
+; THROUGHPUT-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: %r = extractvalue { i32, i1 } %agg, 0
 ; THROUGHPUT-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: ret i32 %r
 ;
 ; LATENCY-LABEL: 'extract_i32'
-; LATENCY-NEXT:  Cost Model: Found an estimated cost of 1 for instruction: %r = extractvalue { i32, i1 } %agg, 0
+; LATENCY-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: %r = extractvalue { i32, i1 } %agg, 0
 ; LATENCY-NEXT:  Cost Model: Found an estimated cost of 1 for instruction: ret i32 %r
 ;
 ; CODESIZE-LABEL: 'extract_i32'
-; CODESIZE-NEXT:  Cost Model: Found an estimated cost of 1 for instruction: %r = extractvalue { i32, i1 } %agg, 0
+; CODESIZE-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: %r = extractvalue { i32, i1 } %agg, 0
 ; CODESIZE-NEXT:  Cost Model: Found an estimated cost of 1 for instruction: ret i32 %r
 ;
   %r = extractvalue {i32, i1} %agg, 0
   ret i32 %r
 }
 
 define i1 @extract_i1({i32, i1} %agg) {
 ; THROUGHPUT-LABEL: 'extract_i1'
-; THROUGHPUT-NEXT:  Cost Model: Unknown cost for instruction: %r = extractvalue { i32, i1 } %agg, 1
+; THROUGHPUT-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: %r = extractvalue { i32, i1 } %agg, 1
 ; THROUGHPUT-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: ret i1 %r
 ;
 ; LATENCY-LABEL: 'extract_i1'
-; LATENCY-NEXT:  Cost Model: Found an estimated cost of 1 for instruction: %r = extractvalue { i32, i1 } %agg, 1
+; LATENCY-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: %r = extractvalue { i32, i1 } %agg, 1
 ; LATENCY-NEXT:  Cost Model: Found an estimated cost of 1 for instruction: ret i1 %r
 ;
 ; CODESIZE-LABEL: 'extract_i1'
-; CODESIZE-NEXT:  Cost Model: Found an estimated cost of 1 for instruction: %r = extractvalue { i32, i1 } %agg, 1
+; CODESIZE-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: %r = extractvalue { i32, i1 } %agg, 1
 ; CODESIZE-NEXT:  Cost Model: Found an estimated cost of 1 for instruction: ret i1 %r
 ;
   %r = extractvalue {i32, i1} %agg, 1
   ret i1 %r
 }
 
 define float @extract_float({i32, float} %agg) {
 ; THROUGHPUT-LABEL: 'extract_float'
-; THROUGHPUT-NEXT:  Cost Model: Unknown cost for instruction: %r = extractvalue { i32, float } %agg, 1
+; THROUGHPUT-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: %r = extractvalue { i32, float } %agg, 1
 ; THROUGHPUT-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: ret float %r
 ;
 ; LATENCY-LABEL: 'extract_float'
-; LATENCY-NEXT:  Cost Model: Found an estimated cost of 3 for instruction: %r = extractvalue { i32, float } %agg, 1
+; LATENCY-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: %r = extractvalue { i32, float } %agg, 1
 ; LATENCY-NEXT:  Cost Model: Found an estimated cost of 1 for instruction: ret float %r
 ;
 ; CODESIZE-LABEL: 'extract_float'
-; CODESIZE-NEXT:  Cost Model: Found an estimated cost of 1 for instruction: %r = extractvalue { i32, float } %agg, 1
+; CODESIZE-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: %r = extractvalue { i32, float } %agg, 1
 ; CODESIZE-NEXT:  Cost Model: Found an estimated cost of 1 for instruction: ret float %r
 ;
   %r = extractvalue {i32, float} %agg, 1
   ret float %r
 }
 
 define [42 x i42] @extract_array({i32, [42 x i42]} %agg) {
 ; THROUGHPUT-LABEL: 'extract_array'
-; THROUGHPUT-NEXT:  Cost Model: Unknown cost for instruction: %r = extractvalue { i32, [42 x i42] } %agg, 1
+; THROUGHPUT-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: %r = extractvalue { i32, [42 x i42] } %agg, 1
 ; THROUGHPUT-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: ret [42 x i42] %r
 ;
 ; LATENCY-LABEL: 'extract_array'
-; LATENCY-NEXT:  Cost Model: Found an estimated cost of 1 for instruction: %r = extractvalue { i32, [42 x i42] } %agg, 1
+; LATENCY-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: %r = extractvalue { i32, [42 x i42] } %agg, 1
 ; LATENCY-NEXT:  Cost Model: Found an estimated cost of 1 for instruction: ret [42 x i42] %r
 ;
 ; CODESIZE-LABEL: 'extract_array'
-; CODESIZE-NEXT:  Cost Model: Found an estimated cost of 1 for instruction: %r = extractvalue { i32, [42 x i42] } %agg, 1
+; CODESIZE-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: %r = extractvalue { i32, [42 x i42] } %agg, 1
 ; CODESIZE-NEXT:  Cost Model: Found an estimated cost of 1 for instruction: ret [42 x i42] %r
 ;
   %r = extractvalue {i32, [42 x i42]} %agg, 1
   ret [42 x i42] %r
 }
 
 define <42 x i42> @extract_vector({i32, <42 x i42>} %agg) {
 ; THROUGHPUT-LABEL: 'extract_vector'
-; THROUGHPUT-NEXT:  Cost Model: Unknown cost for instruction: %r = extractvalue { i32, <42 x i42> } %agg, 1
+; THROUGHPUT-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: %r = extractvalue { i32, <42 x i42> } %agg, 1
 ; THROUGHPUT-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: ret <42 x i42> %r
 ;
 ; LATENCY-LABEL: 'extract_vector'
-; LATENCY-NEXT:  Cost Model: Found an estimated cost of 1 for instruction: %r = extractvalue { i32, <42 x i42> } %agg, 1
+; LATENCY-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: %r = extractvalue { i32, <42 x i42> } %agg, 1
 ; LATENCY-NEXT:  Cost Model: Found an estimated cost of 1 for instruction: ret <42 x i42> %r
 ;
 ; CODESIZE-LABEL: 'extract_vector'
-; CODESIZE-NEXT:  Cost Model: Found an estimated cost of 1 for instruction: %r = extractvalue { i32, <42 x i42> } %agg, 1
+; CODESIZE-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: %r = extractvalue { i32, <42 x i42> } %agg, 1
 ; CODESIZE-NEXT:  Cost Model: Found an estimated cost of 1 for instruction: ret <42 x i42> %r
 ;
   %r = extractvalue {i32, <42 x i42>} %agg, 1
   ret <42 x i42> %r
 }
 
 %T1 = type { i32, float, <4 x i1> }
 
 define %T1 @extract_struct({i32, %T1} %agg) {
 ; THROUGHPUT-LABEL: 'extract_struct'
-; THROUGHPUT-NEXT:  Cost Model: Unknown cost for instruction: %r = extractvalue { i32, %T1 } %agg, 1
+; THROUGHPUT-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: %r = extractvalue { i32, %T1 } %agg, 1
 ; THROUGHPUT-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: ret %T1 %r
 ;
 ; LATENCY-LABEL: 'extract_struct'
-; LATENCY-NEXT:  Cost Model: Found an estimated cost of 1 for instruction: %r = extractvalue { i32, %T1 } %agg, 1
+; LATENCY-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: %r = extractvalue { i32, %T1 } %agg, 1
 ; LATENCY-NEXT:  Cost Model: Found an estimated cost of 1 for instruction: ret %T1 %r
 ;
 ; CODESIZE-LABEL: 'extract_struct'
-; CODESIZE-NEXT:  Cost Model: Found an estimated cost of 1 for instruction: %r = extractvalue { i32, %T1 } %agg, 1
+; CODESIZE-NEXT:  Cost Model: Found an estimated cost of 0 for instruction: %r = extractvalue { i32, %T1 } %agg, 1
 ; CODESIZE-NEXT:  Cost Model: Found an estimated cost of 1 for instruction: ret %T1 %r
 ;
   %r = extractvalue {i32, %T1} %agg, 1
   ret %T1 %r
 }