Skip to content

Commit a21d3da

Browse files
nlewyckynlewycky
committed
Remove the vicmp and vfcmp instructions. Because we never had a release with
these instructions, no autoupgrade or backwards compatibility support is provided. llvm-svn: 74991
1 parent d8ffadc commit a21d3da

31 files changed

+99
-664
lines changed

‎llvm/docs/LangRef.html

Lines changed: 0 additions & 111 deletions
Original file line numberDiff line numberDiff line change
@@ -155,8 +155,6 @@
155155
<ol>
156156
<li><a href="#i_icmp">'<tt>icmp</tt>' Instruction</a></li>
157157
<li><a href="#i_fcmp">'<tt>fcmp</tt>' Instruction</a></li>
158-
<li><a href="#i_vicmp">'<tt>vicmp</tt>' Instruction</a></li>
159-
<li><a href="#i_vfcmp">'<tt>vfcmp</tt>' Instruction</a></li>
160158
<li><a href="#i_phi">'<tt>phi</tt>' Instruction</a></li>
161159
<li><a href="#i_select">'<tt>select</tt>' Instruction</a></li>
162160
<li><a href="#i_call">'<tt>call</tt>' Instruction</a></li>
@@ -2042,12 +2040,6 @@ <h5>Examples:</h5>
20422040
<dt><b><tt>fcmp COND ( VAL1, VAL2 )</tt></b></dt>
20432041
<dd>Performs the <a href="#i_fcmp">fcmp operation</a> on constants.</dd>
20442042

2045-
<dt><b><tt>vicmp COND ( VAL1, VAL2 )</tt></b></dt>
2046-
<dd>Performs the <a href="#i_vicmp">vicmp operation</a> on constants.</dd>
2047-
2048-
<dt><b><tt>vfcmp COND ( VAL1, VAL2 )</tt></b></dt>
2049-
<dd>Performs the <a href="#i_vfcmp">vfcmp operation</a> on constants.</dd>
2050-
20512043
<dt><b><tt>extractelement ( VAL, IDX )</tt></b></dt>
20522044

20532045
<dd>Perform the <a href="#i_extractelement">extractelement
@@ -4504,109 +4496,6 @@ <h5>Example:</h5>
45044496

45054497
</div>
45064498

4507-
<!-- _______________________________________________________________________ -->
4508-
<div class="doc_subsubsection">
4509-
<a name="i_vicmp">'<tt>vicmp</tt>' Instruction</a>
4510-
</div>
4511-
<div class="doc_text">
4512-
<h5>Syntax:</h5>
4513-
<pre> &lt;result&gt; = vicmp &lt;cond&gt; &lt;ty&gt; &lt;op1&gt;, &lt;op2&gt; <i>; yields {ty}:result</i>
4514-
</pre>
4515-
<h5>Overview:</h5>
4516-
<p>The '<tt>vicmp</tt>' instruction returns an integer vector value based on
4517-
element-wise comparison of its two integer vector operands.</p>
4518-
<h5>Arguments:</h5>
4519-
<p>The '<tt>vicmp</tt>' instruction takes three operands. The first operand is
4520-
the condition code indicating the kind of comparison to perform. It is not
4521-
a value, just a keyword. The possible condition code are:</p>
4522-
<ol>
4523-
<li><tt>eq</tt>: equal</li>
4524-
<li><tt>ne</tt>: not equal </li>
4525-
<li><tt>ugt</tt>: unsigned greater than</li>
4526-
<li><tt>uge</tt>: unsigned greater or equal</li>
4527-
<li><tt>ult</tt>: unsigned less than</li>
4528-
<li><tt>ule</tt>: unsigned less or equal</li>
4529-
<li><tt>sgt</tt>: signed greater than</li>
4530-
<li><tt>sge</tt>: signed greater or equal</li>
4531-
<li><tt>slt</tt>: signed less than</li>
4532-
<li><tt>sle</tt>: signed less or equal</li>
4533-
</ol>
4534-
<p>The remaining two arguments must be <a href="#t_vector">vector</a> or
4535-
<a href="#t_integer">integer</a> typed. They must also be identical types.</p>
4536-
<h5>Semantics:</h5>
4537-
<p>The '<tt>vicmp</tt>' instruction compares <tt>op1</tt> and <tt>op2</tt>
4538-
according to the condition code given as <tt>cond</tt>. The comparison yields a
4539-
<a href="#t_vector">vector</a> of <a href="#t_integer">integer</a> result, of
4540-
identical type as the values being compared. The most significant bit in each
4541-
element is 1 if the element-wise comparison evaluates to true, and is 0
4542-
otherwise. All other bits of the result are undefined. The condition codes
4543-
are evaluated identically to the <a href="#i_icmp">'<tt>icmp</tt>'
4544-
instruction</a>.</p>
4545-
4546-
<h5>Example:</h5>
4547-
<pre>
4548-
&lt;result&gt; = vicmp eq &lt;2 x i32&gt; &lt; i32 4, i32 0&gt;, &lt; i32 5, i32 0&gt; <i>; yields: result=&lt;2 x i32&gt; &lt; i32 0, i32 -1 &gt;</i>
4549-
&lt;result&gt; = vicmp ult &lt;2 x i8 &gt; &lt; i8 1, i8 2&gt;, &lt; i8 2, i8 2 &gt; <i>; yields: result=&lt;2 x i8&gt; &lt; i8 -1, i8 0 &gt;</i>
4550-
</pre>
4551-
</div>
4552-
4553-
<!-- _______________________________________________________________________ -->
4554-
<div class="doc_subsubsection">
4555-
<a name="i_vfcmp">'<tt>vfcmp</tt>' Instruction</a>
4556-
</div>
4557-
<div class="doc_text">
4558-
<h5>Syntax:</h5>
4559-
<pre> &lt;result&gt; = vfcmp &lt;cond&gt; &lt;ty&gt; &lt;op1&gt;, &lt;op2&gt;</pre>
4560-
<h5>Overview:</h5>
4561-
<p>The '<tt>vfcmp</tt>' instruction returns an integer vector value based on
4562-
element-wise comparison of its two floating point vector operands. The output
4563-
elements have the same width as the input elements.</p>
4564-
<h5>Arguments:</h5>
4565-
<p>The '<tt>vfcmp</tt>' instruction takes three operands. The first operand is
4566-
the condition code indicating the kind of comparison to perform. It is not
4567-
a value, just a keyword. The possible condition code are:</p>
4568-
<ol>
4569-
<li><tt>false</tt>: no comparison, always returns false</li>
4570-
<li><tt>oeq</tt>: ordered and equal</li>
4571-
<li><tt>ogt</tt>: ordered and greater than </li>
4572-
<li><tt>oge</tt>: ordered and greater than or equal</li>
4573-
<li><tt>olt</tt>: ordered and less than </li>
4574-
<li><tt>ole</tt>: ordered and less than or equal</li>
4575-
<li><tt>one</tt>: ordered and not equal</li>
4576-
<li><tt>ord</tt>: ordered (no nans)</li>
4577-
<li><tt>ueq</tt>: unordered or equal</li>
4578-
<li><tt>ugt</tt>: unordered or greater than </li>
4579-
<li><tt>uge</tt>: unordered or greater than or equal</li>
4580-
<li><tt>ult</tt>: unordered or less than </li>
4581-
<li><tt>ule</tt>: unordered or less than or equal</li>
4582-
<li><tt>une</tt>: unordered or not equal</li>
4583-
<li><tt>uno</tt>: unordered (either nans)</li>
4584-
<li><tt>true</tt>: no comparison, always returns true</li>
4585-
</ol>
4586-
<p>The remaining two arguments must be <a href="#t_vector">vector</a> of
4587-
<a href="#t_floating">floating point</a> typed. They must also be identical
4588-
types.</p>
4589-
<h5>Semantics:</h5>
4590-
<p>The '<tt>vfcmp</tt>' instruction compares <tt>op1</tt> and <tt>op2</tt>
4591-
according to the condition code given as <tt>cond</tt>. The comparison yields a
4592-
<a href="#t_vector">vector</a> of <a href="#t_integer">integer</a> result, with
4593-
an identical number of elements as the values being compared, and each element
4594-
having identical with to the width of the floating point elements. The most
4595-
significant bit in each element is 1 if the element-wise comparison evaluates to
4596-
true, and is 0 otherwise. All other bits of the result are undefined. The
4597-
condition codes are evaluated identically to the
4598-
<a href="#i_fcmp">'<tt>fcmp</tt>' instruction</a>.</p>
4599-
4600-
<h5>Example:</h5>
4601-
<pre>
4602-
<i>; yields: result=&lt;2 x i32&gt; &lt; i32 0, i32 -1 &gt;</i>
4603-
&lt;result&gt; = vfcmp oeq &lt;2 x float&gt; &lt; float 4, float 0 &gt;, &lt; float 5, float 0 &gt;
4604-
4605-
<i>; yields: result=&lt;2 x i64&gt; &lt; i64 -1, i64 0 &gt;</i>
4606-
&lt;result&gt; = vfcmp ult &lt;2 x double&gt; &lt; double 1, double 2 &gt;, &lt; double 2, double 2&gt;
4607-
</pre>
4608-
</div>
4609-
46104499
<!-- _______________________________________________________________________ -->
46114500
<div class="doc_subsubsection">
46124501
<a name="i_phi">'<tt>phi</tt>' Instruction</a>

‎llvm/include/llvm-c/Core.h

Lines changed: 0 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -341,8 +341,6 @@ void LLVMDisposeTypeHandle(LLVMTypeHandleRef TypeHandle);
341341
macro(CmpInst) \
342342
macro(FCmpInst) \
343343
macro(ICmpInst) \
344-
macro(VFCmpInst) \
345-
macro(VICmpInst) \
346344
macro(ExtractElementInst) \
347345
macro(GetElementPtrInst) \
348346
macro(InsertElementInst) \

‎llvm/include/llvm/Bitcode/LLVMBitCodes.h

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -210,7 +210,8 @@ namespace bitc {
210210
FUNC_CODE_INST_GETRESULT = 25, // GETRESULT: [ty, opval, n]
211211
FUNC_CODE_INST_EXTRACTVAL = 26, // EXTRACTVAL: [n x operands]
212212
FUNC_CODE_INST_INSERTVAL = 27, // INSERTVAL: [n x operands]
213-
// fcmp/icmp returning Int1TY or vector of Int1Ty, NOT for vicmp/vfcmp
213+
// fcmp/icmp returning Int1TY or vector of Int1Ty. Same as CMP, exists to
214+
// support legacy vicmp/vfcmp instructions.
214215
FUNC_CODE_INST_CMP2 = 28, // CMP2: [opty, opval, opval, pred]
215216
// new select on i1 or [N x i1]
216217
FUNC_CODE_INST_VSELECT = 29 // VSELECT: [ty,opval,opval,predty,pred]

‎llvm/include/llvm/Constants.h

Lines changed: 1 addition & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -710,8 +710,7 @@ class ConstantExpr : public Constant {
710710
///
711711
static Constant *get(unsigned Opcode, Constant *C1, Constant *C2);
712712

713-
/// @brief Return an ICmp, FCmp, VICmp, or VFCmp comparison operator constant
714-
/// expression.
713+
/// @brief Return an ICmp or FCmp comparison operator constant expression.
715714
static Constant *getCompare(unsigned short pred, Constant *C1, Constant *C2);
716715

717716
/// ConstantExpr::get* - Return some common constants without having to
@@ -737,8 +736,6 @@ class ConstantExpr : public Constant {
737736
static Constant *getXor(Constant *C1, Constant *C2);
738737
static Constant *getICmp(unsigned short pred, Constant *LHS, Constant *RHS);
739738
static Constant *getFCmp(unsigned short pred, Constant *LHS, Constant *RHS);
740-
static Constant *getVICmp(unsigned short pred, Constant *LHS, Constant *RHS);
741-
static Constant *getVFCmp(unsigned short pred, Constant *LHS, Constant *RHS);
742739
static Constant *getShl(Constant *C1, Constant *C2);
743740
static Constant *getLShr(Constant *C1, Constant *C2);
744741
static Constant *getAShr(Constant *C1, Constant *C2);

‎llvm/include/llvm/InstrTypes.h

Lines changed: 2 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -655,14 +655,12 @@ class CmpInst: public Instruction {
655655
static inline bool classof(const CmpInst *) { return true; }
656656
static inline bool classof(const Instruction *I) {
657657
return I->getOpcode() == Instruction::ICmp ||
658-
I->getOpcode() == Instruction::FCmp ||
659-
I->getOpcode() == Instruction::VICmp ||
660-
I->getOpcode() == Instruction::VFCmp;
658+
I->getOpcode() == Instruction::FCmp;
661659
}
662660
static inline bool classof(const Value *V) {
663661
return isa<Instruction>(V) && classof(cast<Instruction>(V));
664662
}
665-
/// @brief Create a result type for fcmp/icmp (but not vicmp/vfcmp)
663+
/// @brief Create a result type for fcmp/icmp
666664
static const Type* makeCmpResultType(const Type* opnd_type) {
667665
if (const VectorType* vt = dyn_cast<const VectorType>(opnd_type)) {
668666
return VectorType::get(Type::Int1Ty, vt->getNumElements());

‎llvm/include/llvm/Instruction.def

Lines changed: 1 addition & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -169,10 +169,8 @@ HANDLE_OTHER_INST(52, InsertElement, InsertElementInst) // insert into vector
169169
HANDLE_OTHER_INST(53, ShuffleVector, ShuffleVectorInst) // shuffle two vectors.
170170
HANDLE_OTHER_INST(54, ExtractValue, ExtractValueInst)// extract from aggregate
171171
HANDLE_OTHER_INST(55, InsertValue, InsertValueInst) // insert into aggregate
172-
HANDLE_OTHER_INST(56, VICmp , VICmpInst ) // Vec Int comparison instruction.
173-
HANDLE_OTHER_INST(57, VFCmp , VFCmpInst ) // Vec FP point comparison instr.
174172

175-
LAST_OTHER_INST(57)
173+
LAST_OTHER_INST(55)
176174

177175
#undef FIRST_TERM_INST
178176
#undef HANDLE_TERM_INST

‎llvm/include/llvm/Instructions.h

Lines changed: 0 additions & 112 deletions
Original file line numberDiff line numberDiff line change
@@ -861,118 +861,6 @@ class FCmpInst: public CmpInst {
861861

862862
};
863863

864-
//===----------------------------------------------------------------------===//
865-
// VICmpInst Class
866-
//===----------------------------------------------------------------------===//
867-
868-
/// This instruction compares its operands according to the predicate given
869-
/// to the constructor. It only operates on vectors of integers.
870-
/// The operands must be identical types.
871-
/// @brief Represents a vector integer comparison operator.
872-
class VICmpInst: public CmpInst {
873-
public:
874-
/// @brief Constructor with insert-before-instruction semantics.
875-
VICmpInst(
876-
Predicate pred, ///< The predicate to use for the comparison
877-
Value *LHS, ///< The left-hand-side of the expression
878-
Value *RHS, ///< The right-hand-side of the expression
879-
const std::string &NameStr = "", ///< Name of the instruction
880-
Instruction *InsertBefore = 0 ///< Where to insert
881-
) : CmpInst(LHS->getType(), Instruction::VICmp, pred, LHS, RHS, NameStr,
882-
InsertBefore) {
883-
assert(pred >= CmpInst::FIRST_ICMP_PREDICATE &&
884-
pred <= CmpInst::LAST_ICMP_PREDICATE &&
885-
"Invalid VICmp predicate value");
886-
assert(getOperand(0)->getType() == getOperand(1)->getType() &&
887-
"Both operands to VICmp instruction are not of the same type!");
888-
}
889-
890-
/// @brief Constructor with insert-at-block-end semantics.
891-
VICmpInst(
892-
Predicate pred, ///< The predicate to use for the comparison
893-
Value *LHS, ///< The left-hand-side of the expression
894-
Value *RHS, ///< The right-hand-side of the expression
895-
const std::string &NameStr, ///< Name of the instruction
896-
BasicBlock *InsertAtEnd ///< Block to insert into.
897-
) : CmpInst(LHS->getType(), Instruction::VICmp, pred, LHS, RHS, NameStr,
898-
InsertAtEnd) {
899-
assert(pred >= CmpInst::FIRST_ICMP_PREDICATE &&
900-
pred <= CmpInst::LAST_ICMP_PREDICATE &&
901-
"Invalid VICmp predicate value");
902-
assert(getOperand(0)->getType() == getOperand(1)->getType() &&
903-
"Both operands to VICmp instruction are not of the same type!");
904-
}
905-
906-
/// @brief Return the predicate for this instruction.
907-
Predicate getPredicate() const { return Predicate(SubclassData); }
908-
909-
virtual VICmpInst *clone() const;
910-
911-
// Methods for support type inquiry through isa, cast, and dyn_cast:
912-
static inline bool classof(const VICmpInst *) { return true; }
913-
static inline bool classof(const Instruction *I) {
914-
return I->getOpcode() == Instruction::VICmp;
915-
}
916-
static inline bool classof(const Value *V) {
917-
return isa<Instruction>(V) && classof(cast<Instruction>(V));
918-
}
919-
};
920-
921-
//===----------------------------------------------------------------------===//
922-
// VFCmpInst Class
923-
//===----------------------------------------------------------------------===//
924-
925-
/// This instruction compares its operands according to the predicate given
926-
/// to the constructor. It only operates on vectors of floating point values.
927-
/// The operands must be identical types.
928-
/// @brief Represents a vector floating point comparison operator.
929-
class VFCmpInst: public CmpInst {
930-
public:
931-
/// @brief Constructor with insert-before-instruction semantics.
932-
VFCmpInst(
933-
Predicate pred, ///< The predicate to use for the comparison
934-
Value *LHS, ///< The left-hand-side of the expression
935-
Value *RHS, ///< The right-hand-side of the expression
936-
const std::string &NameStr = "", ///< Name of the instruction
937-
Instruction *InsertBefore = 0 ///< Where to insert
938-
) : CmpInst(VectorType::getInteger(cast<VectorType>(LHS->getType())),
939-
Instruction::VFCmp, pred, LHS, RHS, NameStr, InsertBefore) {
940-
assert(pred <= CmpInst::LAST_FCMP_PREDICATE &&
941-
"Invalid VFCmp predicate value");
942-
assert(getOperand(0)->getType() == getOperand(1)->getType() &&
943-
"Both operands to VFCmp instruction are not of the same type!");
944-
}
945-
946-
/// @brief Constructor with insert-at-block-end semantics.
947-
VFCmpInst(
948-
Predicate pred, ///< The predicate to use for the comparison
949-
Value *LHS, ///< The left-hand-side of the expression
950-
Value *RHS, ///< The right-hand-side of the expression
951-
const std::string &NameStr, ///< Name of the instruction
952-
BasicBlock *InsertAtEnd ///< Block to insert into.
953-
) : CmpInst(VectorType::getInteger(cast<VectorType>(LHS->getType())),
954-
Instruction::VFCmp, pred, LHS, RHS, NameStr, InsertAtEnd) {
955-
assert(pred <= CmpInst::LAST_FCMP_PREDICATE &&
956-
"Invalid VFCmp predicate value");
957-
assert(getOperand(0)->getType() == getOperand(1)->getType() &&
958-
"Both operands to VFCmp instruction are not of the same type!");
959-
}
960-
961-
/// @brief Return the predicate for this instruction.
962-
Predicate getPredicate() const { return Predicate(SubclassData); }
963-
964-
virtual VFCmpInst *clone() const;
965-
966-
/// @brief Methods for support type inquiry through isa, cast, and dyn_cast:
967-
static inline bool classof(const VFCmpInst *) { return true; }
968-
static inline bool classof(const Instruction *I) {
969-
return I->getOpcode() == Instruction::VFCmp;
970-
}
971-
static inline bool classof(const Value *V) {
972-
return isa<Instruction>(V) && classof(cast<Instruction>(V));
973-
}
974-
};
975-
976864
//===----------------------------------------------------------------------===//
977865
// CallInst Class
978866
//===----------------------------------------------------------------------===//

‎llvm/include/llvm/LLVMContext.h

Lines changed: 0 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -145,10 +145,6 @@ class LLVMContext {
145145
Constant* RHS);
146146
Constant* getConstantExprFCmp(unsigned short pred, Constant* LHS,
147147
Constant* RHS);
148-
Constant* getConstantExprVICmp(unsigned short pred, Constant* LHS,
149-
Constant* RHS);
150-
Constant* getConstantExprVFCmp(unsigned short pred, Constant* LHS,
151-
Constant* RHS);
152148
Constant* getConstantExprShl(Constant* C1, Constant* C2);
153149
Constant* getConstantExprLShr(Constant* C1, Constant* C2);
154150
Constant* getConstantExprAShr(Constant* C1, Constant* C2);

‎llvm/include/llvm/Support/ConstantFolder.h

Lines changed: 0 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -154,14 +154,6 @@ class ConstantFolder {
154154
Constant *RHS) const {
155155
return ConstantExpr::getCompare(P, LHS, RHS);
156156
}
157-
Constant *CreateVICmp(CmpInst::Predicate P, Constant *LHS,
158-
Constant *RHS) const {
159-
return ConstantExpr::getCompare(P, LHS, RHS);
160-
}
161-
Constant *CreateVFCmp(CmpInst::Predicate P, Constant *LHS,
162-
Constant *RHS) const {
163-
return ConstantExpr::getCompare(P, LHS, RHS);
164-
}
165157

166158
//===--------------------------------------------------------------------===//
167159
// Other Instructions

‎llvm/include/llvm/Support/IRBuilder.h

Lines changed: 0 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -570,21 +570,6 @@ template <bool preserveNames=true, typename T = ConstantFolder> class IRBuilder{
570570
return Insert(new FCmpInst(P, LHS, RHS), Name);
571571
}
572572

573-
Value *CreateVICmp(CmpInst::Predicate P, Value *LHS, Value *RHS,
574-
const char *Name = "") {
575-
if (Constant *LC = dyn_cast<Constant>(LHS))
576-
if (Constant *RC = dyn_cast<Constant>(RHS))
577-
return Folder.CreateVICmp(P, LC, RC);
578-
return Insert(new VICmpInst(P, LHS, RHS), Name);
579-
}
580-
Value *CreateVFCmp(CmpInst::Predicate P, Value *LHS, Value *RHS,
581-
const char *Name = "") {
582-
if (Constant *LC = dyn_cast<Constant>(LHS))
583-
if (Constant *RC = dyn_cast<Constant>(RHS))
584-
return Folder.CreateVFCmp(P, LC, RC);
585-
return Insert(new VFCmpInst(P, LHS, RHS), Name);
586-
}
587-
588573
//===--------------------------------------------------------------------===//
589574
// Instruction creation methods: Other Instructions
590575
//===--------------------------------------------------------------------===//

‎llvm/include/llvm/Support/InstVisitor.h

Lines changed: 0 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -165,8 +165,6 @@ class InstVisitor {
165165
RetTy visitUnreachableInst(UnreachableInst &I) { DELEGATE(TerminatorInst);}
166166
RetTy visitICmpInst(ICmpInst &I) { DELEGATE(CmpInst);}
167167
RetTy visitFCmpInst(FCmpInst &I) { DELEGATE(CmpInst);}
168-
RetTy visitVICmpInst(VICmpInst &I) { DELEGATE(CmpInst);}
169-
RetTy visitVFCmpInst(VFCmpInst &I) { DELEGATE(CmpInst);}
170168
RetTy visitMallocInst(MallocInst &I) { DELEGATE(AllocationInst);}
171169
RetTy visitAllocaInst(AllocaInst &I) { DELEGATE(AllocationInst);}
172170
RetTy visitFreeInst(FreeInst &I) { DELEGATE(Instruction); }

‎llvm/include/llvm/Support/NoFolder.h

Lines changed: 0 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -143,12 +143,6 @@ class NoFolder {
143143
Value *CreateFCmp(CmpInst::Predicate P, Constant *LHS, Constant *RHS) const {
144144
return new FCmpInst(P, LHS, RHS);
145145
}
146-
Value *CreateVICmp(CmpInst::Predicate P, Constant *LHS, Constant *RHS) const {
147-
return new VICmpInst(P, LHS, RHS);
148-
}
149-
Value *CreateVFCmp(CmpInst::Predicate P, Constant *LHS, Constant *RHS) const {
150-
return new VFCmpInst(P, LHS, RHS);
151-
}
152146

153147
//===--------------------------------------------------------------------===//
154148
// Other Instructions

0 commit comments

Comments
 (0)