1 //===-- llvm/InstrTypes.h - Important Instruction subclasses ----*- C++ -*-===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 // 10 // This file defines various meta classes of instructions that exist in the VM 11 // representation. Specific concrete subclasses of these may be found in the 12 // i*.h files... 13 // 14 //===----------------------------------------------------------------------===// 15 16 #ifndef LLVM_IR_INSTRTYPES_H 17 #define LLVM_IR_INSTRTYPES_H 18 19 #include "llvm/ADT/Twine.h" 20 #include "llvm/IR/DerivedTypes.h" 21 #include "llvm/IR/Instruction.h" 22 #include "llvm/IR/OperandTraits.h" 23 24 namespace llvm { 25 26 class LLVMContext; 27 28 //===----------------------------------------------------------------------===// 29 // TerminatorInst Class 30 //===----------------------------------------------------------------------===// 31 32 /// TerminatorInst - Subclasses of this class are all able to terminate a basic 33 /// block. Thus, these are all the flow control type of operations. 34 /// 35 class TerminatorInst : public Instruction { 36 protected: 37 TerminatorInst(Type *Ty, Instruction::TermOps iType, 38 Use *Ops, unsigned NumOps, 39 Instruction *InsertBefore = 0) 40 : Instruction(Ty, iType, Ops, NumOps, InsertBefore) {} 41 42 TerminatorInst(Type *Ty, Instruction::TermOps iType, 43 Use *Ops, unsigned NumOps, BasicBlock *InsertAtEnd) 44 : Instruction(Ty, iType, Ops, NumOps, InsertAtEnd) {} 45 46 // Out of line virtual method, so the vtable, etc has a home. 47 ~TerminatorInst(); 48 49 /// Virtual methods - Terminators should overload these and provide inline 50 /// overrides of non-V methods. 51 virtual BasicBlock *getSuccessorV(unsigned idx) const = 0; 52 virtual unsigned getNumSuccessorsV() const = 0; 53 virtual void setSuccessorV(unsigned idx, BasicBlock *B) = 0; 54 virtual TerminatorInst *clone_impl() const = 0; 55 public: 56 57 /// getNumSuccessors - Return the number of successors that this terminator 58 /// has. 59 unsigned getNumSuccessors() const { 60 return getNumSuccessorsV(); 61 } 62 63 /// getSuccessor - Return the specified successor. 64 /// 65 BasicBlock *getSuccessor(unsigned idx) const { 66 return getSuccessorV(idx); 67 } 68 69 /// setSuccessor - Update the specified successor to point at the provided 70 /// block. 71 void setSuccessor(unsigned idx, BasicBlock *B) { 72 setSuccessorV(idx, B); 73 } 74 75 // Methods for support type inquiry through isa, cast, and dyn_cast: 76 static inline bool classof(const Instruction *I) { 77 return I->isTerminator(); 78 } 79 static inline bool classof(const Value *V) { 80 return isa<Instruction>(V) && classof(cast<Instruction>(V)); 81 } 82 }; 83 84 85 //===----------------------------------------------------------------------===// 86 // UnaryInstruction Class 87 //===----------------------------------------------------------------------===// 88 89 class UnaryInstruction : public Instruction { 90 void *operator new(size_t, unsigned) LLVM_DELETED_FUNCTION; 91 92 protected: 93 UnaryInstruction(Type *Ty, unsigned iType, Value *V, 94 Instruction *IB = 0) 95 : Instruction(Ty, iType, &Op<0>(), 1, IB) { 96 Op<0>() = V; 97 } 98 UnaryInstruction(Type *Ty, unsigned iType, Value *V, BasicBlock *IAE) 99 : Instruction(Ty, iType, &Op<0>(), 1, IAE) { 100 Op<0>() = V; 101 } 102 public: 103 // allocate space for exactly one operand 104 void *operator new(size_t s) { 105 return User::operator new(s, 1); 106 } 107 108 // Out of line virtual method, so the vtable, etc has a home. 109 ~UnaryInstruction(); 110 111 /// Transparently provide more efficient getOperand methods. 112 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value); 113 114 // Methods for support type inquiry through isa, cast, and dyn_cast: 115 static inline bool classof(const Instruction *I) { 116 return I->getOpcode() == Instruction::Alloca || 117 I->getOpcode() == Instruction::Load || 118 I->getOpcode() == Instruction::VAArg || 119 I->getOpcode() == Instruction::ExtractValue || 120 (I->getOpcode() >= CastOpsBegin && I->getOpcode() < CastOpsEnd); 121 } 122 static inline bool classof(const Value *V) { 123 return isa<Instruction>(V) && classof(cast<Instruction>(V)); 124 } 125 }; 126 127 template <> 128 struct OperandTraits<UnaryInstruction> : 129 public FixedNumOperandTraits<UnaryInstruction, 1> { 130 }; 131 132 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(UnaryInstruction, Value) 133 134 //===----------------------------------------------------------------------===// 135 // BinaryOperator Class 136 //===----------------------------------------------------------------------===// 137 138 class BinaryOperator : public Instruction { 139 void *operator new(size_t, unsigned) LLVM_DELETED_FUNCTION; 140 protected: 141 void init(BinaryOps iType); 142 BinaryOperator(BinaryOps iType, Value *S1, Value *S2, Type *Ty, 143 const Twine &Name, Instruction *InsertBefore); 144 BinaryOperator(BinaryOps iType, Value *S1, Value *S2, Type *Ty, 145 const Twine &Name, BasicBlock *InsertAtEnd); 146 virtual BinaryOperator *clone_impl() const LLVM_OVERRIDE; 147 public: 148 // allocate space for exactly two operands 149 void *operator new(size_t s) { 150 return User::operator new(s, 2); 151 } 152 153 /// Transparently provide more efficient getOperand methods. 154 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value); 155 156 /// Create() - Construct a binary instruction, given the opcode and the two 157 /// operands. Optionally (if InstBefore is specified) insert the instruction 158 /// into a BasicBlock right before the specified instruction. The specified 159 /// Instruction is allowed to be a dereferenced end iterator. 160 /// 161 static BinaryOperator *Create(BinaryOps Op, Value *S1, Value *S2, 162 const Twine &Name = Twine(), 163 Instruction *InsertBefore = 0); 164 165 /// Create() - Construct a binary instruction, given the opcode and the two 166 /// operands. Also automatically insert this instruction to the end of the 167 /// BasicBlock specified. 168 /// 169 static BinaryOperator *Create(BinaryOps Op, Value *S1, Value *S2, 170 const Twine &Name, BasicBlock *InsertAtEnd); 171 172 /// Create* - These methods just forward to Create, and are useful when you 173 /// statically know what type of instruction you're going to create. These 174 /// helpers just save some typing. 175 #define HANDLE_BINARY_INST(N, OPC, CLASS) \ 176 static BinaryOperator *Create##OPC(Value *V1, Value *V2, \ 177 const Twine &Name = "") {\ 178 return Create(Instruction::OPC, V1, V2, Name);\ 179 } 180 #include "llvm/IR/Instruction.def" 181 #define HANDLE_BINARY_INST(N, OPC, CLASS) \ 182 static BinaryOperator *Create##OPC(Value *V1, Value *V2, \ 183 const Twine &Name, BasicBlock *BB) {\ 184 return Create(Instruction::OPC, V1, V2, Name, BB);\ 185 } 186 #include "llvm/IR/Instruction.def" 187 #define HANDLE_BINARY_INST(N, OPC, CLASS) \ 188 static BinaryOperator *Create##OPC(Value *V1, Value *V2, \ 189 const Twine &Name, Instruction *I) {\ 190 return Create(Instruction::OPC, V1, V2, Name, I);\ 191 } 192 #include "llvm/IR/Instruction.def" 193 194 static BinaryOperator *CreateNSW(BinaryOps Opc, Value *V1, Value *V2, 195 const Twine &Name = "") { 196 BinaryOperator *BO = Create(Opc, V1, V2, Name); 197 BO->setHasNoSignedWrap(true); 198 return BO; 199 } 200 static BinaryOperator *CreateNSW(BinaryOps Opc, Value *V1, Value *V2, 201 const Twine &Name, BasicBlock *BB) { 202 BinaryOperator *BO = Create(Opc, V1, V2, Name, BB); 203 BO->setHasNoSignedWrap(true); 204 return BO; 205 } 206 static BinaryOperator *CreateNSW(BinaryOps Opc, Value *V1, Value *V2, 207 const Twine &Name, Instruction *I) { 208 BinaryOperator *BO = Create(Opc, V1, V2, Name, I); 209 BO->setHasNoSignedWrap(true); 210 return BO; 211 } 212 213 static BinaryOperator *CreateNUW(BinaryOps Opc, Value *V1, Value *V2, 214 const Twine &Name = "") { 215 BinaryOperator *BO = Create(Opc, V1, V2, Name); 216 BO->setHasNoUnsignedWrap(true); 217 return BO; 218 } 219 static BinaryOperator *CreateNUW(BinaryOps Opc, Value *V1, Value *V2, 220 const Twine &Name, BasicBlock *BB) { 221 BinaryOperator *BO = Create(Opc, V1, V2, Name, BB); 222 BO->setHasNoUnsignedWrap(true); 223 return BO; 224 } 225 static BinaryOperator *CreateNUW(BinaryOps Opc, Value *V1, Value *V2, 226 const Twine &Name, Instruction *I) { 227 BinaryOperator *BO = Create(Opc, V1, V2, Name, I); 228 BO->setHasNoUnsignedWrap(true); 229 return BO; 230 } 231 232 static BinaryOperator *CreateExact(BinaryOps Opc, Value *V1, Value *V2, 233 const Twine &Name = "") { 234 BinaryOperator *BO = Create(Opc, V1, V2, Name); 235 BO->setIsExact(true); 236 return BO; 237 } 238 static BinaryOperator *CreateExact(BinaryOps Opc, Value *V1, Value *V2, 239 const Twine &Name, BasicBlock *BB) { 240 BinaryOperator *BO = Create(Opc, V1, V2, Name, BB); 241 BO->setIsExact(true); 242 return BO; 243 } 244 static BinaryOperator *CreateExact(BinaryOps Opc, Value *V1, Value *V2, 245 const Twine &Name, Instruction *I) { 246 BinaryOperator *BO = Create(Opc, V1, V2, Name, I); 247 BO->setIsExact(true); 248 return BO; 249 } 250 251 #define DEFINE_HELPERS(OPC, NUWNSWEXACT) \ 252 static BinaryOperator *Create ## NUWNSWEXACT ## OPC \ 253 (Value *V1, Value *V2, const Twine &Name = "") { \ 254 return Create ## NUWNSWEXACT(Instruction::OPC, V1, V2, Name); \ 255 } \ 256 static BinaryOperator *Create ## NUWNSWEXACT ## OPC \ 257 (Value *V1, Value *V2, const Twine &Name, BasicBlock *BB) { \ 258 return Create ## NUWNSWEXACT(Instruction::OPC, V1, V2, Name, BB); \ 259 } \ 260 static BinaryOperator *Create ## NUWNSWEXACT ## OPC \ 261 (Value *V1, Value *V2, const Twine &Name, Instruction *I) { \ 262 return Create ## NUWNSWEXACT(Instruction::OPC, V1, V2, Name, I); \ 263 } 264 265 DEFINE_HELPERS(Add, NSW) // CreateNSWAdd 266 DEFINE_HELPERS(Add, NUW) // CreateNUWAdd 267 DEFINE_HELPERS(Sub, NSW) // CreateNSWSub 268 DEFINE_HELPERS(Sub, NUW) // CreateNUWSub 269 DEFINE_HELPERS(Mul, NSW) // CreateNSWMul 270 DEFINE_HELPERS(Mul, NUW) // CreateNUWMul 271 DEFINE_HELPERS(Shl, NSW) // CreateNSWShl 272 DEFINE_HELPERS(Shl, NUW) // CreateNUWShl 273 274 DEFINE_HELPERS(SDiv, Exact) // CreateExactSDiv 275 DEFINE_HELPERS(UDiv, Exact) // CreateExactUDiv 276 DEFINE_HELPERS(AShr, Exact) // CreateExactAShr 277 DEFINE_HELPERS(LShr, Exact) // CreateExactLShr 278 279 #undef DEFINE_HELPERS 280 281 /// Helper functions to construct and inspect unary operations (NEG and NOT) 282 /// via binary operators SUB and XOR: 283 /// 284 /// CreateNeg, CreateNot - Create the NEG and NOT 285 /// instructions out of SUB and XOR instructions. 286 /// 287 static BinaryOperator *CreateNeg(Value *Op, const Twine &Name = "", 288 Instruction *InsertBefore = 0); 289 static BinaryOperator *CreateNeg(Value *Op, const Twine &Name, 290 BasicBlock *InsertAtEnd); 291 static BinaryOperator *CreateNSWNeg(Value *Op, const Twine &Name = "", 292 Instruction *InsertBefore = 0); 293 static BinaryOperator *CreateNSWNeg(Value *Op, const Twine &Name, 294 BasicBlock *InsertAtEnd); 295 static BinaryOperator *CreateNUWNeg(Value *Op, const Twine &Name = "", 296 Instruction *InsertBefore = 0); 297 static BinaryOperator *CreateNUWNeg(Value *Op, const Twine &Name, 298 BasicBlock *InsertAtEnd); 299 static BinaryOperator *CreateFNeg(Value *Op, const Twine &Name = "", 300 Instruction *InsertBefore = 0); 301 static BinaryOperator *CreateFNeg(Value *Op, const Twine &Name, 302 BasicBlock *InsertAtEnd); 303 static BinaryOperator *CreateNot(Value *Op, const Twine &Name = "", 304 Instruction *InsertBefore = 0); 305 static BinaryOperator *CreateNot(Value *Op, const Twine &Name, 306 BasicBlock *InsertAtEnd); 307 308 /// isNeg, isFNeg, isNot - Check if the given Value is a 309 /// NEG, FNeg, or NOT instruction. 310 /// 311 static bool isNeg(const Value *V); 312 static bool isFNeg(const Value *V, bool IgnoreZeroSign=false); 313 static bool isNot(const Value *V); 314 315 /// getNegArgument, getNotArgument - Helper functions to extract the 316 /// unary argument of a NEG, FNEG or NOT operation implemented via 317 /// Sub, FSub, or Xor. 318 /// 319 static const Value *getNegArgument(const Value *BinOp); 320 static Value *getNegArgument( Value *BinOp); 321 static const Value *getFNegArgument(const Value *BinOp); 322 static Value *getFNegArgument( Value *BinOp); 323 static const Value *getNotArgument(const Value *BinOp); 324 static Value *getNotArgument( Value *BinOp); 325 326 BinaryOps getOpcode() const { 327 return static_cast<BinaryOps>(Instruction::getOpcode()); 328 } 329 330 /// swapOperands - Exchange the two operands to this instruction. 331 /// This instruction is safe to use on any binary instruction and 332 /// does not modify the semantics of the instruction. If the instruction 333 /// cannot be reversed (ie, it's a Div), then return true. 334 /// 335 bool swapOperands(); 336 337 /// setHasNoUnsignedWrap - Set or clear the nsw flag on this instruction, 338 /// which must be an operator which supports this flag. See LangRef.html 339 /// for the meaning of this flag. 340 void setHasNoUnsignedWrap(bool b = true); 341 342 /// setHasNoSignedWrap - Set or clear the nsw flag on this instruction, 343 /// which must be an operator which supports this flag. See LangRef.html 344 /// for the meaning of this flag. 345 void setHasNoSignedWrap(bool b = true); 346 347 /// setIsExact - Set or clear the exact flag on this instruction, 348 /// which must be an operator which supports this flag. See LangRef.html 349 /// for the meaning of this flag. 350 void setIsExact(bool b = true); 351 352 /// hasNoUnsignedWrap - Determine whether the no unsigned wrap flag is set. 353 bool hasNoUnsignedWrap() const; 354 355 /// hasNoSignedWrap - Determine whether the no signed wrap flag is set. 356 bool hasNoSignedWrap() const; 357 358 /// isExact - Determine whether the exact flag is set. 359 bool isExact() const; 360 361 // Methods for support type inquiry through isa, cast, and dyn_cast: 362 static inline bool classof(const Instruction *I) { 363 return I->isBinaryOp(); 364 } 365 static inline bool classof(const Value *V) { 366 return isa<Instruction>(V) && classof(cast<Instruction>(V)); 367 } 368 }; 369 370 template <> 371 struct OperandTraits<BinaryOperator> : 372 public FixedNumOperandTraits<BinaryOperator, 2> { 373 }; 374 375 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(BinaryOperator, Value) 376 377 //===----------------------------------------------------------------------===// 378 // CastInst Class 379 //===----------------------------------------------------------------------===// 380 381 /// CastInst - This is the base class for all instructions that perform data 382 /// casts. It is simply provided so that instruction category testing 383 /// can be performed with code like: 384 /// 385 /// if (isa<CastInst>(Instr)) { ... } 386 /// @brief Base class of casting instructions. 387 class CastInst : public UnaryInstruction { 388 virtual void anchor() LLVM_OVERRIDE; 389 protected: 390 /// @brief Constructor with insert-before-instruction semantics for subclasses 391 CastInst(Type *Ty, unsigned iType, Value *S, 392 const Twine &NameStr = "", Instruction *InsertBefore = 0) 393 : UnaryInstruction(Ty, iType, S, InsertBefore) { 394 setName(NameStr); 395 } 396 /// @brief Constructor with insert-at-end-of-block semantics for subclasses 397 CastInst(Type *Ty, unsigned iType, Value *S, 398 const Twine &NameStr, BasicBlock *InsertAtEnd) 399 : UnaryInstruction(Ty, iType, S, InsertAtEnd) { 400 setName(NameStr); 401 } 402 public: 403 /// Provides a way to construct any of the CastInst subclasses using an 404 /// opcode instead of the subclass's constructor. The opcode must be in the 405 /// CastOps category (Instruction::isCast(opcode) returns true). This 406 /// constructor has insert-before-instruction semantics to automatically 407 /// insert the new CastInst before InsertBefore (if it is non-null). 408 /// @brief Construct any of the CastInst subclasses 409 static CastInst *Create( 410 Instruction::CastOps, ///< The opcode of the cast instruction 411 Value *S, ///< The value to be casted (operand 0) 412 Type *Ty, ///< The type to which cast should be made 413 const Twine &Name = "", ///< Name for the instruction 414 Instruction *InsertBefore = 0 ///< Place to insert the instruction 415 ); 416 /// Provides a way to construct any of the CastInst subclasses using an 417 /// opcode instead of the subclass's constructor. The opcode must be in the 418 /// CastOps category. This constructor has insert-at-end-of-block semantics 419 /// to automatically insert the new CastInst at the end of InsertAtEnd (if 420 /// its non-null). 421 /// @brief Construct any of the CastInst subclasses 422 static CastInst *Create( 423 Instruction::CastOps, ///< The opcode for the cast instruction 424 Value *S, ///< The value to be casted (operand 0) 425 Type *Ty, ///< The type to which operand is casted 426 const Twine &Name, ///< The name for the instruction 427 BasicBlock *InsertAtEnd ///< The block to insert the instruction into 428 ); 429 430 /// @brief Create a ZExt or BitCast cast instruction 431 static CastInst *CreateZExtOrBitCast( 432 Value *S, ///< The value to be casted (operand 0) 433 Type *Ty, ///< The type to which cast should be made 434 const Twine &Name = "", ///< Name for the instruction 435 Instruction *InsertBefore = 0 ///< Place to insert the instruction 436 ); 437 438 /// @brief Create a ZExt or BitCast cast instruction 439 static CastInst *CreateZExtOrBitCast( 440 Value *S, ///< The value to be casted (operand 0) 441 Type *Ty, ///< The type to which operand is casted 442 const Twine &Name, ///< The name for the instruction 443 BasicBlock *InsertAtEnd ///< The block to insert the instruction into 444 ); 445 446 /// @brief Create a SExt or BitCast cast instruction 447 static CastInst *CreateSExtOrBitCast( 448 Value *S, ///< The value to be casted (operand 0) 449 Type *Ty, ///< The type to which cast should be made 450 const Twine &Name = "", ///< Name for the instruction 451 Instruction *InsertBefore = 0 ///< Place to insert the instruction 452 ); 453 454 /// @brief Create a SExt or BitCast cast instruction 455 static CastInst *CreateSExtOrBitCast( 456 Value *S, ///< The value to be casted (operand 0) 457 Type *Ty, ///< The type to which operand is casted 458 const Twine &Name, ///< The name for the instruction 459 BasicBlock *InsertAtEnd ///< The block to insert the instruction into 460 ); 461 462 /// @brief Create a BitCast or a PtrToInt cast instruction 463 static CastInst *CreatePointerCast( 464 Value *S, ///< The pointer value to be casted (operand 0) 465 Type *Ty, ///< The type to which operand is casted 466 const Twine &Name, ///< The name for the instruction 467 BasicBlock *InsertAtEnd ///< The block to insert the instruction into 468 ); 469 470 /// @brief Create a BitCast or a PtrToInt cast instruction 471 static CastInst *CreatePointerCast( 472 Value *S, ///< The pointer value to be casted (operand 0) 473 Type *Ty, ///< The type to which cast should be made 474 const Twine &Name = "", ///< Name for the instruction 475 Instruction *InsertBefore = 0 ///< Place to insert the instruction 476 ); 477 478 /// @brief Create a ZExt, BitCast, or Trunc for int -> int casts. 479 static CastInst *CreateIntegerCast( 480 Value *S, ///< The pointer value to be casted (operand 0) 481 Type *Ty, ///< The type to which cast should be made 482 bool isSigned, ///< Whether to regard S as signed or not 483 const Twine &Name = "", ///< Name for the instruction 484 Instruction *InsertBefore = 0 ///< Place to insert the instruction 485 ); 486 487 /// @brief Create a ZExt, BitCast, or Trunc for int -> int casts. 488 static CastInst *CreateIntegerCast( 489 Value *S, ///< The integer value to be casted (operand 0) 490 Type *Ty, ///< The integer type to which operand is casted 491 bool isSigned, ///< Whether to regard S as signed or not 492 const Twine &Name, ///< The name for the instruction 493 BasicBlock *InsertAtEnd ///< The block to insert the instruction into 494 ); 495 496 /// @brief Create an FPExt, BitCast, or FPTrunc for fp -> fp casts 497 static CastInst *CreateFPCast( 498 Value *S, ///< The floating point value to be casted 499 Type *Ty, ///< The floating point type to cast to 500 const Twine &Name = "", ///< Name for the instruction 501 Instruction *InsertBefore = 0 ///< Place to insert the instruction 502 ); 503 504 /// @brief Create an FPExt, BitCast, or FPTrunc for fp -> fp casts 505 static CastInst *CreateFPCast( 506 Value *S, ///< The floating point value to be casted 507 Type *Ty, ///< The floating point type to cast to 508 const Twine &Name, ///< The name for the instruction 509 BasicBlock *InsertAtEnd ///< The block to insert the instruction into 510 ); 511 512 /// @brief Create a Trunc or BitCast cast instruction 513 static CastInst *CreateTruncOrBitCast( 514 Value *S, ///< The value to be casted (operand 0) 515 Type *Ty, ///< The type to which cast should be made 516 const Twine &Name = "", ///< Name for the instruction 517 Instruction *InsertBefore = 0 ///< Place to insert the instruction 518 ); 519 520 /// @brief Create a Trunc or BitCast cast instruction 521 static CastInst *CreateTruncOrBitCast( 522 Value *S, ///< The value to be casted (operand 0) 523 Type *Ty, ///< The type to which operand is casted 524 const Twine &Name, ///< The name for the instruction 525 BasicBlock *InsertAtEnd ///< The block to insert the instruction into 526 ); 527 528 /// @brief Check whether it is valid to call getCastOpcode for these types. 529 static bool isCastable( 530 Type *SrcTy, ///< The Type from which the value should be cast. 531 Type *DestTy ///< The Type to which the value should be cast. 532 ); 533 534 /// Returns the opcode necessary to cast Val into Ty using usual casting 535 /// rules. 536 /// @brief Infer the opcode for cast operand and type 537 static Instruction::CastOps getCastOpcode( 538 const Value *Val, ///< The value to cast 539 bool SrcIsSigned, ///< Whether to treat the source as signed 540 Type *Ty, ///< The Type to which the value should be casted 541 bool DstIsSigned ///< Whether to treate the dest. as signed 542 ); 543 544 /// There are several places where we need to know if a cast instruction 545 /// only deals with integer source and destination types. To simplify that 546 /// logic, this method is provided. 547 /// @returns true iff the cast has only integral typed operand and dest type. 548 /// @brief Determine if this is an integer-only cast. 549 bool isIntegerCast() const; 550 551 /// A lossless cast is one that does not alter the basic value. It implies 552 /// a no-op cast but is more stringent, preventing things like int->float, 553 /// long->double, or int->ptr. 554 /// @returns true iff the cast is lossless. 555 /// @brief Determine if this is a lossless cast. 556 bool isLosslessCast() const; 557 558 /// A no-op cast is one that can be effected without changing any bits. 559 /// It implies that the source and destination types are the same size. The 560 /// IntPtrTy argument is used to make accurate determinations for casts 561 /// involving Integer and Pointer types. They are no-op casts if the integer 562 /// is the same size as the pointer. However, pointer size varies with 563 /// platform. Generally, the result of DataLayout::getIntPtrType() should be 564 /// passed in. If that's not available, use Type::Int64Ty, which will make 565 /// the isNoopCast call conservative. 566 /// @brief Determine if the described cast is a no-op cast. 567 static bool isNoopCast( 568 Instruction::CastOps Opcode, ///< Opcode of cast 569 Type *SrcTy, ///< SrcTy of cast 570 Type *DstTy, ///< DstTy of cast 571 Type *IntPtrTy ///< Integer type corresponding to Ptr types, or null 572 ); 573 574 /// @brief Determine if this cast is a no-op cast. 575 bool isNoopCast( 576 Type *IntPtrTy ///< Integer type corresponding to pointer 577 ) const; 578 579 /// Determine how a pair of casts can be eliminated, if they can be at all. 580 /// This is a helper function for both CastInst and ConstantExpr. 581 /// @returns 0 if the CastInst pair can't be eliminated, otherwise 582 /// returns Instruction::CastOps value for a cast that can replace 583 /// the pair, casting SrcTy to DstTy. 584 /// @brief Determine if a cast pair is eliminable 585 static unsigned isEliminableCastPair( 586 Instruction::CastOps firstOpcode, ///< Opcode of first cast 587 Instruction::CastOps secondOpcode, ///< Opcode of second cast 588 Type *SrcTy, ///< SrcTy of 1st cast 589 Type *MidTy, ///< DstTy of 1st cast & SrcTy of 2nd cast 590 Type *DstTy, ///< DstTy of 2nd cast 591 Type *SrcIntPtrTy, ///< Integer type corresponding to Ptr SrcTy, or null 592 Type *MidIntPtrTy, ///< Integer type corresponding to Ptr MidTy, or null 593 Type *DstIntPtrTy ///< Integer type corresponding to Ptr DstTy, or null 594 ); 595 596 /// @brief Return the opcode of this CastInst 597 Instruction::CastOps getOpcode() const { 598 return Instruction::CastOps(Instruction::getOpcode()); 599 } 600 601 /// @brief Return the source type, as a convenience 602 Type* getSrcTy() const { return getOperand(0)->getType(); } 603 /// @brief Return the destination type, as a convenience 604 Type* getDestTy() const { return getType(); } 605 606 /// This method can be used to determine if a cast from S to DstTy using 607 /// Opcode op is valid or not. 608 /// @returns true iff the proposed cast is valid. 609 /// @brief Determine if a cast is valid without creating one. 610 static bool castIsValid(Instruction::CastOps op, Value *S, Type *DstTy); 611 612 /// @brief Methods for support type inquiry through isa, cast, and dyn_cast: 613 static inline bool classof(const Instruction *I) { 614 return I->isCast(); 615 } 616 static inline bool classof(const Value *V) { 617 return isa<Instruction>(V) && classof(cast<Instruction>(V)); 618 } 619 }; 620 621 //===----------------------------------------------------------------------===// 622 // CmpInst Class 623 //===----------------------------------------------------------------------===// 624 625 /// This class is the base class for the comparison instructions. 626 /// @brief Abstract base class of comparison instructions. 627 class CmpInst : public Instruction { 628 void *operator new(size_t, unsigned) LLVM_DELETED_FUNCTION; 629 CmpInst() LLVM_DELETED_FUNCTION; 630 protected: 631 CmpInst(Type *ty, Instruction::OtherOps op, unsigned short pred, 632 Value *LHS, Value *RHS, const Twine &Name = "", 633 Instruction *InsertBefore = 0); 634 635 CmpInst(Type *ty, Instruction::OtherOps op, unsigned short pred, 636 Value *LHS, Value *RHS, const Twine &Name, 637 BasicBlock *InsertAtEnd); 638 639 virtual void anchor() LLVM_OVERRIDE; // Out of line virtual method. 640 public: 641 /// This enumeration lists the possible predicates for CmpInst subclasses. 642 /// Values in the range 0-31 are reserved for FCmpInst, while values in the 643 /// range 32-64 are reserved for ICmpInst. This is necessary to ensure the 644 /// predicate values are not overlapping between the classes. 645 enum Predicate { 646 // Opcode U L G E Intuitive operation 647 FCMP_FALSE = 0, ///< 0 0 0 0 Always false (always folded) 648 FCMP_OEQ = 1, ///< 0 0 0 1 True if ordered and equal 649 FCMP_OGT = 2, ///< 0 0 1 0 True if ordered and greater than 650 FCMP_OGE = 3, ///< 0 0 1 1 True if ordered and greater than or equal 651 FCMP_OLT = 4, ///< 0 1 0 0 True if ordered and less than 652 FCMP_OLE = 5, ///< 0 1 0 1 True if ordered and less than or equal 653 FCMP_ONE = 6, ///< 0 1 1 0 True if ordered and operands are unequal 654 FCMP_ORD = 7, ///< 0 1 1 1 True if ordered (no nans) 655 FCMP_UNO = 8, ///< 1 0 0 0 True if unordered: isnan(X) | isnan(Y) 656 FCMP_UEQ = 9, ///< 1 0 0 1 True if unordered or equal 657 FCMP_UGT = 10, ///< 1 0 1 0 True if unordered or greater than 658 FCMP_UGE = 11, ///< 1 0 1 1 True if unordered, greater than, or equal 659 FCMP_ULT = 12, ///< 1 1 0 0 True if unordered or less than 660 FCMP_ULE = 13, ///< 1 1 0 1 True if unordered, less than, or equal 661 FCMP_UNE = 14, ///< 1 1 1 0 True if unordered or not equal 662 FCMP_TRUE = 15, ///< 1 1 1 1 Always true (always folded) 663 FIRST_FCMP_PREDICATE = FCMP_FALSE, 664 LAST_FCMP_PREDICATE = FCMP_TRUE, 665 BAD_FCMP_PREDICATE = FCMP_TRUE + 1, 666 ICMP_EQ = 32, ///< equal 667 ICMP_NE = 33, ///< not equal 668 ICMP_UGT = 34, ///< unsigned greater than 669 ICMP_UGE = 35, ///< unsigned greater or equal 670 ICMP_ULT = 36, ///< unsigned less than 671 ICMP_ULE = 37, ///< unsigned less or equal 672 ICMP_SGT = 38, ///< signed greater than 673 ICMP_SGE = 39, ///< signed greater or equal 674 ICMP_SLT = 40, ///< signed less than 675 ICMP_SLE = 41, ///< signed less or equal 676 FIRST_ICMP_PREDICATE = ICMP_EQ, 677 LAST_ICMP_PREDICATE = ICMP_SLE, 678 BAD_ICMP_PREDICATE = ICMP_SLE + 1 679 }; 680 681 // allocate space for exactly two operands 682 void *operator new(size_t s) { 683 return User::operator new(s, 2); 684 } 685 /// Construct a compare instruction, given the opcode, the predicate and 686 /// the two operands. Optionally (if InstBefore is specified) insert the 687 /// instruction into a BasicBlock right before the specified instruction. 688 /// The specified Instruction is allowed to be a dereferenced end iterator. 689 /// @brief Create a CmpInst 690 static CmpInst *Create(OtherOps Op, 691 unsigned short predicate, Value *S1, 692 Value *S2, const Twine &Name = "", 693 Instruction *InsertBefore = 0); 694 695 /// Construct a compare instruction, given the opcode, the predicate and the 696 /// two operands. Also automatically insert this instruction to the end of 697 /// the BasicBlock specified. 698 /// @brief Create a CmpInst 699 static CmpInst *Create(OtherOps Op, unsigned short predicate, Value *S1, 700 Value *S2, const Twine &Name, BasicBlock *InsertAtEnd); 701 702 /// @brief Get the opcode casted to the right type 703 OtherOps getOpcode() const { 704 return static_cast<OtherOps>(Instruction::getOpcode()); 705 } 706 707 /// @brief Return the predicate for this instruction. 708 Predicate getPredicate() const { 709 return Predicate(getSubclassDataFromInstruction()); 710 } 711 712 /// @brief Set the predicate for this instruction to the specified value. 713 void setPredicate(Predicate P) { setInstructionSubclassData(P); } 714 715 static bool isFPPredicate(Predicate P) { 716 return P >= FIRST_FCMP_PREDICATE && P <= LAST_FCMP_PREDICATE; 717 } 718 719 static bool isIntPredicate(Predicate P) { 720 return P >= FIRST_ICMP_PREDICATE && P <= LAST_ICMP_PREDICATE; 721 } 722 723 bool isFPPredicate() const { return isFPPredicate(getPredicate()); } 724 bool isIntPredicate() const { return isIntPredicate(getPredicate()); } 725 726 727 /// For example, EQ -> NE, UGT -> ULE, SLT -> SGE, 728 /// OEQ -> UNE, UGT -> OLE, OLT -> UGE, etc. 729 /// @returns the inverse predicate for the instruction's current predicate. 730 /// @brief Return the inverse of the instruction's predicate. 731 Predicate getInversePredicate() const { 732 return getInversePredicate(getPredicate()); 733 } 734 735 /// For example, EQ -> NE, UGT -> ULE, SLT -> SGE, 736 /// OEQ -> UNE, UGT -> OLE, OLT -> UGE, etc. 737 /// @returns the inverse predicate for predicate provided in \p pred. 738 /// @brief Return the inverse of a given predicate 739 static Predicate getInversePredicate(Predicate pred); 740 741 /// For example, EQ->EQ, SLE->SGE, ULT->UGT, 742 /// OEQ->OEQ, ULE->UGE, OLT->OGT, etc. 743 /// @returns the predicate that would be the result of exchanging the two 744 /// operands of the CmpInst instruction without changing the result 745 /// produced. 746 /// @brief Return the predicate as if the operands were swapped 747 Predicate getSwappedPredicate() const { 748 return getSwappedPredicate(getPredicate()); 749 } 750 751 /// This is a static version that you can use without an instruction 752 /// available. 753 /// @brief Return the predicate as if the operands were swapped. 754 static Predicate getSwappedPredicate(Predicate pred); 755 756 /// @brief Provide more efficient getOperand methods. 757 DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value); 758 759 /// This is just a convenience that dispatches to the subclasses. 760 /// @brief Swap the operands and adjust predicate accordingly to retain 761 /// the same comparison. 762 void swapOperands(); 763 764 /// This is just a convenience that dispatches to the subclasses. 765 /// @brief Determine if this CmpInst is commutative. 766 bool isCommutative() const; 767 768 /// This is just a convenience that dispatches to the subclasses. 769 /// @brief Determine if this is an equals/not equals predicate. 770 bool isEquality() const; 771 772 /// @returns true if the comparison is signed, false otherwise. 773 /// @brief Determine if this instruction is using a signed comparison. 774 bool isSigned() const { 775 return isSigned(getPredicate()); 776 } 777 778 /// @returns true if the comparison is unsigned, false otherwise. 779 /// @brief Determine if this instruction is using an unsigned comparison. 780 bool isUnsigned() const { 781 return isUnsigned(getPredicate()); 782 } 783 784 /// This is just a convenience. 785 /// @brief Determine if this is true when both operands are the same. 786 bool isTrueWhenEqual() const { 787 return isTrueWhenEqual(getPredicate()); 788 } 789 790 /// This is just a convenience. 791 /// @brief Determine if this is false when both operands are the same. 792 bool isFalseWhenEqual() const { 793 return isFalseWhenEqual(getPredicate()); 794 } 795 796 /// @returns true if the predicate is unsigned, false otherwise. 797 /// @brief Determine if the predicate is an unsigned operation. 798 static bool isUnsigned(unsigned short predicate); 799 800 /// @returns true if the predicate is signed, false otherwise. 801 /// @brief Determine if the predicate is an signed operation. 802 static bool isSigned(unsigned short predicate); 803 804 /// @brief Determine if the predicate is an ordered operation. 805 static bool isOrdered(unsigned short predicate); 806 807 /// @brief Determine if the predicate is an unordered operation. 808 static bool isUnordered(unsigned short predicate); 809 810 /// Determine if the predicate is true when comparing a value with itself. 811 static bool isTrueWhenEqual(unsigned short predicate); 812 813 /// Determine if the predicate is false when comparing a value with itself. 814 static bool isFalseWhenEqual(unsigned short predicate); 815 816 /// @brief Methods for support type inquiry through isa, cast, and dyn_cast: 817 static inline bool classof(const Instruction *I) { 818 return I->getOpcode() == Instruction::ICmp || 819 I->getOpcode() == Instruction::FCmp; 820 } 821 static inline bool classof(const Value *V) { 822 return isa<Instruction>(V) && classof(cast<Instruction>(V)); 823 } 824 825 /// @brief Create a result type for fcmp/icmp 826 static Type* makeCmpResultType(Type* opnd_type) { 827 if (VectorType* vt = dyn_cast<VectorType>(opnd_type)) { 828 return VectorType::get(Type::getInt1Ty(opnd_type->getContext()), 829 vt->getNumElements()); 830 } 831 return Type::getInt1Ty(opnd_type->getContext()); 832 } 833 private: 834 // Shadow Value::setValueSubclassData with a private forwarding method so that 835 // subclasses cannot accidentally use it. 836 void setValueSubclassData(unsigned short D) { 837 Value::setValueSubclassData(D); 838 } 839 }; 840 841 842 // FIXME: these are redundant if CmpInst < BinaryOperator 843 template <> 844 struct OperandTraits<CmpInst> : public FixedNumOperandTraits<CmpInst, 2> { 845 }; 846 847 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(CmpInst, Value) 848 849 } // End llvm namespace 850 851 #endif 852
