1cf3056db0fee1db7921214b1f25cea04e959e105Chris Lattner//===-- Instruction.cpp - Implement the Instruction class -----------------===// 2fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman// 3b576c94c15af9a440f69d9d03c2afead7971118cJohn Criswell// The LLVM Compiler Infrastructure 4b576c94c15af9a440f69d9d03c2afead7971118cJohn Criswell// 54ee451de366474b9c228b4e5fa573795a715216dChris Lattner// This file is distributed under the University of Illinois Open Source 64ee451de366474b9c228b4e5fa573795a715216dChris Lattner// License. See LICENSE.TXT for details. 7fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman// 8b576c94c15af9a440f69d9d03c2afead7971118cJohn Criswell//===----------------------------------------------------------------------===// 9009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner// 10c2c50cdcdc19a1bca993c06d13d8cdca87083ce4Chandler Carruth// This file implements the Instruction class for the IR library. 11009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner// 12009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner//===----------------------------------------------------------------------===// 13009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 140b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/Instruction.h" 1536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines#include "llvm/IR/CallSite.h" 160b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/Constants.h" 170b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/Instructions.h" 1836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines#include "llvm/IR/LeakDetector.h" 190b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/Module.h" 200b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/Operator.h" 210b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/Type.h" 224b74c8333495c609fa81421df32e46db616672e1Chris Lattnerusing namespace llvm; 23d0fde30ce850b78371fd1386338350591f9ff494Brian Gaeke 24db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris LattnerInstruction::Instruction(Type *ty, unsigned it, Use *Ops, unsigned NumOps, 25910c80a07503591052a77cefb26cebea95a8d743Chris Lattner Instruction *InsertBefore) 26dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines : User(ty, Value::InstructionVal + it, Ops, NumOps), Parent(nullptr) { 27d1e693f2a3883dacf213aa2b477540c57b53b714Chris Lattner // Make sure that we get added to a basicblock 28d1e693f2a3883dacf213aa2b477540c57b53b714Chris Lattner LeakDetector::addGarbageObject(this); 292aa831120c97fa4725aea97b0b3e67e8d95b4f38Chris Lattner 302aa831120c97fa4725aea97b0b3e67e8d95b4f38Chris Lattner // If requested, insert this instruction into a basic block... 312aa831120c97fa4725aea97b0b3e67e8d95b4f38Chris Lattner if (InsertBefore) { 322aa831120c97fa4725aea97b0b3e67e8d95b4f38Chris Lattner assert(InsertBefore->getParent() && 332aa831120c97fa4725aea97b0b3e67e8d95b4f38Chris Lattner "Instruction to insert before is not in a basic block!"); 342aa831120c97fa4725aea97b0b3e67e8d95b4f38Chris Lattner InsertBefore->getParent()->getInstList().insert(InsertBefore, this); 352aa831120c97fa4725aea97b0b3e67e8d95b4f38Chris Lattner } 36009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 37009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 3836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hinesconst DataLayout *Instruction::getDataLayout() const { 3936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return getParent()->getDataLayout(); 4036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines} 4136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines 42db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris LattnerInstruction::Instruction(Type *ty, unsigned it, Use *Ops, unsigned NumOps, 43910c80a07503591052a77cefb26cebea95a8d743Chris Lattner BasicBlock *InsertAtEnd) 44dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines : User(ty, Value::InstructionVal + it, Ops, NumOps), Parent(nullptr) { 4596d83f63cdbb33c075901b1b84eb07622d86386fChris Lattner // Make sure that we get added to a basicblock 4696d83f63cdbb33c075901b1b84eb07622d86386fChris Lattner LeakDetector::addGarbageObject(this); 47e5828f1fa7c2691f747f5060ce11b8e55cea03abAlkis Evlogimenos 48e5828f1fa7c2691f747f5060ce11b8e55cea03abAlkis Evlogimenos // append this instruction into the basic block 49e5828f1fa7c2691f747f5060ce11b8e55cea03abAlkis Evlogimenos assert(InsertAtEnd && "Basic block to append to may not be NULL!"); 50e5828f1fa7c2691f747f5060ce11b8e55cea03abAlkis Evlogimenos InsertAtEnd->getInstList().push_back(this); 51f00042a9990d90885a8f236ed0f6bf07902d1374Chris Lattner} 52f00042a9990d90885a8f236ed0f6bf07902d1374Chris Lattner 53f00042a9990d90885a8f236ed0f6bf07902d1374Chris Lattner 5470aa33ee37fede7fb84de02daa38557ffd366458Chris Lattner// Out of line virtual method, so the vtable, etc has a home. 55afba8fe662d65b25b4baf46bb26cc18e1f9cc0a5Gordon HenriksenInstruction::~Instruction() { 56dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines assert(!Parent && "Instruction still linked in the program!"); 574f1be4abba762f8a7b77d7622abaf1ed1a87b48bDan Gohman if (hasMetadataHashEntry()) 584f1be4abba762f8a7b77d7622abaf1ed1a87b48bDan Gohman clearMetadataHashEntries(); 5970aa33ee37fede7fb84de02daa38557ffd366458Chris Lattner} 6070aa33ee37fede7fb84de02daa38557ffd366458Chris Lattner 6170aa33ee37fede7fb84de02daa38557ffd366458Chris Lattner 62bded132d00ed626a6541b67ad101ef0fd47d3491Chris Lattnervoid Instruction::setParent(BasicBlock *P) { 63786993c01ec8bdabe354fb62a083fedc9d7a087eChris Lattner if (getParent()) { 64786993c01ec8bdabe354fb62a083fedc9d7a087eChris Lattner if (!P) LeakDetector::addGarbageObject(this); 65786993c01ec8bdabe354fb62a083fedc9d7a087eChris Lattner } else { 66786993c01ec8bdabe354fb62a083fedc9d7a087eChris Lattner if (P) LeakDetector::removeGarbageObject(this); 67786993c01ec8bdabe354fb62a083fedc9d7a087eChris Lattner } 68d1e693f2a3883dacf213aa2b477540c57b53b714Chris Lattner 69bded132d00ed626a6541b67ad101ef0fd47d3491Chris Lattner Parent = P; 70bded132d00ed626a6541b67ad101ef0fd47d3491Chris Lattner} 71bded132d00ed626a6541b67ad101ef0fd47d3491Chris Lattner 724b83380f330b1c77bb9b4ad8f63bdcf1a596afd6Chris Lattnervoid Instruction::removeFromParent() { 734b83380f330b1c77bb9b4ad8f63bdcf1a596afd6Chris Lattner getParent()->getInstList().remove(this); 744b83380f330b1c77bb9b4ad8f63bdcf1a596afd6Chris Lattner} 754b83380f330b1c77bb9b4ad8f63bdcf1a596afd6Chris Lattner 764b83380f330b1c77bb9b4ad8f63bdcf1a596afd6Chris Lattnervoid Instruction::eraseFromParent() { 774b83380f330b1c77bb9b4ad8f63bdcf1a596afd6Chris Lattner getParent()->getInstList().erase(this); 784b83380f330b1c77bb9b4ad8f63bdcf1a596afd6Chris Lattner} 79c105645c16f77ee20b853baf717073ad393dd4aaVikram S. Adve 8026bb50ab48c561adfd32d129e0eff0cbf0a04625Owen Anderson/// insertBefore - Insert an unlinked instructions into a basic block 8126bb50ab48c561adfd32d129e0eff0cbf0a04625Owen Anderson/// immediately before the specified instruction. 8226bb50ab48c561adfd32d129e0eff0cbf0a04625Owen Andersonvoid Instruction::insertBefore(Instruction *InsertPos) { 8326bb50ab48c561adfd32d129e0eff0cbf0a04625Owen Anderson InsertPos->getParent()->getInstList().insert(InsertPos, this); 8426bb50ab48c561adfd32d129e0eff0cbf0a04625Owen Anderson} 8526bb50ab48c561adfd32d129e0eff0cbf0a04625Owen Anderson 863ff704fa2b67d6c857142218c5aca3058b6239fcChris Lattner/// insertAfter - Insert an unlinked instructions into a basic block 873ff704fa2b67d6c857142218c5aca3058b6239fcChris Lattner/// immediately after the specified instruction. 883ff704fa2b67d6c857142218c5aca3058b6239fcChris Lattnervoid Instruction::insertAfter(Instruction *InsertPos) { 893ff704fa2b67d6c857142218c5aca3058b6239fcChris Lattner InsertPos->getParent()->getInstList().insertAfter(InsertPos, this); 903ff704fa2b67d6c857142218c5aca3058b6239fcChris Lattner} 913ff704fa2b67d6c857142218c5aca3058b6239fcChris Lattner 920fe34d89126c594e0e8378d978a593350189fedfChris Lattner/// moveBefore - Unlink this instruction from its current basic block and 930fe34d89126c594e0e8378d978a593350189fedfChris Lattner/// insert it into the basic block that MovePos lives in, right before 940fe34d89126c594e0e8378d978a593350189fedfChris Lattner/// MovePos. 950fe34d89126c594e0e8378d978a593350189fedfChris Lattnervoid Instruction::moveBefore(Instruction *MovePos) { 960fe34d89126c594e0e8378d978a593350189fedfChris Lattner MovePos->getParent()->getInstList().splice(MovePos,getParent()->getInstList(), 970fe34d89126c594e0e8378d978a593350189fedfChris Lattner this); 980fe34d89126c594e0e8378d978a593350189fedfChris Lattner} 990fe34d89126c594e0e8378d978a593350189fedfChris Lattner 100125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman/// Set or clear the unsafe-algebra flag on this instruction, which must be an 101125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman/// operator which supports this flag. See LangRef.html for the meaning of this 102125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman/// flag. 103125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilsemanvoid Instruction::setHasUnsafeAlgebra(bool B) { 104125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman assert(isa<FPMathOperator>(this) && "setting fast-math flag on invalid op"); 105125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman cast<FPMathOperator>(this)->setHasUnsafeAlgebra(B); 106125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman} 107125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman 108125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman/// Set or clear the NoNaNs flag on this instruction, which must be an operator 109125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman/// which supports this flag. See LangRef.html for the meaning of this flag. 110125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilsemanvoid Instruction::setHasNoNaNs(bool B) { 111125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman assert(isa<FPMathOperator>(this) && "setting fast-math flag on invalid op"); 112125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman cast<FPMathOperator>(this)->setHasNoNaNs(B); 113125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman} 114125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman 115125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman/// Set or clear the no-infs flag on this instruction, which must be an operator 116125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman/// which supports this flag. See LangRef.html for the meaning of this flag. 117125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilsemanvoid Instruction::setHasNoInfs(bool B) { 118125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman assert(isa<FPMathOperator>(this) && "setting fast-math flag on invalid op"); 119125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman cast<FPMathOperator>(this)->setHasNoInfs(B); 120125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman} 121125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman 122125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman/// Set or clear the no-signed-zeros flag on this instruction, which must be an 123125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman/// operator which supports this flag. See LangRef.html for the meaning of this 124125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman/// flag. 125125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilsemanvoid Instruction::setHasNoSignedZeros(bool B) { 126125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman assert(isa<FPMathOperator>(this) && "setting fast-math flag on invalid op"); 127125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman cast<FPMathOperator>(this)->setHasNoSignedZeros(B); 128125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman} 129125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman 130125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman/// Set or clear the allow-reciprocal flag on this instruction, which must be an 131125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman/// operator which supports this flag. See LangRef.html for the meaning of this 132125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman/// flag. 133125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilsemanvoid Instruction::setHasAllowReciprocal(bool B) { 134125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman assert(isa<FPMathOperator>(this) && "setting fast-math flag on invalid op"); 135125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman cast<FPMathOperator>(this)->setHasAllowReciprocal(B); 136125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman} 137125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman 138125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman/// Convenience function for setting all the fast-math flags on this 139125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman/// instruction, which must be an operator which supports these flags. See 140125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman/// LangRef.html for the meaning of these flats. 141125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilsemanvoid Instruction::setFastMathFlags(FastMathFlags FMF) { 142125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman assert(isa<FPMathOperator>(this) && "setting fast-math flag on invalid op"); 143125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman cast<FPMathOperator>(this)->setFastMathFlags(FMF); 144125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman} 145125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman 146125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman/// Determine whether the unsafe-algebra flag is set. 147125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilsemanbool Instruction::hasUnsafeAlgebra() const { 148cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines assert(isa<FPMathOperator>(this) && "getting fast-math flag on invalid op"); 149125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman return cast<FPMathOperator>(this)->hasUnsafeAlgebra(); 150125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman} 151125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman 152125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman/// Determine whether the no-NaNs flag is set. 153125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilsemanbool Instruction::hasNoNaNs() const { 154cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines assert(isa<FPMathOperator>(this) && "getting fast-math flag on invalid op"); 155125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman return cast<FPMathOperator>(this)->hasNoNaNs(); 156125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman} 157125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman 158125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman/// Determine whether the no-infs flag is set. 159125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilsemanbool Instruction::hasNoInfs() const { 160cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines assert(isa<FPMathOperator>(this) && "getting fast-math flag on invalid op"); 161125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman return cast<FPMathOperator>(this)->hasNoInfs(); 162125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman} 163125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman 164125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman/// Determine whether the no-signed-zeros flag is set. 165125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilsemanbool Instruction::hasNoSignedZeros() const { 166cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines assert(isa<FPMathOperator>(this) && "getting fast-math flag on invalid op"); 167125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman return cast<FPMathOperator>(this)->hasNoSignedZeros(); 168125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman} 169125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman 170125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman/// Determine whether the allow-reciprocal flag is set. 171125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilsemanbool Instruction::hasAllowReciprocal() const { 172cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines assert(isa<FPMathOperator>(this) && "getting fast-math flag on invalid op"); 173125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman return cast<FPMathOperator>(this)->hasAllowReciprocal(); 174125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman} 175125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman 176125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman/// Convenience function for getting all the fast-math flags, which must be an 177125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman/// operator which supports these flags. See LangRef.html for the meaning of 178125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman/// these flats. 179125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael IlsemanFastMathFlags Instruction::getFastMathFlags() const { 180cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines assert(isa<FPMathOperator>(this) && "getting fast-math flag on invalid op"); 181125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman return cast<FPMathOperator>(this)->getFastMathFlags(); 182125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman} 1830fe34d89126c594e0e8378d978a593350189fedfChris Lattner 1844b896dd613b1d85ee1b261ee470cb72fab24c282Michael Ilseman/// Copy I's fast-math flags 1854b896dd613b1d85ee1b261ee470cb72fab24c282Michael Ilsemanvoid Instruction::copyFastMathFlags(const Instruction *I) { 1864b896dd613b1d85ee1b261ee470cb72fab24c282Michael Ilseman setFastMathFlags(I->getFastMathFlags()); 1874b896dd613b1d85ee1b261ee470cb72fab24c282Michael Ilseman} 1884b896dd613b1d85ee1b261ee470cb72fab24c282Michael Ilseman 1894b896dd613b1d85ee1b261ee470cb72fab24c282Michael Ilseman 190c105645c16f77ee20b853baf717073ad393dd4aaVikram S. Adveconst char *Instruction::getOpcodeName(unsigned OpCode) { 191c105645c16f77ee20b853baf717073ad393dd4aaVikram S. Adve switch (OpCode) { 192c105645c16f77ee20b853baf717073ad393dd4aaVikram S. Adve // Terminators 1930513e9fe03f6e3c7d0272b8f4f82359e8d1a2e44Chris Lattner case Ret: return "ret"; 1940513e9fe03f6e3c7d0272b8f4f82359e8d1a2e44Chris Lattner case Br: return "br"; 195c105645c16f77ee20b853baf717073ad393dd4aaVikram S. Adve case Switch: return "switch"; 196ab21db79ef1d2530880ad11f21f0b87ffca02dd4Chris Lattner case IndirectBr: return "indirectbr"; 197c105645c16f77ee20b853baf717073ad393dd4aaVikram S. Adve case Invoke: return "invoke"; 198dccc03b2423fe65efb5963ae816b99c24fc53374Bill Wendling case Resume: return "resume"; 199b976e668165e1875a8f1eb7af800e33bb1e4393dChris Lattner case Unreachable: return "unreachable"; 200fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman 201c105645c16f77ee20b853baf717073ad393dd4aaVikram S. Adve // Standard binary operators... 202c105645c16f77ee20b853baf717073ad393dd4aaVikram S. Adve case Add: return "add"; 203ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case FAdd: return "fadd"; 204c105645c16f77ee20b853baf717073ad393dd4aaVikram S. Adve case Sub: return "sub"; 205ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case FSub: return "fsub"; 206c105645c16f77ee20b853baf717073ad393dd4aaVikram S. Adve case Mul: return "mul"; 207ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case FMul: return "fmul"; 2081628cec4d7fce310d9cde0bcc73997e5a71692c4Reid Spencer case UDiv: return "udiv"; 2091628cec4d7fce310d9cde0bcc73997e5a71692c4Reid Spencer case SDiv: return "sdiv"; 2101628cec4d7fce310d9cde0bcc73997e5a71692c4Reid Spencer case FDiv: return "fdiv"; 2110a783f783ca05c961234385f5b269d4cf03dbbdbReid Spencer case URem: return "urem"; 2120a783f783ca05c961234385f5b269d4cf03dbbdbReid Spencer case SRem: return "srem"; 2130a783f783ca05c961234385f5b269d4cf03dbbdbReid Spencer case FRem: return "frem"; 214c105645c16f77ee20b853baf717073ad393dd4aaVikram S. Adve 215c105645c16f77ee20b853baf717073ad393dd4aaVikram S. Adve // Logical operators... 216c105645c16f77ee20b853baf717073ad393dd4aaVikram S. Adve case And: return "and"; 217c105645c16f77ee20b853baf717073ad393dd4aaVikram S. Adve case Or : return "or"; 218c105645c16f77ee20b853baf717073ad393dd4aaVikram S. Adve case Xor: return "xor"; 219c105645c16f77ee20b853baf717073ad393dd4aaVikram S. Adve 220c105645c16f77ee20b853baf717073ad393dd4aaVikram S. Adve // Memory instructions... 221c105645c16f77ee20b853baf717073ad393dd4aaVikram S. Adve case Alloca: return "alloca"; 222c105645c16f77ee20b853baf717073ad393dd4aaVikram S. Adve case Load: return "load"; 223c105645c16f77ee20b853baf717073ad393dd4aaVikram S. Adve case Store: return "store"; 224ff03048c1350fcc4fda1ef6d6c57252f3a950854Eli Friedman case AtomicCmpXchg: return "cmpxchg"; 225ff03048c1350fcc4fda1ef6d6c57252f3a950854Eli Friedman case AtomicRMW: return "atomicrmw"; 22647f3513dd574535aeb40c9eb11134f0899e92269Eli Friedman case Fence: return "fence"; 227c105645c16f77ee20b853baf717073ad393dd4aaVikram S. Adve case GetElementPtr: return "getelementptr"; 228fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman 2293da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer // Convert instructions... 23059d3ae6cdc4316ad338cd848251f33a236ccb36cMatt Arsenault case Trunc: return "trunc"; 23159d3ae6cdc4316ad338cd848251f33a236ccb36cMatt Arsenault case ZExt: return "zext"; 23259d3ae6cdc4316ad338cd848251f33a236ccb36cMatt Arsenault case SExt: return "sext"; 23359d3ae6cdc4316ad338cd848251f33a236ccb36cMatt Arsenault case FPTrunc: return "fptrunc"; 23459d3ae6cdc4316ad338cd848251f33a236ccb36cMatt Arsenault case FPExt: return "fpext"; 23559d3ae6cdc4316ad338cd848251f33a236ccb36cMatt Arsenault case FPToUI: return "fptoui"; 23659d3ae6cdc4316ad338cd848251f33a236ccb36cMatt Arsenault case FPToSI: return "fptosi"; 23759d3ae6cdc4316ad338cd848251f33a236ccb36cMatt Arsenault case UIToFP: return "uitofp"; 23859d3ae6cdc4316ad338cd848251f33a236ccb36cMatt Arsenault case SIToFP: return "sitofp"; 23959d3ae6cdc4316ad338cd848251f33a236ccb36cMatt Arsenault case IntToPtr: return "inttoptr"; 24059d3ae6cdc4316ad338cd848251f33a236ccb36cMatt Arsenault case PtrToInt: return "ptrtoint"; 24159d3ae6cdc4316ad338cd848251f33a236ccb36cMatt Arsenault case BitCast: return "bitcast"; 24259d3ae6cdc4316ad338cd848251f33a236ccb36cMatt Arsenault case AddrSpaceCast: return "addrspacecast"; 2433da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer 244c105645c16f77ee20b853baf717073ad393dd4aaVikram S. Adve // Other instructions... 24574f1642bc1c2981e4573c9f0690d91b6a9bbc68cReid Spencer case ICmp: return "icmp"; 24674f1642bc1c2981e4573c9f0690d91b6a9bbc68cReid Spencer case FCmp: return "fcmp"; 2473da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer case PHI: return "phi"; 2483da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer case Select: return "select"; 2493da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer case Call: return "call"; 2503da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer case Shl: return "shl"; 2513da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer case LShr: return "lshr"; 2523da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer case AShr: return "ashr"; 2533da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer case VAArg: return "va_arg"; 254b52ee7f5ffd189c4f21ab227c6a24061ef3378fcRobert Bocchino case ExtractElement: return "extractelement"; 2553da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer case InsertElement: return "insertelement"; 2563da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer case ShuffleVector: return "shufflevector"; 25774b5e07cc4a65989eb43bdc016d51db3c192691fMatthijs Kooijman case ExtractValue: return "extractvalue"; 25874b5e07cc4a65989eb43bdc016d51db3c192691fMatthijs Kooijman case InsertValue: return "insertvalue"; 259e6e8826870bee3facb04f950f0bd725f8a88623dBill Wendling case LandingPad: return "landingpad"; 2608f77daef04355c00b78b645f5aae5694e7a8b631Chris Lattner 261c105645c16f77ee20b853baf717073ad393dd4aaVikram S. Adve default: return "<Invalid operator> "; 262c105645c16f77ee20b853baf717073ad393dd4aaVikram S. Adve } 263c105645c16f77ee20b853baf717073ad393dd4aaVikram S. Adve} 264f2da7241f590aaae128ecce7732c6094084df2b6Chris Lattner 265dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines/// Return true if both instructions have the same special state 266dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines/// This must be kept in sync with lib/Transforms/IPO/MergeFunctions.cpp. 267dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hinesstatic bool haveSameSpecialState(const Instruction *I1, const Instruction *I2, 268dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines bool IgnoreAlignment = false) { 269dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines assert(I1->getOpcode() == I2->getOpcode() && 270dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines "Can not compare special state of different instructions"); 271dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines 272dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (const LoadInst *LI = dyn_cast<LoadInst>(I1)) 273dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return LI->isVolatile() == cast<LoadInst>(I2)->isVolatile() && 274dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines (LI->getAlignment() == cast<LoadInst>(I2)->getAlignment() || 275dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines IgnoreAlignment) && 276dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines LI->getOrdering() == cast<LoadInst>(I2)->getOrdering() && 277dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines LI->getSynchScope() == cast<LoadInst>(I2)->getSynchScope(); 278dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (const StoreInst *SI = dyn_cast<StoreInst>(I1)) 279dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return SI->isVolatile() == cast<StoreInst>(I2)->isVolatile() && 280dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines (SI->getAlignment() == cast<StoreInst>(I2)->getAlignment() || 281dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines IgnoreAlignment) && 282dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines SI->getOrdering() == cast<StoreInst>(I2)->getOrdering() && 283dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines SI->getSynchScope() == cast<StoreInst>(I2)->getSynchScope(); 284dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (const CmpInst *CI = dyn_cast<CmpInst>(I1)) 285dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return CI->getPredicate() == cast<CmpInst>(I2)->getPredicate(); 286dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (const CallInst *CI = dyn_cast<CallInst>(I1)) 287dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return CI->isTailCall() == cast<CallInst>(I2)->isTailCall() && 288dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines CI->getCallingConv() == cast<CallInst>(I2)->getCallingConv() && 289dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines CI->getAttributes() == cast<CallInst>(I2)->getAttributes(); 290dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (const InvokeInst *CI = dyn_cast<InvokeInst>(I1)) 291dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return CI->getCallingConv() == cast<InvokeInst>(I2)->getCallingConv() && 292dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines CI->getAttributes() == 293dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines cast<InvokeInst>(I2)->getAttributes(); 294dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (const InsertValueInst *IVI = dyn_cast<InsertValueInst>(I1)) 295dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return IVI->getIndices() == cast<InsertValueInst>(I2)->getIndices(); 296dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (const ExtractValueInst *EVI = dyn_cast<ExtractValueInst>(I1)) 297dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return EVI->getIndices() == cast<ExtractValueInst>(I2)->getIndices(); 298dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (const FenceInst *FI = dyn_cast<FenceInst>(I1)) 299dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return FI->getOrdering() == cast<FenceInst>(I2)->getOrdering() && 300dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines FI->getSynchScope() == cast<FenceInst>(I2)->getSynchScope(); 301dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (const AtomicCmpXchgInst *CXI = dyn_cast<AtomicCmpXchgInst>(I1)) 302dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return CXI->isVolatile() == cast<AtomicCmpXchgInst>(I2)->isVolatile() && 303cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines CXI->isWeak() == cast<AtomicCmpXchgInst>(I2)->isWeak() && 304dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines CXI->getSuccessOrdering() == 305dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines cast<AtomicCmpXchgInst>(I2)->getSuccessOrdering() && 306dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines CXI->getFailureOrdering() == 307dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines cast<AtomicCmpXchgInst>(I2)->getFailureOrdering() && 308dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines CXI->getSynchScope() == cast<AtomicCmpXchgInst>(I2)->getSynchScope(); 309dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (const AtomicRMWInst *RMWI = dyn_cast<AtomicRMWInst>(I1)) 310dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return RMWI->getOperation() == cast<AtomicRMWInst>(I2)->getOperation() && 311dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines RMWI->isVolatile() == cast<AtomicRMWInst>(I2)->isVolatile() && 312dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines RMWI->getOrdering() == cast<AtomicRMWInst>(I2)->getOrdering() && 313dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines RMWI->getSynchScope() == cast<AtomicRMWInst>(I2)->getSynchScope(); 314dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines 315dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return true; 316dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines} 317dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines 31838f14553939e574becab6ea1e0b055d31293b0cfChris Lattner/// isIdenticalTo - Return true if the specified instruction is exactly 31938f14553939e574becab6ea1e0b055d31293b0cfChris Lattner/// identical to the current one. This means that all operands match and any 32038f14553939e574becab6ea1e0b055d31293b0cfChris Lattner/// extra information (e.g. load is volatile) agree. 321e3a0884ddf9009f040d80f5fde3b6d5d70b0fa13Chris Lattnerbool Instruction::isIdenticalTo(const Instruction *I) const { 32275b0edae7275436c1255c10eb98e5b0dffc978f6Dan Gohman return isIdenticalToWhenDefined(I) && 32358cfa3b13752579c86cf85270d49f9ced0942f2fDan Gohman SubclassOptionalData == I->SubclassOptionalData; 32458cfa3b13752579c86cf85270d49f9ced0942f2fDan Gohman} 32558cfa3b13752579c86cf85270d49f9ced0942f2fDan Gohman 32675b0edae7275436c1255c10eb98e5b0dffc978f6Dan Gohman/// isIdenticalToWhenDefined - This is like isIdenticalTo, except that it 32758cfa3b13752579c86cf85270d49f9ced0942f2fDan Gohman/// ignores the SubclassOptionalData flags, which specify conditions 32858cfa3b13752579c86cf85270d49f9ced0942f2fDan Gohman/// under which the instruction's result is undefined. 32958cfa3b13752579c86cf85270d49f9ced0942f2fDan Gohmanbool Instruction::isIdenticalToWhenDefined(const Instruction *I) const { 33038f14553939e574becab6ea1e0b055d31293b0cfChris Lattner if (getOpcode() != I->getOpcode() || 33138f14553939e574becab6ea1e0b055d31293b0cfChris Lattner getNumOperands() != I->getNumOperands() || 33238f14553939e574becab6ea1e0b055d31293b0cfChris Lattner getType() != I->getType()) 33338f14553939e574becab6ea1e0b055d31293b0cfChris Lattner return false; 33438f14553939e574becab6ea1e0b055d31293b0cfChris Lattner 335cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines // If both instructions have no operands, they are identical. 336cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines if (getNumOperands() == 0 && I->getNumOperands() == 0) 337cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines return haveSameSpecialState(this, I); 338cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines 33938f14553939e574becab6ea1e0b055d31293b0cfChris Lattner // We have two instructions of identical opcode and #operands. Check to see 34038f14553939e574becab6ea1e0b055d31293b0cfChris Lattner // if all operands are the same. 34136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (!std::equal(op_begin(), op_end(), I->op_begin())) 34236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return false; 34338f14553939e574becab6ea1e0b055d31293b0cfChris Lattner 3449df72a93ef27a27c6853eed3ed92c9e0b62c9ca6Joel Jones if (const PHINode *thisPHI = dyn_cast<PHINode>(this)) { 3459df72a93ef27a27c6853eed3ed92c9e0b62c9ca6Joel Jones const PHINode *otherPHI = cast<PHINode>(I); 34636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return std::equal(thisPHI->block_begin(), thisPHI->block_end(), 34736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines otherPHI->block_begin()); 3489df72a93ef27a27c6853eed3ed92c9e0b62c9ca6Joel Jones } 349dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines 350dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return haveSameSpecialState(this, I); 351e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer} 352e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer 353e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer// isSameOperationAs 354194ae785e1f94619cbdcdcf2921caa6997277d32Dan Gohman// This should be kept in sync with isEquivalentOperation in 355194ae785e1f94619cbdcdcf2921caa6997277d32Dan Gohman// lib/Transforms/IPO/MergeFunctions.cpp. 356ec4e85e3364f50802f2007e4b1e23661d4610366Hal Finkelbool Instruction::isSameOperationAs(const Instruction *I, 357ec4e85e3364f50802f2007e4b1e23661d4610366Hal Finkel unsigned flags) const { 358ec4e85e3364f50802f2007e4b1e23661d4610366Hal Finkel bool IgnoreAlignment = flags & CompareIgnoringAlignment; 359ec4e85e3364f50802f2007e4b1e23661d4610366Hal Finkel bool UseScalarTypes = flags & CompareUsingScalarTypes; 360ec4e85e3364f50802f2007e4b1e23661d4610366Hal Finkel 361194ae785e1f94619cbdcdcf2921caa6997277d32Dan Gohman if (getOpcode() != I->getOpcode() || 362194ae785e1f94619cbdcdcf2921caa6997277d32Dan Gohman getNumOperands() != I->getNumOperands() || 363ec4e85e3364f50802f2007e4b1e23661d4610366Hal Finkel (UseScalarTypes ? 364ec4e85e3364f50802f2007e4b1e23661d4610366Hal Finkel getType()->getScalarType() != I->getType()->getScalarType() : 365ec4e85e3364f50802f2007e4b1e23661d4610366Hal Finkel getType() != I->getType())) 366e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer return false; 367e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer 368e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer // We have two instructions of identical opcode and #operands. Check to see 369e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer // if all operands are the same type 370e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer for (unsigned i = 0, e = getNumOperands(); i != e; ++i) 371ec4e85e3364f50802f2007e4b1e23661d4610366Hal Finkel if (UseScalarTypes ? 372ec4e85e3364f50802f2007e4b1e23661d4610366Hal Finkel getOperand(i)->getType()->getScalarType() != 373ec4e85e3364f50802f2007e4b1e23661d4610366Hal Finkel I->getOperand(i)->getType()->getScalarType() : 374ec4e85e3364f50802f2007e4b1e23661d4610366Hal Finkel getOperand(i)->getType() != I->getOperand(i)->getType()) 375e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer return false; 376e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer 377dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return haveSameSpecialState(this, I, IgnoreAlignment); 37838f14553939e574becab6ea1e0b055d31293b0cfChris Lattner} 37938f14553939e574becab6ea1e0b055d31293b0cfChris Lattner 3807ae40e7d8ac43feaa5b3107e02c9b3a77fe729f2Chris Lattner/// isUsedOutsideOfBlock - Return true if there are any uses of I outside of the 3817ae40e7d8ac43feaa5b3107e02c9b3a77fe729f2Chris Lattner/// specified block. Note that PHI nodes are considered to evaluate their 3827ae40e7d8ac43feaa5b3107e02c9b3a77fe729f2Chris Lattner/// operands in the corresponding predecessor block. 3837ae40e7d8ac43feaa5b3107e02c9b3a77fe729f2Chris Lattnerbool Instruction::isUsedOutsideOfBlock(const BasicBlock *BB) const { 38436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines for (const Use &U : uses()) { 3857ae40e7d8ac43feaa5b3107e02c9b3a77fe729f2Chris Lattner // PHI nodes uses values in the corresponding predecessor block. For other 3867ae40e7d8ac43feaa5b3107e02c9b3a77fe729f2Chris Lattner // instructions, just check to see whether the parent of the use matches up. 38736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines const Instruction *I = cast<Instruction>(U.getUser()); 38836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines const PHINode *PN = dyn_cast<PHINode>(I); 389dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (!PN) { 39036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (I->getParent() != BB) 3917ae40e7d8ac43feaa5b3107e02c9b3a77fe729f2Chris Lattner return true; 3927ae40e7d8ac43feaa5b3107e02c9b3a77fe729f2Chris Lattner continue; 3937ae40e7d8ac43feaa5b3107e02c9b3a77fe729f2Chris Lattner } 394a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 39536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (PN->getIncomingBlock(U) != BB) 3967ae40e7d8ac43feaa5b3107e02c9b3a77fe729f2Chris Lattner return true; 3977ae40e7d8ac43feaa5b3107e02c9b3a77fe729f2Chris Lattner } 398a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar return false; 3997ae40e7d8ac43feaa5b3107e02c9b3a77fe729f2Chris Lattner} 4007ae40e7d8ac43feaa5b3107e02c9b3a77fe729f2Chris Lattner 401d96288a2ff188bb1fb1b86fb89b1ac82f6310a5cChris Lattner/// mayReadFromMemory - Return true if this instruction may read memory. 402d96288a2ff188bb1fb1b86fb89b1ac82f6310a5cChris Lattner/// 403d96288a2ff188bb1fb1b86fb89b1ac82f6310a5cChris Lattnerbool Instruction::mayReadFromMemory() const { 404d96288a2ff188bb1fb1b86fb89b1ac82f6310a5cChris Lattner switch (getOpcode()) { 405d96288a2ff188bb1fb1b86fb89b1ac82f6310a5cChris Lattner default: return false; 406d96288a2ff188bb1fb1b86fb89b1ac82f6310a5cChris Lattner case Instruction::VAArg: 407748118d8aa8a66597437e6970ab389c988bbdb8bChris Lattner case Instruction::Load: 4088a552bb85a5e9a6c250c0a899941fbd3ae7b5006Eli Friedman case Instruction::Fence: // FIXME: refine definition of mayReadFromMemory 40955ba816883842e793cdeb32fcb805c4e011b527fEli Friedman case Instruction::AtomicCmpXchg: 41055ba816883842e793cdeb32fcb805c4e011b527fEli Friedman case Instruction::AtomicRMW: 411d96288a2ff188bb1fb1b86fb89b1ac82f6310a5cChris Lattner return true; 412d96288a2ff188bb1fb1b86fb89b1ac82f6310a5cChris Lattner case Instruction::Call: 413d96288a2ff188bb1fb1b86fb89b1ac82f6310a5cChris Lattner return !cast<CallInst>(this)->doesNotAccessMemory(); 414d96288a2ff188bb1fb1b86fb89b1ac82f6310a5cChris Lattner case Instruction::Invoke: 415d96288a2ff188bb1fb1b86fb89b1ac82f6310a5cChris Lattner return !cast<InvokeInst>(this)->doesNotAccessMemory(); 416748118d8aa8a66597437e6970ab389c988bbdb8bChris Lattner case Instruction::Store: 417e5e771263a71536ab2794ae726f43e7ccd2720acEli Friedman return !cast<StoreInst>(this)->isUnordered(); 418d96288a2ff188bb1fb1b86fb89b1ac82f6310a5cChris Lattner } 419d96288a2ff188bb1fb1b86fb89b1ac82f6310a5cChris Lattner} 4207ae40e7d8ac43feaa5b3107e02c9b3a77fe729f2Chris Lattner 421bb5493d9fa8845f002613ac013087b347a052357Chris Lattner/// mayWriteToMemory - Return true if this instruction may modify memory. 422bb5493d9fa8845f002613ac013087b347a052357Chris Lattner/// 423bb5493d9fa8845f002613ac013087b347a052357Chris Lattnerbool Instruction::mayWriteToMemory() const { 424bb5493d9fa8845f002613ac013087b347a052357Chris Lattner switch (getOpcode()) { 425bb5493d9fa8845f002613ac013087b347a052357Chris Lattner default: return false; 4268a552bb85a5e9a6c250c0a899941fbd3ae7b5006Eli Friedman case Instruction::Fence: // FIXME: refine definition of mayWriteToMemory 427a3355ffb3d30d19d226bbb75707991c60f236e37Duncan Sands case Instruction::Store: 428bb5493d9fa8845f002613ac013087b347a052357Chris Lattner case Instruction::VAArg: 42955ba816883842e793cdeb32fcb805c4e011b527fEli Friedman case Instruction::AtomicCmpXchg: 43055ba816883842e793cdeb32fcb805c4e011b527fEli Friedman case Instruction::AtomicRMW: 431bb5493d9fa8845f002613ac013087b347a052357Chris Lattner return true; 432bb5493d9fa8845f002613ac013087b347a052357Chris Lattner case Instruction::Call: 433a3355ffb3d30d19d226bbb75707991c60f236e37Duncan Sands return !cast<CallInst>(this)->onlyReadsMemory(); 434d96288a2ff188bb1fb1b86fb89b1ac82f6310a5cChris Lattner case Instruction::Invoke: 435d96288a2ff188bb1fb1b86fb89b1ac82f6310a5cChris Lattner return !cast<InvokeInst>(this)->onlyReadsMemory(); 436bb5493d9fa8845f002613ac013087b347a052357Chris Lattner case Instruction::Load: 437e5e771263a71536ab2794ae726f43e7ccd2720acEli Friedman return !cast<LoadInst>(this)->isUnordered(); 438bb5493d9fa8845f002613ac013087b347a052357Chris Lattner } 439bb5493d9fa8845f002613ac013087b347a052357Chris Lattner} 440f2da7241f590aaae128ecce7732c6094084df2b6Chris Lattner 4417af1c78b98d2df7d0ab9154461ca3d835706716eDuncan Sandsbool Instruction::mayThrow() const { 4427af1c78b98d2df7d0ab9154461ca3d835706716eDuncan Sands if (const CallInst *CI = dyn_cast<CallInst>(this)) 4437af1c78b98d2df7d0ab9154461ca3d835706716eDuncan Sands return !CI->doesNotThrow(); 44455fdb4eec073fe7fd480ffa7e2a3b05acfacd5b1Bill Wendling return isa<ResumeInst>(this); 4457af1c78b98d2df7d0ab9154461ca3d835706716eDuncan Sands} 4467af1c78b98d2df7d0ab9154461ca3d835706716eDuncan Sands 44703544ec2a43fab162d25cf44627d1d08430bcccdNadav Rotembool Instruction::mayReturn() const { 44803544ec2a43fab162d25cf44627d1d08430bcccdNadav Rotem if (const CallInst *CI = dyn_cast<CallInst>(this)) 44903544ec2a43fab162d25cf44627d1d08430bcccdNadav Rotem return !CI->doesNotReturn(); 45003544ec2a43fab162d25cf44627d1d08430bcccdNadav Rotem return true; 45103544ec2a43fab162d25cf44627d1d08430bcccdNadav Rotem} 45203544ec2a43fab162d25cf44627d1d08430bcccdNadav Rotem 453f2da7241f590aaae128ecce7732c6094084df2b6Chris Lattner/// isAssociative - Return true if the instruction is associative: 454f2da7241f590aaae128ecce7732c6094084df2b6Chris Lattner/// 455ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman/// Associative operators satisfy: x op (y op z) === (x op y) op z 456f2da7241f590aaae128ecce7732c6094084df2b6Chris Lattner/// 457ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman/// In LLVM, the Add, Mul, And, Or, and Xor operators are associative. 458f2da7241f590aaae128ecce7732c6094084df2b6Chris Lattner/// 4590d7ce5ffa4aa853b75e1015c62e27bd9f23ef73bDuncan Sandsbool Instruction::isAssociative(unsigned Opcode) { 460ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman return Opcode == And || Opcode == Or || Opcode == Xor || 461ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman Opcode == Add || Opcode == Mul; 462f2da7241f590aaae128ecce7732c6094084df2b6Chris Lattner} 463f2da7241f590aaae128ecce7732c6094084df2b6Chris Lattner 4649b7f6f2de89a321f7eae5e942c8668cb50acfd1dShuxin Yangbool Instruction::isAssociative() const { 4659b7f6f2de89a321f7eae5e942c8668cb50acfd1dShuxin Yang unsigned Opcode = getOpcode(); 4669b7f6f2de89a321f7eae5e942c8668cb50acfd1dShuxin Yang if (isAssociative(Opcode)) 4679b7f6f2de89a321f7eae5e942c8668cb50acfd1dShuxin Yang return true; 4689b7f6f2de89a321f7eae5e942c8668cb50acfd1dShuxin Yang 4699b7f6f2de89a321f7eae5e942c8668cb50acfd1dShuxin Yang switch (Opcode) { 4709b7f6f2de89a321f7eae5e942c8668cb50acfd1dShuxin Yang case FMul: 4719b7f6f2de89a321f7eae5e942c8668cb50acfd1dShuxin Yang case FAdd: 4729b7f6f2de89a321f7eae5e942c8668cb50acfd1dShuxin Yang return cast<FPMathOperator>(this)->hasUnsafeAlgebra(); 4739b7f6f2de89a321f7eae5e942c8668cb50acfd1dShuxin Yang default: 4749b7f6f2de89a321f7eae5e942c8668cb50acfd1dShuxin Yang return false; 4759b7f6f2de89a321f7eae5e942c8668cb50acfd1dShuxin Yang } 4769b7f6f2de89a321f7eae5e942c8668cb50acfd1dShuxin Yang} 4779b7f6f2de89a321f7eae5e942c8668cb50acfd1dShuxin Yang 478f2da7241f590aaae128ecce7732c6094084df2b6Chris Lattner/// isCommutative - Return true if the instruction is commutative: 479f2da7241f590aaae128ecce7732c6094084df2b6Chris Lattner/// 4806b63452c3ad26678b32f93dbca55902a313ee4e9Misha Brukman/// Commutative operators satisfy: (x op y) === (y op x) 481f2da7241f590aaae128ecce7732c6094084df2b6Chris Lattner/// 482f2da7241f590aaae128ecce7732c6094084df2b6Chris Lattner/// In LLVM, these are the associative operators, plus SetEQ and SetNE, when 483f2da7241f590aaae128ecce7732c6094084df2b6Chris Lattner/// applied to any type. 484f2da7241f590aaae128ecce7732c6094084df2b6Chris Lattner/// 485f2da7241f590aaae128ecce7732c6094084df2b6Chris Lattnerbool Instruction::isCommutative(unsigned op) { 486f2da7241f590aaae128ecce7732c6094084df2b6Chris Lattner switch (op) { 487f2da7241f590aaae128ecce7732c6094084df2b6Chris Lattner case Add: 488ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case FAdd: 489f2da7241f590aaae128ecce7732c6094084df2b6Chris Lattner case Mul: 490ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case FMul: 491fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman case And: 492f2da7241f590aaae128ecce7732c6094084df2b6Chris Lattner case Or: 493f2da7241f590aaae128ecce7732c6094084df2b6Chris Lattner case Xor: 494f2da7241f590aaae128ecce7732c6094084df2b6Chris Lattner return true; 495f2da7241f590aaae128ecce7732c6094084df2b6Chris Lattner default: 496f2da7241f590aaae128ecce7732c6094084df2b6Chris Lattner return false; 497f2da7241f590aaae128ecce7732c6094084df2b6Chris Lattner } 498f2da7241f590aaae128ecce7732c6094084df2b6Chris Lattner} 499741bb0019de9aa28a731b4eef2422a3397f99cd0Tanya Lattner 500c038a7833565ecf92a699371d448135a097c9e2fDuncan Sands/// isIdempotent - Return true if the instruction is idempotent: 501c038a7833565ecf92a699371d448135a097c9e2fDuncan Sands/// 502c038a7833565ecf92a699371d448135a097c9e2fDuncan Sands/// Idempotent operators satisfy: x op x === x 503c038a7833565ecf92a699371d448135a097c9e2fDuncan Sands/// 504c038a7833565ecf92a699371d448135a097c9e2fDuncan Sands/// In LLVM, the And and Or operators are idempotent. 505c038a7833565ecf92a699371d448135a097c9e2fDuncan Sands/// 506c038a7833565ecf92a699371d448135a097c9e2fDuncan Sandsbool Instruction::isIdempotent(unsigned Opcode) { 507c038a7833565ecf92a699371d448135a097c9e2fDuncan Sands return Opcode == And || Opcode == Or; 508c038a7833565ecf92a699371d448135a097c9e2fDuncan Sands} 509c038a7833565ecf92a699371d448135a097c9e2fDuncan Sands 510c038a7833565ecf92a699371d448135a097c9e2fDuncan Sands/// isNilpotent - Return true if the instruction is nilpotent: 511c038a7833565ecf92a699371d448135a097c9e2fDuncan Sands/// 512c038a7833565ecf92a699371d448135a097c9e2fDuncan Sands/// Nilpotent operators satisfy: x op x === Id, 513c038a7833565ecf92a699371d448135a097c9e2fDuncan Sands/// 514c038a7833565ecf92a699371d448135a097c9e2fDuncan Sands/// where Id is the identity for the operator, i.e. a constant such that 515c038a7833565ecf92a699371d448135a097c9e2fDuncan Sands/// x op Id === x and Id op x === x for all x. 516c038a7833565ecf92a699371d448135a097c9e2fDuncan Sands/// 517c038a7833565ecf92a699371d448135a097c9e2fDuncan Sands/// In LLVM, the Xor operator is nilpotent. 518c038a7833565ecf92a699371d448135a097c9e2fDuncan Sands/// 519c038a7833565ecf92a699371d448135a097c9e2fDuncan Sandsbool Instruction::isNilpotent(unsigned Opcode) { 520c038a7833565ecf92a699371d448135a097c9e2fDuncan Sands return Opcode == Xor; 521c038a7833565ecf92a699371d448135a097c9e2fDuncan Sands} 522c038a7833565ecf92a699371d448135a097c9e2fDuncan Sands 52350b6e33584f4e4cf75c7795b1f1a90731861c825Devang PatelInstruction *Instruction::clone() const { 52450b6e33584f4e4cf75c7795b1f1a90731861c825Devang Patel Instruction *New = clone_impl(); 52550b6e33584f4e4cf75c7795b1f1a90731861c825Devang Patel New->SubclassOptionalData = SubclassOptionalData; 526508b19a5a41a4b82be4ae71e6ea5c691bea99b96Chris Lattner if (!hasMetadata()) 527508b19a5a41a4b82be4ae71e6ea5c691bea99b96Chris Lattner return New; 528407a6169b729c72c3a7ddb01b8454ab0b4f6897cMichael Ilseman 529508b19a5a41a4b82be4ae71e6ea5c691bea99b96Chris Lattner // Otherwise, enumerate and copy over metadata from the old instruction to the 530508b19a5a41a4b82be4ae71e6ea5c691bea99b96Chris Lattner // new one. 531508b19a5a41a4b82be4ae71e6ea5c691bea99b96Chris Lattner SmallVector<std::pair<unsigned, MDNode*>, 4> TheMDs; 5324baa510f48000308251a0d7c6be491d11c20d30bChris Lattner getAllMetadataOtherThanDebugLoc(TheMDs); 53336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines for (const auto &MD : TheMDs) 53436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines New->setMetadata(MD.first, MD.second); 535407a6169b729c72c3a7ddb01b8454ab0b4f6897cMichael Ilseman 5364baa510f48000308251a0d7c6be491d11c20d30bChris Lattner New->setDebugLoc(getDebugLoc()); 53750b6e33584f4e4cf75c7795b1f1a90731861c825Devang Patel return New; 53850b6e33584f4e4cf75c7795b1f1a90731861c825Devang Patel} 539