[IR] Add Freeze instruction

[aqjune]

Summary

• Define Instruction::Freeze, let it be UnaryOperator
• Add support for freeze to LLLexer/LLParser/BitcodeReader/BitcodeWriter The format is %x = freeze <ty> %v
• Add support for freeze instruction to llvm-c interface.
• Add m_Freeze in PatternMatch.
• Erase freeze when lowering IR to SelDag.

[deadalnix]

Hi,

Could you add a test case for the C API ? You can do so using the echo facility of llvm-c-test. See for instance: https://reviews.llvm.org/diffusion/L/browse/llvm/trunk/test/Bindings/llvm-c/atomics.ll

include/llvm-c/Core.h

3028 ↗

(On Diff #85342)

nit: please align the Name parameter properly.

[aqjune]

• Add llvm-c test (test/Bindings/llvm-c/freeze.ll)
• Update tools/llvm-c-test/echo.cpp so it can deal with Freeze instruction.

[deadalnix]

Awesome, as far as the C API goes, this is good. I'll let other the time to review everything else.

[filcab]

Just some minor nits.
You're adding some functions which will never be called. It might be easier to hold them off until the next patch (and have this one only add the instruction + necessary plumbing), or to at least post a follow-up patch on phabricator which shows usage for those functions, as that makes it easier to know it shouldn't be dead code for long.

include/llvm/IR/IRBuilder.h

1713 ↗

(On Diff #85541)

Maybe omit the \brief?

1715 ↗

(On Diff #85541)

This is not being used. Maybe submit in a later patch, with a use for it?

include/llvm/IR/Instructions.h

5064 ↗

(On Diff #85541)

undef?

include/llvm/IR/PatternMatch.h

931 ↗

(On Diff #85541)

Minor nit: Unsure if the usual pattern matching policy is to add the pattern only when you need it on when adding the instruction.

lib/Analysis/ValueTracking.cpp

3917 ↗

(On Diff #85541)

If we're just doing ConstantInt for now, why not just use the inner if (same for the FreezeInst)? Then change it after adding more, if the code ends up being too complex or has too many repeated tests.
No need to add a comment stating what an if (isa...) return is doing.
Is there a plan for adding constants, etc? Maybe add a TODO tag here, so it jumps out if someone is grepping for those.

lib/AsmParser/LLParser.cpp

5914 ↗

(On Diff #85541)

Please test this error.

5916 ↗

(On Diff #85541)

Omit the , "" since it's the default arg anyway.

lib/Bitcode/Reader/BitcodeReader.cpp

4350 ↗

(On Diff #85541)

Omit the , "".

[filcab]

lib/AsmParser/LLParser.cpp

5914 ↗

(On Diff #85541)

Even better: Should this be in the verifier only? Otherwise you're checking for the same thing in two places, which is easy to get out of sync. (Would still require a test)

[majnemer]

lib/AsmParser/LLParser.cpp

5914 ↗

(On Diff #85541)

its not bad for them to be in both, the error messages are much nicer in the parser.

[vsk]

Please move the bitcode round-trip in test/Bitcode/freeze.ll to test/Bitcode/compatibility.ll. This lets us test bitcode backwards-compatibility.

[aqjune]

• Modify typos, add more comments (including TODOs)
• Add tests for parsing error
• Moved test/Bitcode/freeze.ll to test/Bitcode/compatibility.ll.

[aqjune]

include/llvm/IR/IRBuilder.h

1715 ↗

(On Diff #85541)

Hello. Thanks for your comment.
This function is going to be used in https://reviews.llvm.org/D29016, and this patch is important because it may reduce the number of unnecessarily inserted freezes.

include/llvm/IR/PatternMatch.h

931 ↗

(On Diff #85760)

You're right - it is not used right now.
However every other values has its own match function currently, so I just followed convention..
If you think this is redundant now, I'll erase this.

lib/Analysis/ValueTracking.cpp

3917 ↗

(On Diff #85760)

There's no plan to add other cases now.
I added TODOs, as you recommended.

lib/AsmParser/LLParser.cpp

5914 ↗

(On Diff #85760)

I added 3 test cases which checks whether this error message is printed out.

5916 ↗

(On Diff #85760)

I removed the second argument.

[filcab]

include/llvm/IR/IRBuilder.h

1715 ↗

(On Diff #85541)

That patch seems to have no instance of CreateFreezeAtDef. It's better to only add this function when it's going to be used.

include/llvm/IR/PatternMatch.h

931 ↗

(On Diff #85760)

It's a minor nit. I'm ok with this being added now with the rest of the instruction stuff.

lib/Analysis/ValueTracking.cpp

3901 ↗

(On Diff #85760)

This function is unused.

3917 ↗

(On Diff #85760)

Maybe this?

// TODO: Deal with other Constant subclasses.
if (isa<ConstantInt>(C))
  return true;

return false;

I don't think the outer if is buying you anything for now. Anyone who adds more can deal with avoiding testing the same thing twice.
(we can even return isa<...>...;, but keeping the "itemization"-like code doesn't seem bad in my view).

lib/Bitcode/Reader/BitcodeReader.cpp

4350 ↗

(On Diff #85760)

If you don't test for an integer type, this will generate invalid IR. It's also not consistent with the parser.

lib/IR/Verifier.cpp

3654 ↗

(On Diff #85760)

Please add a test to unittests/IR/VerifierTest.cpp

test/Bitcode/freeze-vector.ll

3 ↗

(On Diff #85760)

No need to name the LINE variable. But you should be matching to make sure we get the correct line.
Something like (using the automatic @LINE variable):

CHECK: freeze-vector.ll:[[@LINE+2]]: ```...
The same for the other tests.

[aqjune]

• Move isGuaranteedNotToBeUndefOrPoison to https://reviews.llvm.org/D29013
• Move CreateFreezeAtDef to https://reviews.llvm.org/D29015
• Add a test to unittest/unittests/IR/VerifierTest.cpp
• Add type checking to BitcodeReader.cpp

[aqjune]

include/llvm/IR/IRBuilder.h

1715 ↗

(On Diff #86250)

Oh, sorry, the patch was https://reviews.llvm.org/D29015 , not https://reviews.llvm.org/D29016.
I moved the CreateFreezeAtDef to https://reviews.llvm.org/D29015.

[aqjune]

include/llvm/IR/IRBuilder.h

1713 ↗

(On Diff #86250)

@filcab Other functions also have \brief , so I followed the convention.

[filcab]

Looks good on my end. But please wait for someone more familiar with IR to chime in and LGTM, since I'm not sure of all places that need to be changed when adding instructions.

include/llvm/IR/IRBuilder.h

1713 ↗

(On Diff #86250)

Consistency is ok by me. If we ever convert these, we can do it on all at once.

[aqjune]

@filcab Thanks for your comments.

[aqjune]

Rebased to svn commit 308173

[delcypher]

lib/AsmParser/LLParser.cpp

5953 ↗

(On Diff #106873)

@aqjune What's the motivation to restricting the freeze instruction to scalar integers?

For vector SSA registers that contain integers that we want to "freeze" this would force doing constructing a new vector by use of extractelement, freeze on the each scalar element and then insertelement to construct the new register. This seems a bit cumbersome.

I presume the reason for not allowing floating point operands is that none of the floating point instructions are supposed to produce poison? However consider the load instruction. That could load poisoned memory and the type could be a floating point type. There's an example of a poisoned load in the IR language reference ( https://llvm.org/docs/LangRef.html#poison-values ).

[nlopes]

lib/AsmParser/LLParser.cpp

5953 ↗

(On Diff #106873)

You're right that in the future it may be useful to freeze vectors of integers, at least.
This is just the first version of the patch. The intent was to fix loop unswitch, which doesn't require freezing vectors yet. As uses expand we can relax the condition.
We definitely didn't want to freeze floats; I don't know yet if that's needed or what does it mean.

[delcypher]

lib/AsmParser/LLParser.cpp

5953 ↗

(On Diff #106873)

Thanks for clarifying. I see the instruction is documented in https://reviews.llvm.org/D29121 so I left a minor comment there about this.

[aqjune]

Rebased to svn commit 331585

[xbolva00]

Ping

[aqjune]

Rebase to trunk@369887 (August 26th, 2019)

[lebedev.ri]

Thank you for working on this! This needs more cleanup.
Since the patch was initially posted, and Unary operator type was added to LLVM.
In last patch's update many parts of the patch were correctly migrated, but not all.
See D53877 for the list of potential places, i tried to point out most of them inline.

include/llvm-c/Core.h

144 ↗

(On Diff #217187)

unrelated

include/llvm/Bitcode/LLVMBitCodes.h

394–395 ↗

(On Diff #217187)

Did you mean to put freeze as an unary instruction instead of a function?

559 ↗

(On Diff #217187)

Wouldn't basing it on unary op work?

include/llvm/CodeGen/GlobalISel/IRTranslator.h

487 ↗

(On Diff #217187)

Is this a correctness issue?
Or does returning false here results in IRTranslator "aborting"?

include/llvm/IR/IRBuilder.h

2358 ↗

(On Diff #217187)

I personally have mild preference for the ::Create; not sure if this is a remark or review note.

include/llvm/IR/InstVisitor.h

202 ↗

(On Diff #217187)

Should you delegate to UnaryInstruction instead?

lib/AsmParser/LLParser.cpp

6739 ↗

(On Diff #217187)

Needs updating to match langref - vectors; floating point support?

lib/IR/Verifier.cpp

3964–3965 ↗

(On Diff #217187)

Needs updating to match langref - vectors; floating point support?

[kristof.beyls]

Given this seems to add a new IR instruction, shouldn't there also be good quality documentation for this new instruction in docs/LangRef.rst?

[lebedev.ri]

In D29011#1696898, @kristof.beyls wrote:

Given this seems to add a new IR instruction, shouldn't there also be good quality documentation for this new instruction in docs/LangRef.rst?

See D29121

[aqjune]

Updated the patch so UnaryOperator is used for Instruction::Freeze op.
Currently I see an error from Phabricator while uploading a new diff:

Unhandled Exception ("PhabricatorFileUploadException")	
Unable to write file: failed to write to temporary directory.

I'll retry uploading it later.

include/llvm/CodeGen/GlobalISel/IRTranslator.h

487 ↗

(On Diff #217187)

Yep, returning false makes it abort, if my understanding is correct.

[lebedev.ri]

Thanks, this looks about right.
I'm not sure about backend part of this patch, but that is likely okay.
Two main questions: should there be a constantexpr freeze, and should freeze be fully type-agnostic, like it is stated in D29121?

include/llvm/CodeGen/GlobalISel/IRTranslator.h

487 ↗

(On Diff #217187)

Okay.

lib/AsmParser/LLParser.cpp

3407–3430 ↗

(On Diff #223461)

Should there be constantexpr version of freeze?

6317–6338 ↗

(On Diff #223461)

I see no restrictions on the type to freeze in D29121,
so i think you just don't want any checking for freeze here.
And existing ParseUnaryOp is only called with /*IsFP*/true to parse fneg.
So let's change this to

bool Valid = !IsFPOnly || LHS->getType()->isFPOrFPVectorTy();

?

lib/Bitcode/Writer/BitcodeWriter.cpp

2448–2457 ↗

(On Diff #223461)

What about constantexpr freeze?

lib/IR/Instructions.cpp

2240–2242 ↗

(On Diff #223461)

I'm not seeing this restriction in D29121

lib/IR/Verifier.cpp

3141–3144 ↗

(On Diff #223461)

I'm not seeing this restriction in D29121

[aqjune]

should there be a constantexpr freeze

Yep, constantexpr freeze makes sense, as freeze is a scalar operation (like fneg). :)

and should freeze be fully type-agnostic, like it is stated in D29121?

I think this is a hard question, especially due to the existence of the undef pointer.
A pointer value tracks which memory block it is pointing to. If freeze i8* undef is defined to yield a random pointer to any pre-defined memory block, this will limit free moving of freeze, e.g:

p = malloc() // p is created
ptr0 = freeze i8* undef // ptr0 can point to block p
=>
ptr0 = freeze i8* undef // ptr0 can't point to block p, because p is not allocated yet
p = malloc()

[lebedev.ri]

In D29011#1697170, @aqjune wrote:

should there be a constantexpr freeze

Yep, constantexpr freeze makes sense, as freeze is a scalar operation (like fneg). :)

See inline comments then :)

and should freeze be fully type-agnostic, like it is stated in D29121?

I think this is a hard question, especially due to the existence of the undef pointer.
A pointer value tracks which memory block it is pointing to. If freeze i8* undef is defined to yield a random pointer to any pre-defined memory block, this will limit free moving of freeze, e.g:

p = malloc() // p is created
ptr0 = freeze i8* undef // ptr0 can point to block p
=>
ptr0 = freeze i8* undef // ptr0 can't point to block p, because p is not allocated yet
p = malloc()

I guess D29121 needs to explicitly single-out the pointers then.

[lebedev.ri]

(marking as reviewed as per previous comments - constantexpr, typechecking inconsistent with langref)

[aqjune]

• Support freeze constexpr
• Make freeze's type checking consistent with LangRef.

[jdoerfert]

Two minor comments from my side.

(I would like someone to include the keyword in the editor lists llvm/utils/{emacs,vim} after this landed)

lib/CodeGen/SelectionDAG/SelectionDAGBuilder.h

671 ↗

(On Diff #224745)

The lady of the lake says this should be:

`void visitFreeze(const User &I) { visitUnary(I, ISD::FREEZE); }`

If you have reason not to do it this way, also replace visitUnrary with visitFNeg, though I'd prefer not to.

test/Bindings/llvm-c/freeze.ll

12 ↗

(On Diff #224745)

Missing types, here and elsewhere I think:

• array
• struct w/ definition
• struct w/o definition (opaque)
• non-standard integer size (i666)

Missing inputs:

• undef
• null

[lebedev.ri]

In D29011#1707274, @jdoerfert wrote:

Two minor comments from my side.

Looks good to me with those two fixed.
Should you add llvm::Freze here by inheriting from UnaryOperator to make isa<Freze>(Op) possible?

(I would like someone to include the keyword in the editor lists llvm/utils/{emacs,vim} after this landed)

There is also llvm/utils/{kate}.

include/llvm/Bitcode/LLVMBitCodes.h

394 ↗

(On Diff #224745)

I think you want to rebase.

[aqjune]

In D29011#1707278, @lebedev.ri wrote:

Should you add llvm::Freeze here by inheriting from UnaryOperator to make isa<Freeze>(Op) possible?

Couldn't you kindly point which place is good to update?

lib/CodeGen/SelectionDAG/SelectionDAGBuilder.h

671 ↗

(On Diff #224745)

ISD::FREEZE will be added in the next patch - https://reviews.llvm.org/D29014 .
Do you want to move the definition of ISD::FREEZE to this patch? @lebedev.ri

[lebedev.ri]

In D29011#1707396, @aqjune wrote:

In D29011#1707278, @lebedev.ri wrote:

Should you add llvm::Freeze here by inheriting from UnaryOperator to make isa<Freeze>(Op) possible?

Couldn't you kindly point which place is good to update?

Right after where the llvm::UnaryOperator is defined in llvm/include/llvm/IR/InstrTypes.h i think.
See OverflowingBinaryOperator for an example.

lib/CodeGen/SelectionDAG/SelectionDAGBuilder.h

671 ↗

(On Diff #224745)

Oh good point, let's leave as is.

[aqjune]

• Rebase
• Add more tests to freeze.ll
• Define FreezeOperator

[aqjune]

include/llvm/IR/Operator.h

594 ↗

(On Diff #224771)

I added FreezeOperator here, as other operators including OverflowingBinaryOperator were in this file.

test/Bindings/llvm-c/freeze.ll

12 ↗

(On Diff #224745)

I found that freeze i8* null raised an error due to a bug in tools/llvm-c-test/echo.cpp:

// Try null
if (LLVMIsNull(Cst)) {
  check_value_kind(Cst, LLVMConstantTokenNoneValueKind);
  LLVMTypeRef Ty = TypeCloner(M).Clone(Cst);
  return LLVMConstNull(Ty);
}

Here, Cst can not only be LLVMConstantTokenNoneValueKind but also LLVMConstantPointerNullValueKind.
I'll make a separate patch that resolves this error, then I'll be able to add freeze i8* null test.

[lebedev.ri]

Thanks, LG.
Anyone else has any comments here?

include/llvm/IR/PatternMatch.h

830–834 ↗

(On Diff #224771)

Let's use FreezeOperator here then?

[aqjune]

• Use FreezeOperator inside Freeze_match

[lebedev.ri]

In line with a few recent reverts, is this missing anything for ocaml binding?
(does it compile with ocaml binding enabled and do all tests still pass?)

[jdoerfert]

Fwiw, I'm OK with this (given that we have my requested changes in upcoming commits).

[jdoerfert]

In D29011#1708103, @lebedev.ri wrote:

In line with a few recent reverts, is this missing anything for ocaml binding?
(does it compile with ocaml binding enabled and do all tests still pass?)

Like D61675 ;)

[aqjune]

Sorry, I've been busy recently.

make check-llvm-bindings-ocaml wasn't raising error, but I added tests for freeze to core.ml because it is good to have the tests.

BTW, make check raises an error at test/Transforms/MergeFunc/inline-asm.ll because the output has function definitions reordered - what is the best way to resolve this? I attached the input/output .ll files.

inline-asm.tar.gz633 BDownload

[craig.topper]

Sorry to come to this late, but does it really make sense for Freeze to be inherited from UnaryOperator? UnaryOperator in my mind is like BinaryOperator which is for arithmetic operations. Freeze is different. The fact that it made sense to add a FreezeOperator hints at that. Should we instead just have a FreezeInst separate from UnaryOperator instead of FreezeOperator?

[aqjune]

In D29011#1733572, @craig.topper wrote:

Sorry to come to this late, but does it really make sense for Freeze to be inherited from UnaryOperator? UnaryOperator in my mind is like BinaryOperator which is for arithmetic operations. Freeze is different. The fact that it made sense to add a FreezeOperator hints at that. Should we instead just have a FreezeInst separate from UnaryOperator instead of FreezeOperator?

My understanding of UnaryOperator was that it is a scalar operation that has same input and output type according to the LangRef, so I thought freeze could be categorized into it.
Implementing freeze by inheriting UnaryOperator was straightforward; I did not have to specify instruction's properties, adding it to constexpr was easy, etc. I believe having it inherit UnaryOperator would be good for maintenance, but other than this I have no strong reason for this.
About the FreezeOperator, I think it is natural to have operators in Operator.h that has special purposes: it also has AddOperator / SubOperator / etc defined.

[craig.topper]

Does a ConstantExpr freeze really make sense? ConstantExprs are uniqued by the LLVMContext. So every constantexpr that has the same input ends up being the same object. Do we want that behavior do we need each freeze to be distinct?

[aqjune]

In D29011#1735007, @craig.topper wrote:

Does a ConstantExpr freeze really make sense? ConstantExprs are uniqued by the LLVMContext. So every constantexpr that has the same input ends up being the same object. Do we want that behavior do we need each freeze to be distinct?

Both semantics make sense, and I was thinking of returning the same value for same expression of freeze, because it explains copy of an instruction that has freeze constexpr as an operand.
Conceptually, we can say that freeze constexpr is evaluated at the beginning of a program, and the evaluated value is globally used inside the module.
Using this semantics, freeze constexprs should be carefully optimized, so the same freeze constexprs don't diverge into different expressions.
This is the difference from other constexprs, but I guess binary operator also has a similar diverged case, which is udiv/sdiv constexpr (that made constexpr may trap), but I have to say that having such difference isn't said to be a good idea.
What do you think?

[nlopes]

In D29011#1735007, @craig.topper wrote:

Does a ConstantExpr freeze really make sense? ConstantExprs are uniqued by the LLVMContext. So every constantexpr that has the same input ends up being the same object. Do we want that behavior do we need each freeze to be distinct?

Juneyoung and I have discussed this today.
The conclusion was that we don't see a use-case for a freeze ConstantExpr and therefore we agree that it should be removed. Also, the semantics and implementation would be tricky as you suggest. @aqjune will submit a new patch to change Freeze from being a UnaryOp to just an op on its own.

[aqjune]

The new patch is here: https://reviews.llvm.org/D69932

llvm/include/llvm-c/Core.h

typedef enum {
   LLVMIndirectBr     = 4,
   LLVMInvoke         = 5,
   /* removed 6 due to API changes */
   LLVMUnreachable    = 7,
   LLVMCallBr         = 67,
 
   /* Standard Unary Operators */
   LLVMFNeg           = 66,
+  LLVMFreeze         = 68,
 
   /* Standard Binary Operators */
   LLVMAdd            = 8,
   LLVMFAdd           = 9,
   LLVMSub            = 10,
   LLVMFSub           = 11,
   LLVMMul            = 12,
   LLVMFMul           = 13,
LLVMValueRef LLVMBuildBinOp(LLVMBuilderRef B, LLVMOpcode Op,
                             const char *Name);
 LLVMValueRef LLVMBuildNeg(LLVMBuilderRef, LLVMValueRef V, const char *Name);
 LLVMValueRef LLVMBuildNSWNeg(LLVMBuilderRef B, LLVMValueRef V,
                              const char *Name);
 LLVMValueRef LLVMBuildNUWNeg(LLVMBuilderRef B, LLVMValueRef V,
                              const char *Name);
 LLVMValueRef LLVMBuildFNeg(LLVMBuilderRef, LLVMValueRef V, const char *Name);
 LLVMValueRef LLVMBuildNot(LLVMBuilderRef, LLVMValueRef V, const char *Name);
+LLVMValueRef LLVMBuildFreeze(LLVMBuilderRef, LLVMValueRef V, const char *Name);
 
 /* Memory */
 LLVMValueRef LLVMBuildMalloc(LLVMBuilderRef, LLVMTypeRef Ty, const char *Name);
 LLVMValueRef LLVMBuildArrayMalloc(LLVMBuilderRef, LLVMTypeRef Ty,
                                   LLVMValueRef Val, const char *Name);
 
 /**
  * Creates and inserts a memset to the specified pointer and the 

llvm/include/llvm/Bitcode/LLVMBitCodes.h

enum CastOpcodes {
   CAST_ADDRSPACECAST = 12
 };
 
 /// UnaryOpcodes - These are values used in the bitcode files to encode which
 /// unop a CST_CODE_CE_UNOP or a XXX refers to.  The values of these enums
 /// have no fixed relation to the LLVM IR enum values.  Changing these will
 /// break compatibility with old files.
 enum UnaryOpcodes {
-  UNOP_FNEG = 0
+  UNOP_FNEG = 0,
+  UNOP_FREEZE = 1
 };
 
 /// BinaryOpcodes - These are values used in the bitcode files to encode which
 /// binop a CST_CODE_CE_BINOP or a XXX refers to.  The values of these enums
 /// have no fixed relation to the LLVM IR enum values.  Changing these will
 /// break compatibility with old files.
 enum BinaryOpcodes {
   BINOP_ADD = 0,

llvm/include/llvm/CodeGen/GlobalISel/IRTranslator.h

bool translateCatchPad(const User &U, MachineIRBuilder &MIRBuilder) {
     return false;
   }
   bool translateUserOp1(const User &U, MachineIRBuilder &MIRBuilder) {
     return false;
   }
   bool translateUserOp2(const User &U, MachineIRBuilder &MIRBuilder) {
     return false;
   }
+  bool translateFreeze(const User &U, MachineIRBuilder &MIRBuilder) {
+    return false;
+  }
 
   /// @}
 
   // Builder for machine instruction a la IRBuilder.
   // I.e., compared to regular MIBuilder, this one also inserts the instruction
   // in the current block, it can creates block, etc., basically a kind of
   // IRBuilder, but for Machine IR.
   // CSEMIRBuilder CurBuilder;

llvm/include/llvm/IR/IRBuilder.h

Value *CreateInsertValue(Value *Agg, Value *Val,
     return Insert(InsertValueInst::Create(Agg, Val, Idxs), Name);
   }
 
   LandingPadInst *CreateLandingPad(Type *Ty, unsigned NumClauses,
                                    const Twine &Name = "") {
     return Insert(LandingPadInst::Create(Ty, NumClauses), Name);
   }
 
+  Value *CreateFreeze(Value *V, const Twine &Name = "") {
+    return Insert(UnaryOperator::CreateFreeze(V, Name));
+  }
+
   //===--------------------------------------------------------------------===//
   // Utility creation methods
   //===--------------------------------------------------------------------===//
 
   /// Return an i1 value testing if \p Arg is null.
   Value *CreateIsNull(Value *Arg, const Twine &Name = "") {
     return CreateICmpEQ(Arg, Constant::getNullValue(Arg->getType()),
                         Name);

llvm/include/llvm/IR/Instruction.def

 HANDLE_TERM_INST  ( 9, CatchRet      , CatchReturnInst)
 HANDLE_TERM_INST  (10, CatchSwitch   , CatchSwitchInst)
 HANDLE_TERM_INST  (11, CallBr        , CallBrInst) // A call-site terminator
   LAST_TERM_INST  (11)
 
 // Standard unary operators...
  FIRST_UNARY_INST(12)
 HANDLE_UNARY_INST(12, FNeg  , UnaryOperator)
-  LAST_UNARY_INST(12)
+HANDLE_UNARY_INST(13, Freeze, UnaryOperator)
+  LAST_UNARY_INST(13)
 
 // Standard binary operators...
- FIRST_BINARY_INST(13)
-HANDLE_BINARY_INST(13, Add  , BinaryOperator)
-HANDLE_BINARY_INST(14, FAdd , BinaryOperator)
-HANDLE_BINARY_INST(15, Sub  , BinaryOperator)
-HANDLE_BINARY_INST(16, FSub , BinaryOperator)
-HANDLE_BINARY_INST(17, Mul  , BinaryOperator)
-HANDLE_BINARY_INST(18, FMul , BinaryOperator)
-HANDLE_BINARY_INST(19, UDiv , BinaryOperator)
-HANDLE_BINARY_INST(20, SDiv , BinaryOperator)
-HANDLE_BINARY_INST(21, FDiv , BinaryOperator)
-HANDLE_BINARY_INST(22, URem , BinaryOperator)
-HANDLE_BINARY_INST(23, SRem , BinaryOperator)
-HANDLE_BINARY_INST(24, FRem , BinaryOperator)
+ FIRST_BINARY_INST(14)
+HANDLE_BINARY_INST(14, Add  , BinaryOperator)
+HANDLE_BINARY_INST(15, FAdd , BinaryOperator)
+HANDLE_BINARY_INST(16, Sub  , BinaryOperator)
+HANDLE_BINARY_INST(17, FSub , BinaryOperator)
+HANDLE_BINARY_INST(18, Mul  , BinaryOperator)
+HANDLE_BINARY_INST(19, FMul , BinaryOperator)
+HANDLE_BINARY_INST(20, UDiv , BinaryOperator)
+HANDLE_BINARY_INST(21, SDiv , BinaryOperator)
+HANDLE_BINARY_INST(22, FDiv , BinaryOperator)
+HANDLE_BINARY_INST(23, URem , BinaryOperator)
+HANDLE_BINARY_INST(24, SRem , BinaryOperator)
+HANDLE_BINARY_INST(25, FRem , BinaryOperator)
 
 // Logical operators (integer operands)
-HANDLE_BINARY_INST(25, Shl  , BinaryOperator) // Shift left  (logical)
-HANDLE_BINARY_INST(26, LShr , BinaryOperator) // Shift right (logical)
-HANDLE_BINARY_INST(27, AShr , BinaryOperator) // Shift right (arithmetic)
-HANDLE_BINARY_INST(28, And  , BinaryOperator)
-HANDLE_BINARY_INST(29, Or   , BinaryOperator)
-HANDLE_BINARY_INST(30, Xor  , BinaryOperator)
-  LAST_BINARY_INST(30)
+HANDLE_BINARY_INST(26, Shl  , BinaryOperator) // Shift left  (logical)
+HANDLE_BINARY_INST(27, LShr , BinaryOperator) // Shift right (logical)
+HANDLE_BINARY_INST(28, AShr , BinaryOperator) // Shift right (arithmetic)
+HANDLE_BINARY_INST(29, And  , BinaryOperator)
+HANDLE_BINARY_INST(30, Or   , BinaryOperator)
+HANDLE_BINARY_INST(31, Xor  , BinaryOperator)
+  LAST_BINARY_INST(31)
 
 // Memory operators...
- FIRST_MEMORY_INST(31)
-HANDLE_MEMORY_INST(31, Alloca, AllocaInst)  // Stack management
-HANDLE_MEMORY_INST(32, Load  , LoadInst  )  // Memory manipulation instrs
-HANDLE_MEMORY_INST(33, Store , StoreInst )
-HANDLE_MEMORY_INST(34, GetElementPtr, GetElementPtrInst)
-HANDLE_MEMORY_INST(35, Fence , FenceInst )
-HANDLE_MEMORY_INST(36, AtomicCmpXchg , AtomicCmpXchgInst )
-HANDLE_MEMORY_INST(37, AtomicRMW , AtomicRMWInst )
-  LAST_MEMORY_INST(37)
+ FIRST_MEMORY_INST(32)
+HANDLE_MEMORY_INST(32, Alloca, AllocaInst)  // Stack management
+HANDLE_MEMORY_INST(33, Load  , LoadInst  )  // Memory manipulation instrs
+HANDLE_MEMORY_INST(34, Store , StoreInst )
+HANDLE_MEMORY_INST(35, GetElementPtr, GetElementPtrInst)
+HANDLE_MEMORY_INST(36, Fence , FenceInst )
+HANDLE_MEMORY_INST(37, AtomicCmpXchg , AtomicCmpXchgInst )
+HANDLE_MEMORY_INST(38, AtomicRMW , AtomicRMWInst )
+  LAST_MEMORY_INST(38)
 
 // Cast operators ...
 // NOTE: The order matters here because CastInst::isEliminableCastPair
 // NOTE: (see Instructions.cpp) encodes a table based on this ordering.
- FIRST_CAST_INST(38)
-HANDLE_CAST_INST(38, Trunc   , TruncInst   )  // Truncate integers
-HANDLE_CAST_INST(39, ZExt    , ZExtInst    )  // Zero extend integers
-HANDLE_CAST_INST(40, SExt    , SExtInst    )  // Sign extend integers
-HANDLE_CAST_INST(41, FPToUI  , FPToUIInst  )  // floating point -> UInt
-HANDLE_CAST_INST(42, FPToSI  , FPToSIInst  )  // floating point -> SInt
-HANDLE_CAST_INST(43, UIToFP  , UIToFPInst  )  // UInt -> floating point
-HANDLE_CAST_INST(44, SIToFP  , SIToFPInst  )  // SInt -> floating point
-HANDLE_CAST_INST(45, FPTrunc , FPTruncInst )  // Truncate floating point
-HANDLE_CAST_INST(46, FPExt   , FPExtInst   )  // Extend floating point
-HANDLE_CAST_INST(47, PtrToInt, PtrToIntInst)  // Pointer -> Integer
-HANDLE_CAST_INST(48, IntToPtr, IntToPtrInst)  // Integer -> Pointer
-HANDLE_CAST_INST(49, BitCast , BitCastInst )  // Type cast
-HANDLE_CAST_INST(50, AddrSpaceCast, AddrSpaceCastInst)  // addrspace cast
-  LAST_CAST_INST(50)
-
- FIRST_FUNCLETPAD_INST(51)
-HANDLE_FUNCLETPAD_INST(51, CleanupPad, CleanupPadInst)
-HANDLE_FUNCLETPAD_INST(52, CatchPad  , CatchPadInst)
-  LAST_FUNCLETPAD_INST(52)
+ FIRST_CAST_INST(39)
+HANDLE_CAST_INST(39, Trunc   , TruncInst   )  // Truncate integers
+HANDLE_CAST_INST(40, ZExt    , ZExtInst    )  // Zero extend integers
+HANDLE_CAST_INST(41, SExt    , SExtInst    )  // Sign extend integers
+HANDLE_CAST_INST(42, FPToUI  , FPToUIInst  )  // floating point -> UInt
+HANDLE_CAST_INST(43, FPToSI  , FPToSIInst  )  // floating point -> SInt
+HANDLE_CAST_INST(44, UIToFP  , UIToFPInst  )  // UInt -> floating point
+HANDLE_CAST_INST(45, SIToFP  , SIToFPInst  )  // SInt -> floating point
+HANDLE_CAST_INST(46, FPTrunc , FPTruncInst )  // Truncate floating point
+HANDLE_CAST_INST(47, FPExt   , FPExtInst   )  // Extend floating point
+HANDLE_CAST_INST(48, PtrToInt, PtrToIntInst)  // Pointer -> Integer
+HANDLE_CAST_INST(49, IntToPtr, IntToPtrInst)  // Integer -> Pointer
+HANDLE_CAST_INST(50, BitCast , BitCastInst )  // Type cast
+HANDLE_CAST_INST(51, AddrSpaceCast, AddrSpaceCastInst)  // addrspace cast
+  LAST_CAST_INST(51)
+
+ FIRST_FUNCLETPAD_INST(52)
+HANDLE_FUNCLETPAD_INST(52, CleanupPad, CleanupPadInst)
+HANDLE_FUNCLETPAD_INST(53, CatchPad  , CatchPadInst)
+  LAST_FUNCLETPAD_INST(53)
 
 // Other operators...
- FIRST_OTHER_INST(53)
-HANDLE_OTHER_INST(53, ICmp   , ICmpInst   )  // Integer comparison instruction
-HANDLE_OTHER_INST(54, FCmp   , FCmpInst   )  // Floating point comparison instr.
-HANDLE_OTHER_INST(55, PHI    , PHINode    )  // PHI node instruction
-HANDLE_OTHER_INST(56, Call   , CallInst   )  // Call a function
-HANDLE_OTHER_INST(57, Select , SelectInst )  // select instruction
-HANDLE_USER_INST (58, UserOp1, Instruction)  // May be used internally in a pass
-HANDLE_USER_INST (59, UserOp2, Instruction)  // Internal to passes only
-HANDLE_OTHER_INST(60, VAArg  , VAArgInst  )  // vaarg instruction
-HANDLE_OTHER_INST(61, ExtractElement, ExtractElementInst)// extract from vector
-HANDLE_OTHER_INST(62, InsertElement, InsertElementInst)  // insert into vector
-HANDLE_OTHER_INST(63, ShuffleVector, ShuffleVectorInst)  // shuffle two vectors.
-HANDLE_OTHER_INST(64, ExtractValue, ExtractValueInst)// extract from aggregate
-HANDLE_OTHER_INST(65, InsertValue, InsertValueInst)  // insert into aggregate
-HANDLE_OTHER_INST(66, LandingPad, LandingPadInst)  // Landing pad instruction.
-  LAST_OTHER_INST(66)
+ FIRST_OTHER_INST(54)
+HANDLE_OTHER_INST(54, ICmp   , ICmpInst   )  // Integer comparison instruction
+HANDLE_OTHER_INST(55, FCmp   , FCmpInst   )  // Floating point comparison instr.
+HANDLE_OTHER_INST(56, PHI    , PHINode    )  // PHI node instruction
+HANDLE_OTHER_INST(57, Call   , CallInst   )  // Call a function
+HANDLE_OTHER_INST(58, Select , SelectInst )  // select instruction
+HANDLE_USER_INST (59, UserOp1, Instruction)  // May be used internally in a pass
+HANDLE_USER_INST (60, UserOp2, Instruction)  // Internal to passes only
+HANDLE_OTHER_INST(61, VAArg  , VAArgInst  )  // vaarg instruction
+HANDLE_OTHER_INST(62, ExtractElement, ExtractElementInst)// extract from vector
+HANDLE_OTHER_INST(63, InsertElement, InsertElementInst)  // insert into vector
+HANDLE_OTHER_INST(64, ShuffleVector, ShuffleVectorInst)  // shuffle two vectors.
+HANDLE_OTHER_INST(65, ExtractValue, ExtractValueInst)// extract from aggregate
+HANDLE_OTHER_INST(66, InsertValue, InsertValueInst)  // insert into aggregate
+HANDLE_OTHER_INST(67, LandingPad, LandingPadInst)  // Landing pad instruction.
+  LAST_OTHER_INST(67)
 
 #undef  FIRST_TERM_INST
 #undef HANDLE_TERM_INST
 #undef   LAST_TERM_INST
 
 #undef  FIRST_UNARY_INST
 #undef HANDLE_UNARY_INST
 #undef   LAST_UNARY_INST

llvm/include/llvm/IR/Operator.h

Type *getSrcTy() const {
     return getOperand(0)->getType();
   }
 
   Type *getDestTy() const {
     return getType();
   }
 };
 
+class FreezeOperator : public ConcreteOperator<Operator, Instruction::Freeze>
+{};
+
 } // end namespace llvm
 
 #endif // LLVM_IR_OPERATOR_H

llvm/include/llvm/IR/PatternMatch.h

 
 /// Match 'fneg X' as 'fsub +-0.0, X'.
 template <typename RHS>
 inline BinaryOp_match<cstfp_pred_ty<is_any_zero_fp>, RHS, Instruction::FSub>
 m_FNegNSZ(const RHS &X) {
   return m_FSub(m_AnyZeroFP(), X);
 }
 
+template <typename Op_t> struct Freeze_match {
+  Op_t X;
+
+  Freeze_match(const Op_t &Op) : X(Op) {}
+  template <typename OpTy> bool match(OpTy *V) {
+    auto *I = dyn_cast<UnaryOperator>(V);
+    if (!I) return false;
+
+    if (isa<FreezeOperator>(I))
+      return X.match(I->getOperand(0));
+
+    return false;
+  }
+};
+
+/// Matches freeze.
+template <typename OpTy>
+inline Freeze_match<OpTy>
+m_Freeze(const OpTy &X) {
+  return Freeze_match<OpTy>(X);
+}
+
 template <typename LHS, typename RHS>
 inline BinaryOp_match<LHS, RHS, Instruction::Mul> m_Mul(const LHS &L,
                                                         const RHS &R) {
   return BinaryOp_match<LHS, RHS, Instruction::Mul>(L, R);
 }
 
 template <typename LHS, typename RHS>
 inline BinaryOp_match<LHS, RHS, Instruction::FMul> m_FMul(const LHS &L,

llvm/lib/AsmParser/LLLexer.cpp

#define INSTKEYWORD(STR, Enum)                                                 \
   do {                                                                         \
     if (Keyword == #STR) {                                                     \
       UIntVal = Instruction::Enum;                                             \
       return lltok::kw_##STR;                                                  \
     }                                                                          \
   } while (false)
 
   INSTKEYWORD(fneg,  FNeg);
+  INSTKEYWORD(freeze, Freeze);
 
   INSTKEYWORD(add,   Add);  INSTKEYWORD(fadd,   FAdd);
   INSTKEYWORD(sub,   Sub);  INSTKEYWORD(fsub,   FSub);
   INSTKEYWORD(mul,   Mul);  INSTKEYWORD(fmul,   FMul);
   INSTKEYWORD(udiv,  UDiv); INSTKEYWORD(sdiv,  SDiv); INSTKEYWORD(fdiv,  FDiv);
   INSTKEYWORD(urem,  URem); INSTKEYWORD(srem,  SRem); INSTKEYWORD(frem,  FRem);
   INSTKEYWORD(shl,   Shl);  INSTKEYWORD(lshr,  LShr); INSTKEYWORD(ashr,  AShr);
   INSTKEYWORD(and,   And);  INSTKEYWORD(or,    Or);   INSTKEYWORD(xor,   Xor);

llvm/lib/AsmParser/LLParser.cpp

if (Opc == Instruction::FCmp) {
         return Error(ID.Loc, "icmp requires pointer or integer operands");
       ID.ConstantVal = ConstantExpr::getICmp(Pred, Val0, Val1);
     }
     ID.Kind = ValID::t_Constant;
     return false;
   }
  
   // Unary Operators.
-  case lltok::kw_fneg: {
+  case lltok::kw_fneg:
+  case lltok::kw_freeze: {
     unsigned Opc = Lex.getUIntVal();
     Constant *Val;
     Lex.Lex();
     if (ParseToken(lltok::lparen, "expected '(' in unary constantexpr") ||
         ParseGlobalTypeAndValue(Val) ||
         ParseToken(lltok::rparen, "expected ')' in unary constantexpr"))
       return true;
     
     // Check that the type is valid for the operator.
     switch (Opc) {
     case Instruction::FNeg:
       if (!Val->getType()->isFPOrFPVectorTy())
         return Error(ID.Loc, "constexpr requires fp operands");
       break;
+    case Instruction::Freeze:
+      break;
     default: llvm_unreachable("Unknown unary operator!");
     }
     unsigned Flags = 0;
     Constant *C = ConstantExpr::get(Opc, Val, Flags);
     ID.ConstantVal = C;
     ID.Kind = ValID::t_Constant;
     return false;
   }
case lltok::kw_fneg: {
     FastMathFlags FMF = EatFastMathFlagsIfPresent();
     int Res = ParseUnaryOp(Inst, PFS, KeywordVal, /*IsFP*/true);
     if (Res != 0)
       return Res;
     if (FMF.any())
       Inst->setFastMathFlags(FMF);
     return false;
   }
+  case lltok::kw_freeze: return ParseUnaryOp(Inst, PFS, KeywordVal, false);
   // Binary Operators.
   case lltok::kw_add:
   case lltok::kw_sub:
   case lltok::kw_mul:
   case lltok::kw_shl: {
     bool NUW = EatIfPresent(lltok::kw_nuw);
     bool NSW = EatIfPresent(lltok::kw_nsw);
     if (!NUW) NUW = EatIfPresent(lltok::kw_nuw);

 
 //===----------------------------------------------------------------------===//
 // Unary Operators.
 //===----------------------------------------------------------------------===//
 
 /// ParseUnaryOp
 ///  ::= UnaryOp TypeAndValue ',' Value
 ///
-/// If IsFP is false, then any integer operand is allowed, if it is true, any fp
-/// operand is allowed.
+/// If IsFP is true, then fp operand is only allowed.
 bool LLParser::ParseUnaryOp(Instruction *&Inst, PerFunctionState &PFS,
                             unsigned Opc, bool IsFP) {
   LocTy Loc; Value *LHS;
   if (ParseTypeAndValue(LHS, Loc, PFS))
     return true;
 
-  bool Valid = IsFP ? LHS->getType()->isFPOrFPVectorTy()
-                    : LHS->getType()->isIntOrIntVectorTy();
+  bool Valid = !IsFP || LHS->getType()->isFPOrFPVectorTy();
 
   if (!Valid)
     return Error(Loc, "invalid operand type for instruction");
 
   Inst = UnaryOperator::Create((Instruction::UnaryOps)Opc, LHS);
   return false;
 }
 

llvm/lib/AsmParser/LLToken.h

enum Kind {
   kw_nand,
   kw_max,
   kw_min,
   kw_umax,
   kw_umin,
 
   // Instruction Opcodes (Opcode in UIntVal).
   kw_fneg,
+  kw_freeze,
   kw_add,
   kw_fadd,
   kw_sub,
   kw_fsub,
   kw_mul,
   kw_fmul,
   kw_udiv,
   kw_sdiv,

llvm/lib/Bitcode/Reader/BitcodeReader.cpp

static int getDecodedCastOpcode(unsigned Val) {
   case bitc::CAST_PTRTOINT: return Instruction::PtrToInt;
   case bitc::CAST_INTTOPTR: return Instruction::IntToPtr;
   case bitc::CAST_BITCAST : return Instruction::BitCast;
   case bitc::CAST_ADDRSPACECAST: return Instruction::AddrSpaceCast;
   }
 }
 
 static int getDecodedUnaryOpcode(unsigned Val, Type *Ty) {
-  bool IsFP = Ty->isFPOrFPVectorTy();
-  // UnOps are only valid for int/fp or vector of int/fp types
-  if (!IsFP && !Ty->isIntOrIntVectorTy())
-    return -1;
-
   switch (Val) {
   default:
     return -1;
   case bitc::UNOP_FNEG:
-    return IsFP ? Instruction::FNeg : -1;
+    return Ty->isFPOrFPVectorTy() ? Instruction::FNeg : -1;
+  case bitc::UNOP_FREEZE:
+    return Instruction::Freeze;
   }
 }
 
 static int getDecodedBinaryOpcode(unsigned Val, Type *Ty) {
   bool IsFP = Ty->isFPOrFPVectorTy();
   // BinOps are only valid for int/fp or vector of int/fp types
   if (!IsFP && !Ty->isIntOrIntVectorTy())
     return -1;
case bitc::FUNC_CODE_DEBUG_LOC: {      // DEBUG_LOC: [line, col, scope, ia]
       LastLoc = DebugLoc::get(Line, Col, Scope, IA, isImplicitCode);
       I->setDebugLoc(LastLoc);
       I = nullptr;
       continue;
     }
     case bitc::FUNC_CODE_INST_UNOP: {    // UNOP: [opval, ty, opcode]
       unsigned OpNum = 0;
       Value *LHS;
-      if (getValueTypePair(Record, OpNum, NextValueNo, LHS) ||
+      if (getValueTypePair(Record, OpNum, NextValueNo, LHS, &FullTy) ||
           OpNum+1 > Record.size())
         return error("Invalid record");
 
       int Opc = getDecodedUnaryOpcode(Record[OpNum++], LHS->getType());
       if (Opc == -1)
         return error("Invalid record");
       I = UnaryOperator::Create((Instruction::UnaryOps)Opc, LHS);
       InstructionList.push_back(I);

llvm/lib/Bitcode/Writer/BitcodeWriter.cpp

static unsigned getEncodedCastOpcode(unsigned Opcode) {
   case Instruction::AddrSpaceCast: return bitc::CAST_ADDRSPACECAST;
   }
 }
 
 static unsigned getEncodedUnaryOpcode(unsigned Opcode) {
   switch (Opcode) {
   default: llvm_unreachable("Unknown binary instruction!");
   case Instruction::FNeg: return bitc::UNOP_FNEG;
+  case Instruction::Freeze: return bitc::UNOP_FREEZE;
   }
 }
 
 static unsigned getEncodedBinaryOpcode(unsigned Opcode) {
   switch (Opcode) {
   default: llvm_unreachable("Unknown binary instruction!");
   case Instruction::Add:
   case Instruction::FAdd: return bitc::BINOP_ADD;
if (C->isNullValue()) {
       switch (CE->getOpcode()) {
       default:
         if (Instruction::isCast(CE->getOpcode())) {
           Code = bitc::CST_CODE_CE_CAST;
           Record.push_back(getEncodedCastOpcode(CE->getOpcode()));
           Record.push_back(VE.getTypeID(C->getOperand(0)->getType()));
           Record.push_back(VE.getValueID(C->getOperand(0)));
           AbbrevToUse = CONSTANTS_CE_CAST_Abbrev;
+        } else if (Instruction::isUnaryOp(CE->getOpcode())) {
+          assert(CE->getNumOperands() == 1 && "Unknown constant expr!");
+          Code = bitc::CST_CODE_CE_UNOP;
+          Record.push_back(getEncodedUnaryOpcode(CE->getOpcode()));
+          Record.push_back(VE.getValueID(C->getOperand(0)));
+          uint64_t Flags = getOptimizationFlags(CE);
+          if (Flags != 0) {
+            assert(CE->getOpcode() == Instruction::FNeg);
+            Record.push_back(Flags);
+          }
+          break;
         } else {
           assert(CE->getNumOperands() == 2 && "Unknown constant expr!");
           Code = bitc::CST_CODE_CE_BINOP;
           Record.push_back(getEncodedBinaryOpcode(CE->getOpcode()));
           Record.push_back(VE.getValueID(C->getOperand(0)));
           Record.push_back(VE.getValueID(C->getOperand(1)));
           uint64_t Flags = getOptimizationFlags(CE);
           if (Flags != 0)
             Record.push_back(Flags);
         }
         break;
-      case Instruction::FNeg: {
-        assert(CE->getNumOperands() == 1 && "Unknown constant expr!");
-        Code = bitc::CST_CODE_CE_UNOP;
-        Record.push_back(getEncodedUnaryOpcode(CE->getOpcode()));
-        Record.push_back(VE.getValueID(C->getOperand(0)));
-        uint64_t Flags = getOptimizationFlags(CE);
-        if (Flags != 0)
-          Record.push_back(Flags);
-        break;
-      }
       case Instruction::GetElementPtr: {
         Code = bitc::CST_CODE_CE_GEP;
         const auto *GO = cast<GEPOperator>(C);
         Record.push_back(VE.getTypeID(GO->getSourceElementType()));
         if (Optional<unsigned> Idx = GO->getInRangeIndex()) {
           Code = bitc::CST_CODE_CE_GEP_WITH_INRANGE_INDEX;
           Record.push_back((*Idx << 1) | GO->isInBounds());
         } else if (GO->isInBounds())
void ModuleBitcodeWriter::writeInstruction(const Instruction &I,
   switch (I.getOpcode()) {
   default:
     if (Instruction::isCast(I.getOpcode())) {
       Code = bitc::FUNC_CODE_INST_CAST;
       if (!pushValueAndType(I.getOperand(0), InstID, Vals))
         AbbrevToUse = FUNCTION_INST_CAST_ABBREV;
       Vals.push_back(VE.getTypeID(I.getType()));
       Vals.push_back(getEncodedCastOpcode(I.getOpcode()));
+    } else if (isa<UnaryOperator>(I)) {
+      Code = bitc::FUNC_CODE_INST_UNOP;
+      if (!pushValueAndType(I.getOperand(0), InstID, Vals))
+        AbbrevToUse = FUNCTION_INST_UNOP_ABBREV;
+      Vals.push_back(getEncodedUnaryOpcode(I.getOpcode()));
+      uint64_t Flags = getOptimizationFlags(&I);
+      if (Flags != 0) {
+        if (AbbrevToUse == FUNCTION_INST_UNOP_ABBREV)
+          AbbrevToUse = FUNCTION_INST_UNOP_FLAGS_ABBREV;
+        Vals.push_back(Flags);
+      }
     } else {
       assert(isa<BinaryOperator>(I) && "Unknown instruction!");
       Code = bitc::FUNC_CODE_INST_BINOP;
       if (!pushValueAndType(I.getOperand(0), InstID, Vals))
         AbbrevToUse = FUNCTION_INST_BINOP_ABBREV;
       pushValue(I.getOperand(1), InstID, Vals);
       Vals.push_back(getEncodedBinaryOpcode(I.getOpcode()));
       uint64_t Flags = getOptimizationFlags(&I);
       if (Flags != 0) {
         if (AbbrevToUse == FUNCTION_INST_BINOP_ABBREV)
           AbbrevToUse = FUNCTION_INST_BINOP_FLAGS_ABBREV;
         Vals.push_back(Flags);
       }
     }
     break;
-  case Instruction::FNeg: {
-    Code = bitc::FUNC_CODE_INST_UNOP;
-    if (!pushValueAndType(I.getOperand(0), InstID, Vals))
-      AbbrevToUse = FUNCTION_INST_UNOP_ABBREV;
-    Vals.push_back(getEncodedUnaryOpcode(I.getOpcode()));
-    uint64_t Flags = getOptimizationFlags(&I);
-    if (Flags != 0) {
-      if (AbbrevToUse == FUNCTION_INST_UNOP_ABBREV)
-        AbbrevToUse = FUNCTION_INST_UNOP_FLAGS_ABBREV;
-      Vals.push_back(Flags);
-    }
-    break;
-  }
   case Instruction::GetElementPtr: {
     Code = bitc::FUNC_CODE_INST_GEP;
     AbbrevToUse = FUNCTION_INST_GEP_ABBREV;
     auto &GEPInst = cast<GetElementPtrInst>(I);
     Vals.push_back(GEPInst.isInBounds());
     Vals.push_back(VE.getTypeID(GEPInst.getSourceElementType()));
     for (unsigned i = 0, e = I.getNumOperands(); i != e; ++i)
       pushValueAndType(I.getOperand(i), InstID, Vals);

llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.h

 private:
   // These all get lowered before this pass.
   void visitInvoke(const InvokeInst &I);
   void visitCallBr(const CallBrInst &I);
   void visitResume(const ResumeInst &I);
 
   void visitUnary(const User &I, unsigned Opcode);
   void visitFNeg(const User &I) { visitUnary(I, ISD::FNEG); }
+  void visitFreeze(const User &I);
 
   void visitBinary(const User &I, unsigned Opcode);
   void visitShift(const User &I, unsigned Opcode);
   void visitAdd(const User &I)  { visitBinary(I, ISD::ADD); }
   void visitFAdd(const User &I) { visitBinary(I, ISD::FADD); }
   void visitSub(const User &I)  { visitBinary(I, ISD::SUB); }
   void visitFSub(const User &I);
   void visitMul(const User &I)  { visitBinary(I, ISD::MUL); }

llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

if (NumClusters > 3 && TM.getOptLevel() != CodeGenOpt::None &&
       // For optimized builds, lower large range as a balanced binary tree.
       splitWorkItem(WorkList, W, SI.getCondition(), SwitchMBB);
       continue;
     }
 
     lowerWorkItem(W, SI.getCondition(), SwitchMBB, DefaultMBB);
   }
 }
+
+void SelectionDAGBuilder::visitFreeze(const User &I) {
+  SDValue N = getValue(I.getOperand(0));
+  setValue(&I, N);
+}

llvm/lib/CodeGen/TargetLoweringBase.cpp

#include "llvm/IR/Instruction.def"
   case UserOp2:        return 0;
   case VAArg:          return 0;
   case ExtractElement: return ISD::EXTRACT_VECTOR_ELT;
   case InsertElement:  return ISD::INSERT_VECTOR_ELT;
   case ShuffleVector:  return ISD::VECTOR_SHUFFLE;
   case ExtractValue:   return ISD::MERGE_VALUES;
   case InsertValue:    return ISD::MERGE_VALUES;
   case LandingPad:     return 0;
+  case Freeze:         return 0;
   }
 
   llvm_unreachable("Unknown instruction type encountered!");
 }
 
 std::pair<int, MVT>
 TargetLoweringBase::getTypeLegalizationCost(const DataLayout &DL,
                                             Type *Ty) const {

llvm/lib/IR/ConstantFold.cpp

Constant *llvm::ConstantFoldInsertValueInstruction(Constant *Agg,
   if (ArrayType *AT = dyn_cast<ArrayType>(Agg->getType()))
     return ConstantArray::get(AT, Result);
   return ConstantVector::get(Result);
 }
 
 Constant *llvm::ConstantFoldUnaryInstruction(unsigned Opcode, Constant *C) {
   assert(Instruction::isUnaryOp(Opcode) && "Non-unary instruction detected");
 
+  switch (static_cast<Instruction::UnaryOps>(Opcode)) {
+  default:
+    break;
+  case Instruction::FNeg: {
     // Handle scalar UndefValue. Vectors are always evaluated per element.
     bool HasScalarUndef = !C->getType()->isVectorTy() && isa<UndefValue>(C);
 
     if (HasScalarUndef) {
-    switch (static_cast<Instruction::UnaryOps>(Opcode)) {
-    case Instruction::FNeg:
       return C; // -undef -> undef
-    case Instruction::UnaryOpsEnd:
-      llvm_unreachable("Invalid UnaryOp");
-    }
     }
 
     // Constant should not be UndefValue, unless these are vector constants.
     assert(!HasScalarUndef && "Unexpected UndefValue");
-  // We only have FP UnaryOps right now.
     assert(!isa<ConstantInt>(C) && "Unexpected Integer UnaryOp");
 
     if (ConstantFP *CFP = dyn_cast<ConstantFP>(C)) {
       const APFloat &CV = CFP->getValueAPF();
-    switch (Opcode) {
-    default:
-      break;
-    case Instruction::FNeg:
       return ConstantFP::get(C->getContext(), neg(CV));
-    }
     } else if (VectorType *VTy = dyn_cast<VectorType>(C->getType())) {
       // Fold each element and create a vector constant from those constants.
       SmallVector<Constant*, 16> Result;
       Type *Ty = IntegerType::get(VTy->getContext(), 32);
       for (unsigned i = 0, e = VTy->getNumElements(); i != e; ++i) {
         Constant *ExtractIdx = ConstantInt::get(Ty, i);
         Constant *Elt = ConstantExpr::getExtractElement(C, ExtractIdx);
 
         Result.push_back(ConstantExpr::get(Opcode, Elt));
       }
 
       return ConstantVector::get(Result);
     }
+    break;
+  }
+  case Instruction::Freeze: {
+    if (ConstantFP *CFP = dyn_cast<ConstantFP>(C)) {
+      return CFP;
+    } else if (ConstantInt *CINT = dyn_cast<ConstantInt>(C)) {
+      return CINT;
+    } else if (GlobalVariable *GV = dyn_cast<GlobalVariable>(C)) {
+      // A global variable is neither undef nor poison.
+      return GV;
+    }
+    break;
+  }
+  case Instruction::UnaryOpsEnd:
+    llvm_unreachable("Invalid UnaryOp");
+  }
 
   // We don't know how to fold this.
   return nullptr;
 }
 
 Constant *llvm::ConstantFoldBinaryInstruction(unsigned Opcode, Constant *C1,
                                               Constant *C2) {
   assert(Instruction::isBinaryOp(Opcode) && "Non-binary instruction detected");

llvm/lib/IR/Core.cpp

LLVMValueRef LLVMBuildNUWNeg(LLVMBuilderRef B, LLVMValueRef V,
                              const char *Name) {
   return wrap(unwrap(B)->CreateNUWNeg(unwrap(V), Name));
 }
 
 LLVMValueRef LLVMBuildFNeg(LLVMBuilderRef B, LLVMValueRef V, const char *Name) {
   return wrap(unwrap(B)->CreateFNeg(unwrap(V), Name));
 }
 
+LLVMValueRef LLVMBuildFreeze(LLVMBuilderRef B, LLVMValueRef V,
+                             const char *Name) {
+  return wrap(unwrap(B)->CreateFreeze(unwrap(V), Name));
+}
+
 LLVMValueRef LLVMBuildNot(LLVMBuilderRef B, LLVMValueRef V, const char *Name) {
   return wrap(unwrap(B)->CreateNot(unwrap(V), Name));
 }
 
 /*--.. Memory ..............................................................--*/
 
 LLVMValueRef LLVMBuildMalloc(LLVMBuilderRef B, LLVMTypeRef Ty,
                              const char *Name) {

llvm/lib/IR/Instruction.cpp

const char *Instruction::getOpcodeName(unsigned OpCode) {
   case CleanupRet: return "cleanupret";
   case CatchRet: return "catchret";
   case CatchPad: return "catchpad";
   case CatchSwitch: return "catchswitch";
   case CallBr: return "callbr";
 
   // Standard unary operators...
   case FNeg: return "fneg";
+  case Freeze: return "freeze";
 
   // Standard binary operators...
   case Add: return "add";
   case FAdd: return "fadd";
   case Sub: return "sub";
   case FSub: return "fsub";
   case Mul: return "mul";
   case FMul: return "fmul";

llvm/lib/IR/Instructions.cpp

#ifndef NDEBUG
   switch (getOpcode()) {
   case FNeg:
     assert(getType() == LHS->getType() &&
            "Unary operation should return same type as operand!");
     assert(getType()->isFPOrFPVectorTy() &&
            "Tried to create a floating-point operation on a "
            "non-floating-point type!");
     break;
+  case Freeze:
+    // Freeze can take any type as an argument.
+    break;
   default: llvm_unreachable("Invalid opcode provided");
   }
 #endif
 }
 
 //===----------------------------------------------------------------------===//
 //                             BinaryOperator Class
 //===----------------------------------------------------------------------===//

llvm/lib/IR/Verifier.cpp

void Verifier::visitUnaryOperator(UnaryOperator &U) {
 
   switch (U.getOpcode()) {
   // Check that floating-point arithmetic operators are only used with
   // floating-point operands.
   case Instruction::FNeg:
     Assert(U.getType()->isFPOrFPVectorTy(),
            "FNeg operator only works with float types!", &U);
     break;
+  case Instruction::Freeze:
+    // Freeze can take all kinds of types.
+    break;
   default:
     llvm_unreachable("Unknown UnaryOperator opcode!");
   }
 
   visitInstruction(U);
 }
 
 /// visitBinaryOperator - Check that both arguments to the binary operator are

llvm/test/Bindings/OCaml/core.ml

let test_constants () =
   insist (i1_type = type_of c);
   insist (is_undef c);
 
   group "constant arithmetic";
   (* CHECK: @const_neg = global i64 sub
    * CHECK: @const_nsw_neg = global i64 sub nsw
    * CHECK: @const_nuw_neg = global i64 sub nuw
    * CHECK: @const_fneg = global double fneg
+   * CHECK: @const_freeze = global i64 freeze
    * CHECK: @const_not = global i64 xor
    * CHECK: @const_add = global i64 add
    * CHECK: @const_nsw_add = global i64 add nsw
    * CHECK: @const_nuw_add = global i64 add nuw
    * CHECK: @const_fadd = global double fadd
    * CHECK: @const_sub = global i64 sub
    * CHECK: @const_nsw_sub = global i64 sub nsw
    * CHECK: @const_nuw_sub = global i64 sub nuw
let test_constants () =
   let ffive = const_uitofp five double_type in
   let foldbomb_gv = define_global "FoldBomb" (const_null i8_type) m in
   let foldbomb = const_ptrtoint foldbomb_gv i64_type in
   let ffoldbomb = const_uitofp foldbomb double_type in
   ignore (define_global "const_neg" (const_neg foldbomb) m);
   ignore (define_global "const_nsw_neg" (const_nsw_neg foldbomb) m);
   ignore (define_global "const_nuw_neg" (const_nuw_neg foldbomb) m);
   ignore (define_global "const_fneg" (const_fneg ffoldbomb) m);
+  ignore (define_global "const_freeze" (const_freeze foldbomb) m);
   ignore (define_global "const_not" (const_not foldbomb) m);
   ignore (define_global "const_add" (const_add foldbomb five) m);
   ignore (define_global "const_nsw_add" (const_nsw_add foldbomb five) m);
   ignore (define_global "const_nuw_add" (const_nuw_add foldbomb five) m);
   ignore (define_global "const_fadd" (const_fadd ffoldbomb ffive) m);
   ignore (define_global "const_sub" (const_sub foldbomb five) m);
   ignore (define_global "const_nsw_sub" (const_nsw_sub foldbomb five) m);
   ignore (define_global "const_nuw_sub" (const_nuw_sub foldbomb five) m);
group "arithmetic"; begin
     ignore (build_ashr p1 p2 "build_ashl" b);
     ignore (build_and p1 p2 "build_and" b);
     ignore (build_or p1 p2 "build_or" b);
     ignore (build_xor p1 p2 "build_xor" b);
     ignore (build_neg p1 "build_neg" b);
     ignore (build_nsw_neg p1 "build_nsw_neg" b);
     ignore (build_nuw_neg p1 "build_nuw_neg" b);
     ignore (build_fneg f1 "build_fneg" b);
+    ignore (build_freeze f1 "build_freeze" b);
     ignore (build_not p1 "build_not" b);
     ignore (build_unreachable b)
   end;
 
   group "memory"; begin
     let bb08 = append_block context "Bb08" fn in
     let b = builder_at_end context bb08 in
 

llvm/test/Bindings/llvm-c/freeze.ll

+; RUN: llvm-as < %s | llvm-dis > %t.orig
+; RUN: llvm-as < %s | llvm-c-test --echo > %t.echo
+; RUN: diff -w %t.orig %t.echo
+
+%struct.T = type { i32, i32 }
+
+define i32 @f(i32 %arg, <2 x i32> %arg2, float %arg3, <2 x float> %arg4,
+              i8* %arg5, %struct.T %arg6, [2 x i32] %arg7, { i32, i32 } %arg8) {
+  %1 = freeze i32 %arg
+  %2 = freeze i32 10
+  %3 = freeze i32 %1
+  %4 = freeze i32 undef
+  %5 = freeze i666 11
+  %6 = freeze <2 x i32> %arg2
+  %7 = freeze float %arg3
+  %8 = freeze <2 x float> %arg4
+  %9 = freeze i8* %arg5
+  %10 = freeze %struct.T %arg6
+  %11 = freeze [2 x i32] %arg7
+  %12 = freeze { i32, i32 } %arg8
+  ret i32 %1
+}

llvm/test/Bitcode/compatibility.ll

terminate:
   ; CHECK: cleanuppad within none []
   ; CHECK-NEXT: unreachable
 
 continue:
   ret i32 0
 }
 
 ; Instructions -- Unary Operations
-define void @instructions.unops(double %op1) {
+define void @instructions.unops(double %op1, i32 %op2, <2 x i32> %op3, i8* %op4) {
   fneg double %op1
   ; CHECK: fneg double %op1
+  freeze i32 %op2
+  ; CHECK: freeze i32 %op2
+  freeze double %op1
+  ; CHECK: freeze double %op1
+  freeze <2 x i32> %op3
+  ; CHECK: freeze <2 x i32> %op3
+  freeze i8* %op4
+  ; CHECK: freeze i8* %op4
   ret void
 }
 
 ; Instructions -- Binary Operations
 define void @instructions.binops(i8 %op1, i8 %op2) {
   ; nuw x nsw
   add i8 %op1, %op2
   ; CHECK: add i8 %op1, %op2

 
 define void @instructions.strictfp() strictfp {
   call void @f.strictfp() strictfp
   ; CHECK: call void @f.strictfp() #43
 
   ret void
 }
 
+define i64 @constexpr_freeze() {
+  ret i64 freeze (i64 32)
+}
+
 ; immarg attribute
 declare void @llvm.test.immarg.intrinsic(i32 immarg)
 ; CHECK: declare void @llvm.test.immarg.intrinsic(i32 immarg)
 
 ; byval attribute with type
 %named_type = type [8 x i8]
 declare void @byval_type(i32* byval(i32) align 2)
 declare void @byval_type2({ i8, i8* }* byval({ i8, i8* }))

llvm/test/Transforms/MergeFunc/inline-asm.ll

 ; RUN: opt -mergefunc -S < %s | FileCheck %s
 
 ; CHECK-LABEL: @int_ptr_arg_different
 ; CHECK-NEXT: call void asm
 
-; CHECK-LABEL: @int_ptr_null
-; CHECK-NEXT: tail call void @float_ptr_null()
-
 ; CHECK-LABEL: @int_ptr_arg_same
 ; CHECK-NEXT: %2 = bitcast i32* %0 to float*
 ; CHECK-NEXT: tail call void @float_ptr_arg_same(float* %2)
 
+; CHECK-LABEL: @int_ptr_null
+; CHECK-NEXT: tail call void @float_ptr_null()
+
 ; Used to satisfy minimum size limit
 declare void @stuff()
 
 ; Can be merged
 define void @float_ptr_null() {
   call void asm "nop", "r"(float* null)
   call void @stuff()
   ret void

llvm/tools/llvm-c-test/echo.cpp

switch(Op) {
         LLVMValueRef Agg = CloneValue(LLVMGetOperand(Src, 0));
         LLVMValueRef V = CloneValue(LLVMGetOperand(Src, 1));
         if (LLVMGetNumIndices(Src) != 1)
           report_fatal_error("Expected only one indice");
         auto I = LLVMGetIndices(Src)[0];
         Dst = LLVMBuildInsertValue(Builder, Agg, V, I, Name);
         break;
       }
+      case LLVMFreeze: {
+        LLVMValueRef Arg = CloneValue(LLVMGetOperand(Src, 0));
+        Dst = LLVMBuildFreeze(Builder, Arg, Name);
+        break;
+      }
       default:
         break;
     }
 
     if (Dst == nullptr) {
       fprintf(stderr, "%d is not a supported opcode\n", Op);
       exit(-1);
     }