Added llvm.is.constant intrinsic

[jyknight]

Summary

Add support for llvm.is.constant intrinsic (PR4898)

This adds llvm-side support for post-inline evaluation of the __builtin_constant_p GCC intrinsic.

[rengolin]

I'd add a bit more of tests, especially those that inspired this change...

--renato

docs/LangRef.rst

7178

... to the best of the compiler's knowledge ... :)

[• janusz]

Added a test case for inlining @llvm.is.constant

[• janusz]

Uploading again :)

[rengolin]

Thanks Janusz,

I'm adding Owen to review this patch, since it's not my area, but overall, the patch looks good.

About the tests, though the inline check is important, I was thinking something more elaborate.

Some examples that come to mind:

• static initializer
• generic function arguments
• function arguments where the function is static and only called one with a constant argument
• function arguments where the function is static and only called one with a variable argument
• expressions that will be simplified as constant because all variables were initialised with constants
• expressions that will NOT be simplified as constant because NOT all variables were initialised with constants

Those examples that *should* be constant and are not, should be marked as FIXME. Those examples that *should* NOT be constant and are, should be fixed before commit.

cheers,
--renato

test/CodeGen/Generic/inline-is-constant.ll

4

a more robust way would be to have two run lines, one with O0, another with O3, and use FileCheck for the True/False results.

[• janusz]

I agree that we should have more tests. I'd prefer to have an agreement that we want to add llvm.is.constant intrinsic before spending too much time on writing tests.

A follow up work is to add support for the new intrinsic in clang (__builtin_constant_p -> llvm.is.constant) and write more tests in C.

I have a few questions.

1. Do we want the code to promote or expand llvm.is.constant? On one hand it would make the code more complete but on the other it is not really required because zext() and trunc() don't change the 'constantness'

	%a = zext i1 %b to i32
	%v = call i1 @llvm.is.constant.i32(i32 %a)

and

	%a = trunc i256 %b to i32
	%v = call i1 @llvm.is.constant.i32(i32 %a)

will do the job. Is there a preference in the llvm community?

2. In my implementation llvm.is.constant is lowered to true/false rather late. Would it help in some cases if we added an early check in InstCombine? InstCombine would lower llvm.is.constant to true if the argument is known to be constant. Otherwise InstCombine would leave it unmodified.

[• janusz]

test/CodeGen/Generic/inline-is-constant.ll

4

If using lli is frowned upon, then the resolution is to call 'llc -debug' and search for the debug strings with FileCheck

[• rafael]

Ccing nick since it seems related to the enable_if attribute.

[• janusz]

Moved lowering llvm.is.constant to False from LegalizeDAG to SelectionDAG. Code to promote or expand llvm.is.constant is not required any more and the intrinsic works fine with different input integer types.

[rengolin]

docs/LangRef.rst

7164

As I understand, __builtin_constant_p can be used with any valid expression, and "constant" is the C semantics, so a numeric expression is constant if all its arguments are, string literals are always constant, but pointers are a bit more complicated.

Since this is a GNU extension and we're trying to implement it, it would be wise to add a FIXME and some comments on this documentation to that effect, if our intentions is to not expand to full expresisons, or to do so in the future.

[rengolin]

In D4276#14, @janusz wrote:

1. Do we want the code to promote or expand llvm.is.constant? On one hand it would make the code more complete but on the other it is not really required because zext() and trunc() don't change the 'constantness'

Depends on how hard would it be to infer constantness at a lower level with the added complexity. I'd say, as a general idea, leaving the IR untouched and adding logic to infer that later would be better, but I'm not sure of all the cases.

2. In my implementation llvm.is.constant is lowered to true/false rather late. Would it help in some cases if we added an early check in InstCombine? InstCombine would lower llvm.is.constant to true if the argument is known to be constant. Otherwise InstCombine would leave it unmodified.

Yes, that'd be great. I think we could teach even Clang about that, so that pre-processor constantness is explited at the front-end level. Though, I understand if those things take their time to get implemented.

[rengolin]

Any progress in this? If not, can we close this review?

[jyknight]

Taking this over.

[jyknight]

Rewrote patch significantly.

• Added support for other types.
• Deleted SelectionDAG-side IS_CONSTANT as unneeded.
• Added support in CodeGenPrepare to lower to false, as ISel cannot eliminate unreachable blocks. (similar to llvm.objectsize)

Updated and added more tests;

[efriedma]

It seems like you're waiting to fold llvm.is.constant until really late in the optimization pipeline; we probably want to fold it sometime in the "middle", so we get better optimization. Maybe just after function simplification passes; at that point, we're unlikely to get any more useful information about whether the argument is constant, and we want to simplify the code as much as possible before we run transforms like loop vectorization.

llvm/lib/Analysis/ConstantFolding.cpp

1592 ↗

(On Diff #142433)

Probably doesn't make sense to check for ConstantExpr here; if isManifestConstant is true for all the operands of a ConstantExpr, it should get constant-folded.

llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

5762 ↗

(On Diff #142433)

Indentation.

[jyknight]

In D4276#1067497, @efriedma wrote:

It seems like you're waiting to fold llvm.is.constant until really late in the optimization pipeline; we probably want to fold it sometime in the "middle", so we get better optimization. Maybe just after function simplification passes; at that point, we're unlikely to get any more useful information about whether the argument is constant, and we want to simplify the code as much as possible before we run transforms like loop vectorization.

The most important constraint is that it needs to occur after inlining.

However, we already have llvm.objectsize intrinsic, and I wanted to handle the final failure in the same place, so that __builtin_constant_p works when given __builtin_object_size as an argument, even when the __builtin_object_size is unevaluable (and returns -1).

E.g. in GCC, this code:

int f1(char* x) {
    if (__builtin_constant_p(__builtin_object_size(x, 0))) {
        return __builtin_object_size(x, 0);
    }
    return -9999;
}

int f2() {
    char x[1000];
    return f1(x);
}

compiles such that:

f1 -> returns (constant) -1.
f2 -> returns (constant) 1000.

It's possible that both of them should move somewhere else, though...

llvm/lib/Analysis/ConstantFolding.cpp

1592 ↗

(On Diff #142433)

If I remove that, then this clause fails in the test case:

@llvm.is.constant.p0i64(i64* inttoptr (i32 42 to i64*))

because there's no way to express a pointer with a constant value directly.

[efriedma]

I guess lowering llvm.objectsize and llvm.is.constant at the same time makes sense; okay. They should probably both be lowered earlier, though.

llvm/lib/Analysis/ConstantFolding.cpp

1592 ↗

(On Diff #142433)

Okay.

[void]

llvm/docs/LangRef.rst

14432–14433 ↗

(On Diff #142433)

This is true only for expressions that evaluate to constants not immediates, right?

Should you also mention that if a function with llvm.is.constant() is inlined, any constants fed into the inlined function may cause llvm.is.constant() to return true? (or something to that affect)

llvm/include/llvm/IR/Intrinsics.td

838 ↗

(On Diff #142433)

80-columns?

llvm/lib/Transforms/Scalar/SCCP.cpp

1176 ↗

(On Diff #142433)

This seems unrelated. Was it meant to be in this patch? If so, could you comment that it's specifically related to llvm.is.constant()?

[jyknight]

Ran clang-format.
Expanded on docs.

llvm/docs/LangRef.rst

14432–14433 ↗

(On Diff #142433)

If you build with -O0, constant folding is not done, so even the @test_constant() function will return false.

(Of course, at the C level, the __builtin_constant_p intrinsic will still return true at -O0 when given a frontend constant).

Updated the docs to mention inlining explicitly.

llvm/include/llvm/IR/Intrinsics.td

838 ↗

(On Diff #142433)

Fixed.

llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

5762 ↗

(On Diff #142433)

Fixed.

llvm/lib/Transforms/Scalar/SCCP.cpp

1176 ↗

(On Diff #142433)

It's due to llvm.is.constant being able to take a struct type as an argument. This code gets confused by seeing a call for which is canConstantFoldCallTo() returns true, but which can take a struct as an argument.

I'll add a bit to the commit message remarking why the change was made, but I don't think the code here really need mention llvm.is.constant.

[void]

llvm/docs/LangRef.rst

14432–14433 ↗

(On Diff #142433)

My comment is for documenting the llvm.is.constant intrinsic, not __builtin_constant_p(). :-) (People can write their own .ll files.) I just wanted to make sure that people know that this will evaluate to "true" even without constant folding:

%0 = i1 llvm.is.constant.i32(i32 37)

llvm/lib/Transforms/Scalar/SCCP.cpp

1176 ↗

(On Diff #142433)

I'm still a bit confused. This change will affect all call sites, not just those to llvm.is.constant. Or are you saying that the only time this situation will come up is when it involves the llvm.is.constant call?

[jyknight]

llvm/docs/LangRef.rst

14432–14433 ↗

(On Diff #142433)

Except that that it really _doesn't_ evaluate to true. :)

The only thing that turns a call to llvm.is.constant into "true" is the constant folding code, which doesn't get run in O0.

llvm/lib/Transforms/Scalar/SCCP.cpp

1176 ↗

(On Diff #142433)

This code cannot handle calls with a struct as an argument, it hits an assertion failure about not expecting a struct.

But it only ran in the first place when canConstantFoldCallTo returns true (see up a few lines at 1171), so it didn't actually come up before, because the other functions don't take structs as arguments.

[void]

llvm/docs/LangRef.rst

14432–14433 ↗

(On Diff #142433)

But why couldn't it evaluate to true at O0? Is there a valid reason why not? I mean, the intrinsic has to be lowered somehow at O0, so why not just evaluate it to true in cases like this?

llvm/lib/Transforms/Scalar/SCCP.cpp

1176 ↗

(On Diff #142433)

Ah! I see. Thanks.

[void]

Friendly ping? :-)

[jyknight]

llvm/docs/LangRef.rst

14432–14433 ↗

(On Diff #142433)

Yes, all the places it's lowered to false now in O0 (GlobalISel/IRTranslator.cpp, SelectionDAG/FastISel.cpp, SelectionDAG/SelectionDAGBuilder.cpp) could check if it can be folded to true first. It feels somewhat ugly to have to do that, though.

Of course, it's ugly that we have to do this last-chance lowering in 3 places in the first place. Same issue exists for llvm.objectsize too. Like efriedma suggested earlier, they should probably be both be lowered somewhere else...I'm not really sure where the best elsewhere to move it would be, though.

[void]

I have no more concerns with this patch.

Eli, Are you okay to approve this?

llvm/docs/LangRef.rst

14432–14433 ↗

(On Diff #142433)

It certainly is ugly that we have this in three places instead of one. Anyway, I suppose that as long as we document its behavior correctly, people won't complain. (And it's at -O0, so speed isn't the issue I suppose.)

[efriedma]

Needs a testcase for the SCCP fix. Otherwise LGTM.

[void]

Friendly ping. :-)

[Bharathi]

This feature would be very useful to us and testing this patch against our code base gave us an interesting case where llvm.is.constant (used in a conditional) is lowered to false in CodeGenPrepare and the dead branch that arises out of this lowering does not get eliminated. The code that gets generated after CodeGenPrepare pass has "br i1 false .." with both true and false conditions preserved and this propagates further and remains the same in the final assembly code.

In CodeGenPrepare::runOnFunction, ConstantFoldTerminator (which handles the br i1 false condition) is called only once and if after the transformation of ConstantFoldTerminator() and DeleteDeadBlock(), if we end up with code like "br i1 false", there is no further opportunity to clean them up. So calling the code under ' if (!DisableBranchOpts)' in a loop that is conditioned on MadeChange (similar to other places), fixes the issue. Is this reasonable ?

I wrote a patch to test this and I have one regression with llvm/test/CodeGen/AMDGPU/nested-loop-conditions.ll. I'm having some difficulty to determine if this warrants rewriting the test case to adjust with the new results or if this is a real issue.

Any pointers would be greatly appreciated. My simple fix (without any indentation changes) is:

--- a/llvm/lib/CodeGen/CodeGenPrepare.cpp
+++ b/llvm/lib/CodeGen/CodeGenPrepare.cpp
@@ -316,7 +316,9 @@ bool CodeGenPrepare::runOnFunction(Function &F) {
 
   SunkAddrs.clear();
 
+  MadeChange = true;
   if (!DisableBranchOpts) {
+  while (MadeChange) {
     MadeChange = false;
     SmallPtrSet<BasicBlock*, 8> WorkList;
     for (BasicBlock &BB : F) {
@@ -352,6 +354,7 @@ bool CodeGenPrepare::runOnFunction(Function &F) {
 
     EverMadeChange |= MadeChange;
   }
+ }
 
   if (!DisableGCOpts) {
     SmallVector<Instruction *, 2> Statepoints;

Thanks.

[void]

What's the status of this patch? I'm running into a situation where evaluating __builtin_constant_p through inlining may be useful.

[jyknight]

Rebased onto current head, no changes.

[jyknight]

Picking this back up again...

I'm ready to actually submit this now that Bill has the clang-side code that'll use it almost in place. Woo! :)

In D4276#1073957, @efriedma wrote:

Needs a testcase for the SCCP fix. Otherwise LGTM.

The SCCP bug is already be exhibited by the tests in test/CodeGen/Generic/is-constant.ll which pass a struct. Since I believe llvm.is.constant is the only thing we can constant-fold which takes struct args at the moment anyhow, that's really the only viable test. So I think there's nothing else needed here.

In D4276#1135976, @Bharathi wrote:

This feature would be very useful to us and testing this patch against our code base gave us an interesting case where llvm.is.constant (used in a conditional) is lowered to false in CodeGenPrepare and the dead branch that arises out of this lowering does not get eliminated. The code that gets generated after CodeGenPrepare pass has "br i1 false .." with both true and false conditions preserved and this propagates further and remains the same in the final assembly code.

It may make sense to iterate, as you say, but that can/should be a different patch.

[efriedma]

The SCCP bug is already be exhibited by the tests in test/CodeGen/Generic/is-constant.ll which pass a struct.

I'd prefer a testcase that explicitly calls "opt -sccp", as opposed to implicitly relying on the fact that opt -O2 includes SCCP. (You can just add a small test to test/Transforms/SCCP/ipsccp-basic.ll .)

[george.burgess.iv]

It may make sense to iterate, as you say, but that can/should be a different patch.

D49103 should take care of that, FWIW. Nothing to block this patch on (or vice-versa) IMO

[jyknight]

Added sccp testcase.

[jyknight]

In D4276#1289427, @efriedma wrote:

The SCCP bug is already be exhibited by the tests in test/CodeGen/Generic/is-constant.ll which pass a struct.

I'd prefer a testcase that explicitly calls "opt -sccp", as opposed to implicitly relying on the fact that opt -O2 includes SCCP. (You can just add a small test to test/Transforms/SCCP/ipsccp-basic.ll .)

Done. And verified that without the SCCP change, the test fails, and with it, passes.

[efriedma]

LGTM

docs/LangRef.rst

 privileges.
 
 The default behavior is to emit a call to ``__clear_cache`` from the run
 time library.
 
 This instrinsic does *not* empty the instruction pipeline. Modifications
 of the current function are outside the scope of the intrinsic.
 
+'``llvm.is.constant.*``' Intrinsic
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Syntax:
+"""""""
+
+::
+
+      declare i1 @llvm.is.constant.i32(i32)
+
+Overview:
+"""""""""
+
+The '``llvm.is.constant``' intrinsic checks if the argument value is
+known at compile time. The result of this intrinsic might depend on
+the optimisation level i.e. function inlining.
+
+Semantics:
+""""""""""
+
+This function returns true if the argument value is known at compile time, false otherwise.
+
 Standard C Library Intrinsics
 -----------------------------
 
 LLVM provides intrinsics for a few important standard C library
 functions. These intrinsics allow source-language front-ends to pass
 information about the alignment of the pointer arguments to the code
 generator, providing opportunity for more efficient code generation.
 

include/llvm/CodeGen/ISDOpcodes.h

enum NodeType {
     ATOMIC_LOAD_MAX,
     ATOMIC_LOAD_UMIN,
     ATOMIC_LOAD_UMAX,
 
     /// This corresponds to the llvm.lifetime.* intrinsics. The first operand
     /// is the chain and the second operand is the alloca pointer.
     LIFETIME_START, LIFETIME_END,
 
+    /// This corresponds to llvm.is.constant intrinsics.
+    IS_CONSTANT,
+
     /// BUILTIN_OP_END - This must be the last enum value in this list.
     /// The target-specific pre-isel opcode values start here.
     BUILTIN_OP_END
   };
 
   /// FIRST_TARGET_MEMORY_OPCODE - Target-specific pre-isel operations
   /// which do not reference a specific memory location should be less than
   /// this value. Those that do must not be less than this value, and can

include/llvm/IR/Intrinsics.td

 def int_convertuu  : Intrinsic<[llvm_anyint_ty],
                                [llvm_anyint_ty, llvm_i32_ty, llvm_i32_ty]>;
 
 // Clear cache intrinsic, default to ignore (ie. emit nothing)
 // maps to void __clear_cache() on supporting platforms
 def int_clear_cache : Intrinsic<[], [llvm_ptr_ty, llvm_ptr_ty],
                                 [], "llvm.clear_cache">;
 
+// llvm.is.constant intrinsics
+def int_is_constant : Intrinsic<[llvm_i1_ty], [llvm_anyint_ty], [IntrNoMem], "llvm.is.constant">;
+
 //===----------------------------------------------------------------------===//
 // Target-specific intrinsics
 //===----------------------------------------------------------------------===//
 
 include "llvm/IR/IntrinsicsPowerPC.td"
 include "llvm/IR/IntrinsicsX86.td"
 include "llvm/IR/IntrinsicsARM.td"
 include "llvm/IR/IntrinsicsAArch64.td"
 include "llvm/IR/IntrinsicsXCore.td"
 include "llvm/IR/IntrinsicsHexagon.td"
 include "llvm/IR/IntrinsicsNVVM.td"
 include "llvm/IR/IntrinsicsMips.td"
 include "llvm/IR/IntrinsicsR600.td"

include/llvm/Target/TargetSelectionDAG.td

 // Do not use cvt directly. Use cvt forms below
 def cvt : SDNode<"ISD::CONVERT_RNDSAT", SDTConvertOp>;
 
 def SDT_assertext : SDTypeProfile<1, 1,
   [SDTCisInt<0>, SDTCisInt<1>, SDTCisSameAs<1, 0>]>;
 def assertsext : SDNode<"ISD::AssertSext", SDT_assertext>;
 def assertzext : SDNode<"ISD::AssertZext", SDT_assertext>;
 
+def is_constant : SDNode<"ISD::IS_CONSTANT", SDTIntUnaryOp>; 
+
 
 //===----------------------------------------------------------------------===//
 // Selection DAG Condition Codes
 
 class CondCode; // ISD::CondCode enums
 def SETOEQ : CondCode; def SETOGT : CondCode;
 def SETOGE : CondCode; def SETOLT : CondCode; def SETOLE : CondCode;
 def SETONE : CondCode; def SETO   : CondCode; def SETUO  : CondCode;

lib/Analysis/ConstantFolding.cpp

bool llvm::canConstantFoldCallTo(const Function *F) {
   case Intrinsic::x86_sse_cvtss2si:
   case Intrinsic::x86_sse_cvtss2si64:
   case Intrinsic::x86_sse_cvttss2si:
   case Intrinsic::x86_sse_cvttss2si64:
   case Intrinsic::x86_sse2_cvtsd2si:
   case Intrinsic::x86_sse2_cvtsd2si64:
   case Intrinsic::x86_sse2_cvttsd2si:
   case Intrinsic::x86_sse2_cvttsd2si64:
+  case Intrinsic::is_constant:
     return true;
   default:
     return false;
   case 0: break;
   }
 
   if (!F->hasName())
     return false;

lib/CodeGen/SelectionDAG/LegalizeDAG.cpp

 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Target/TargetFrameLowering.h"
 #include "llvm/Target/TargetLowering.h"
 #include "llvm/Target/TargetMachine.h"
 using namespace llvm;
 
+#define DEBUG_TYPE "legalize-dag"
 //===----------------------------------------------------------------------===//
 /// SelectionDAGLegalize - This takes an arbitrary SelectionDAG as input and
 /// hacks on it until the target machine can handle it.  This involves
 /// eliminating value sizes the machine cannot handle (promoting small sizes to
 /// large sizes or splitting up large values into small values) as well as
 /// eliminating operations the machine cannot handle.
 ///
 /// This code also does a small amount of optimization and recognition of idioms
if (Action == TargetLowering::Expand) {
       SDValue NewVal;
       NewVal = DAG.getNode(ISD::TRAP, SDLoc(Node), Node->getVTList(),
                            Node->getOperand(0));
       ReplaceNode(Node, NewVal.getNode());
       LegalizeOp(NewVal.getNode());
       return;
     }
     break;
+  case ISD::IS_CONSTANT: {
+      DEBUG(dbgs() << "Lowering llvm.is.constant to FALSE.\n");
+      SDValue NewVal = DAG.getConstant(0, Node->getValueType(0));
+      ReplaceNode(Node, NewVal.getNode());
+      LegalizeOp(NewVal.getNode());
+      return;
+    }
 
   default:
     if (Node->getOpcode() >= ISD::BUILTIN_OP_END) {
       Action = TargetLowering::Legal;
     } else {
       Action = TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0));
     }
     break;

lib/CodeGen/SelectionDAG/SelectionDAG.cpp

 #include "llvm/Target/TargetOptions.h"
 #include "llvm/Target/TargetRegisterInfo.h"
 #include "llvm/Target/TargetSelectionDAGInfo.h"
 #include <algorithm>
 #include <cmath>
 
 using namespace llvm;
 
+#define DEBUG_TYPE "selection-dag"
+
 /// makeVTList - Return an instance of the SDVTList struct initialized with the
 /// specified members.
 static SDVTList makeVTList(const EVT *VTs, unsigned NumVTs) {
   SDVTList Res = {VTs, NumVTs};
   return Res;
 }
 
 // Default null implementations of the callbacks.
if (ConstantSDNode *C = dyn_cast<ConstantSDNode>(Operand.getNode())) {
     case ISD::CTLZ:
     case ISD::CTLZ_ZERO_UNDEF:
       return getConstant(Val.countLeadingZeros(), VT, C->isTargetOpcode(),
                          C->isOpaque());
     case ISD::CTTZ:
     case ISD::CTTZ_ZERO_UNDEF:
       return getConstant(Val.countTrailingZeros(), VT, C->isTargetOpcode(),
                          C->isOpaque());
+    case ISD::IS_CONSTANT: {
+      DEBUG(dbgs() << "Lowering llvm.is.constant to TRUE.\n");
+      return getConstant(1, VT);
+    }
     }
   }
 
   // Constant fold unary operations with a floating point constant operand.
   if (ConstantFPSDNode *C = dyn_cast<ConstantFPSDNode>(Operand.getNode())) {
     APFloat V = C->getValueAPF();    // make copy
     switch (Opcode) {
     case ISD::FNEG:

lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

case Intrinsic::flt_rounds:
     setValue(&I, DAG.getNode(ISD::FLT_ROUNDS_, sdl, MVT::i32));
     return nullptr;
 
   case Intrinsic::expect: {
     // Just replace __builtin_expect(exp, c) with EXP.
     setValue(&I, getValue(I.getArgOperand(0)));
     return nullptr;
   }
+  case Intrinsic::is_constant: {
+    SDValue Arg = getValue(I.getArgOperand(0));
+    EVT Ty = Arg.getValueType();
+    setValue(&I, DAG.getNode(ISD::IS_CONSTANT, sdl, Ty, Arg));
+    return nullptr;
+  }
 
   case Intrinsic::debugtrap:
   case Intrinsic::trap: {
     StringRef TrapFuncName = TM.Options.getTrapFunctionName();
     if (TrapFuncName.empty()) {
       ISD::NodeType Op = (Intrinsic == Intrinsic::trap) ?
         ISD::TRAP : ISD::DEBUGTRAP;
       DAG.setRoot(DAG.getNode(Op, sdl,MVT::Other, getRoot()));

lib/CodeGen/SelectionDAG/SelectionDAGDumper.cpp

#endif
   case ISD::UINT_TO_FP:                 return "uint_to_fp";
   case ISD::FP_TO_SINT:                 return "fp_to_sint";
   case ISD::FP_TO_UINT:                 return "fp_to_uint";
   case ISD::BITCAST:                    return "bitcast";
   case ISD::ADDRSPACECAST:              return "addrspacecast";
   case ISD::FP16_TO_FP32:               return "fp16_to_fp32";
   case ISD::FP32_TO_FP16:               return "fp32_to_fp16";
 
+  case ISD::IS_CONSTANT:                return "IsConstant";
+
   case ISD::CONVERT_RNDSAT: {
     switch (cast<CvtRndSatSDNode>(this)->getCvtCode()) {
     default: llvm_unreachable("Unknown cvt code!");
     case ISD::CVT_FF:                   return "cvt_ff";
     case ISD::CVT_FS:                   return "cvt_fs";
     case ISD::CVT_FU:                   return "cvt_fu";
     case ISD::CVT_SF:                   return "cvt_sf";
     case ISD::CVT_UF:                   return "cvt_uf";

test/CodeGen/Generic/inline-is-constant.ll

+; RUN: opt -O3 < %s | lli
+; 
+; Expected outcome: @fun is inlined and @llvm.is.constant is resolved to TRUE
+; Without inlining @llvm.is.constant would resolve to FALSE.
+
+declare i1 @llvm.is.constant.i32(i32 %a)
+
+; Function Attrs: nounwind uwtable alwaysinline
+define private i1 @fun(i32 %x) #0 {
+  %x.addr = alloca i32, align 4
+  store i32 %x, i32* %x.addr, align 4
+  %value = load i32* %x.addr, align 4
+  %const = call i1 @llvm.is.constant.i32(i32 %value)
+  ret i1 %const
+}
+
+; Function Attrs: nounwind uwtable
+define i32 @main() #1 {
+  %call = call i1 @fun(i32 127)
+  br i1 %call, label %IfTrue, label %IfFalse
+IfTrue:
+  ret i32 0
+IfFalse:
+  ret i32 1
+}
+
+attributes #0 = { nounwind uwtable alwaysinline }
+
+attributes #1 = { nounwind uwtable }

test/CodeGen/Generic/is-constant.ll

+; RUN: llc < %s  | FileCheck %s
+; RUN: llc -debug -o /dev/null 2>&1 < %s | FileCheck %s -check-prefix=DEBUG
+
+declare i1 @llvm.is.constant.i32(i32 %a)
+
+define i1 @fun1() #0 {
+; CHECK: fun1:
+; CHECK-NOT: llvm.is.constant
+; DEBUG: Lowering llvm.is.constant to TRUE
+  %y = call i1 @llvm.is.constant.i32(i32 44)
+  ret i1 %y
+}
+
+define i1 @fun2(i32 %x) #0 {
+; CHECK: fun2:
+; CHECK-NOT: llvm.is.constant
+; DEBUG: Lowering llvm.is.constant to FALSE
+  %y = call i1 @llvm.is.constant.i32(i32 %x)
+  ret i1 %y
+}
+
+
+define i32 @fun3() #0 {
+; CHECK: fun3:
+; CHECK-NOT: llvm.is.constant
+; DEBUG: Lowering llvm.is.constant to TRUE
+; DEBUG: Lowering llvm.is.constant to TRUE
+  %val1 = call i1 @llvm.is.constant.i32(i32 27)
+  %val2 = zext i1 %val1 to i32
+  %val3 = add i32 %val2, 12
+  %1 = call i1 @llvm.is.constant.i32(i32 %val3)
+  %2 = zext i1 %1 to i32
+  %3 = add i32 %2, 12
+  ret i32 %3
+}
+
+attributes #0 = { nounwind uwtable }