[PATCH] D111272: [InlineCost] model calls to llvm.is.constant* more carefully

[Kazu Hirata via Phabricator via llvm-commits]

kazu added a comment.

Hi Nick,

I really like the idea of evaluating `__builin_constant_p`.  If it evaluates to true, we are all good.  Now, if it evaluates to false for now but later evaluates to true after some inlining, the cost may be wrong.  Should we worry about that?  I am guessing that's OK because statements inside the "then" clause of `__builtin_constant_p` tend to fold very well in most real world code.

By the way, could we have a shorter test?  If we just want to see the effect of `__builtin_constant_p` being folded to false, two function definitions should suffice like so:

  ; RUN: opt %s -passes=inline -inline-threshold=20 -S | FileCheck %s
  
  declare void @foo()
  
  define void @callee(i64 %val) {
  entry:
    %cond = call i1 @llvm.is.constant.i64(i64 %val)
    br i1 %cond, label %cond.true, label %cond.false
  
  cond.true:                                        ; preds = %entry
  ; Rack up costs with a couple of function calls so that this function
  ; gets inlined only when @llvm.is.constant.i64 is folded.  In reality,
  ; the "then" clause of __builtin_constant_p tends to have statements
  ; that fold very well, so the cost of the "then" clause is not a huge
  ; concern.
    call void @foo()
    call void @foo()
    ret void
  
  cond.false:                                       ; preds = %entry
    ret void
  }
  
  define void @caller(i64 %val) {
  ; CHECK-LABEL: @caller(
  ; CHECK-NEXT:  entry:
  ; CHECK-NEXT:    [[COND_I:%.*]] = call i1 @llvm.is.constant.i64(i64 [[VAL:%.*]])
  ; CHECK-NEXT:    br i1 [[COND_I]], label %[[COND_TRUE_I:.*]], label %[[COND_FALSE_I:.*]]
  ; CHECK:       [[COND_TRUE_I]]:
  ; CHECK-NEXT:    call void @foo()
  ; CHECK-NEXT:    call void @foo()
  ; CHECK-NEXT:    br label %[[CALLEE_EXIT:.*]]
  ; CHECK:       [[COND_FALSE_I]]:
  ; CHECK-NEXT:    br label %[[CALLEE_EXIT]]
  ; CHECK:       [[CALLEE_EXIT]]:
  ; CHECK-NEXT:    ret void
  entry:
    call void @callee(i64 %val)
    ret void
  }
  
  declare i1 @llvm.is.constant.i64(i64)


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D111272/new/

https://reviews.llvm.org/D111272