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" 150b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/Constants.h" 160b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/Instructions.h" 170b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/Module.h" 180b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/Operator.h" 190b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/Type.h" 20a3355ffb3d30d19d226bbb75707991c60f236e37Duncan Sands#include "llvm/Support/CallSite.h" 21551ccae044b0ff658fe629dd67edd5ffe75d10e8Reid Spencer#include "llvm/Support/LeakDetector.h" 224b74c8333495c609fa81421df32e46db616672e1Chris Lattnerusing namespace llvm; 23d0fde30ce850b78371fd1386338350591f9ff494Brian Gaeke 24db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris LattnerInstruction::Instruction(Type *ty, unsigned it, Use *Ops, unsigned NumOps, 25910c80a07503591052a77cefb26cebea95a8d743Chris Lattner Instruction *InsertBefore) 2661336ae001e07c6d68454b1494e45954d373fb51Chris Lattner : User(ty, Value::InstructionVal + it, Ops, NumOps), Parent(0) { 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 38db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris LattnerInstruction::Instruction(Type *ty, unsigned it, Use *Ops, unsigned NumOps, 39910c80a07503591052a77cefb26cebea95a8d743Chris Lattner BasicBlock *InsertAtEnd) 4061336ae001e07c6d68454b1494e45954d373fb51Chris Lattner : User(ty, Value::InstructionVal + it, Ops, NumOps), Parent(0) { 4196d83f63cdbb33c075901b1b84eb07622d86386fChris Lattner // Make sure that we get added to a basicblock 4296d83f63cdbb33c075901b1b84eb07622d86386fChris Lattner LeakDetector::addGarbageObject(this); 43e5828f1fa7c2691f747f5060ce11b8e55cea03abAlkis Evlogimenos 44e5828f1fa7c2691f747f5060ce11b8e55cea03abAlkis Evlogimenos // append this instruction into the basic block 45e5828f1fa7c2691f747f5060ce11b8e55cea03abAlkis Evlogimenos assert(InsertAtEnd && "Basic block to append to may not be NULL!"); 46e5828f1fa7c2691f747f5060ce11b8e55cea03abAlkis Evlogimenos InsertAtEnd->getInstList().push_back(this); 47f00042a9990d90885a8f236ed0f6bf07902d1374Chris Lattner} 48f00042a9990d90885a8f236ed0f6bf07902d1374Chris Lattner 49f00042a9990d90885a8f236ed0f6bf07902d1374Chris Lattner 5070aa33ee37fede7fb84de02daa38557ffd366458Chris Lattner// Out of line virtual method, so the vtable, etc has a home. 51afba8fe662d65b25b4baf46bb26cc18e1f9cc0a5Gordon HenriksenInstruction::~Instruction() { 52f9e0a220fc97df6bcbd545009e036a91f67e9cc4Devang Patel assert(Parent == 0 && "Instruction still linked in the program!"); 534f1be4abba762f8a7b77d7622abaf1ed1a87b48bDan Gohman if (hasMetadataHashEntry()) 544f1be4abba762f8a7b77d7622abaf1ed1a87b48bDan Gohman clearMetadataHashEntries(); 5570aa33ee37fede7fb84de02daa38557ffd366458Chris Lattner} 5670aa33ee37fede7fb84de02daa38557ffd366458Chris Lattner 5770aa33ee37fede7fb84de02daa38557ffd366458Chris Lattner 58bded132d00ed626a6541b67ad101ef0fd47d3491Chris Lattnervoid Instruction::setParent(BasicBlock *P) { 59786993c01ec8bdabe354fb62a083fedc9d7a087eChris Lattner if (getParent()) { 60786993c01ec8bdabe354fb62a083fedc9d7a087eChris Lattner if (!P) LeakDetector::addGarbageObject(this); 61786993c01ec8bdabe354fb62a083fedc9d7a087eChris Lattner } else { 62786993c01ec8bdabe354fb62a083fedc9d7a087eChris Lattner if (P) LeakDetector::removeGarbageObject(this); 63786993c01ec8bdabe354fb62a083fedc9d7a087eChris Lattner } 64d1e693f2a3883dacf213aa2b477540c57b53b714Chris Lattner 65bded132d00ed626a6541b67ad101ef0fd47d3491Chris Lattner Parent = P; 66bded132d00ed626a6541b67ad101ef0fd47d3491Chris Lattner} 67bded132d00ed626a6541b67ad101ef0fd47d3491Chris Lattner 684b83380f330b1c77bb9b4ad8f63bdcf1a596afd6Chris Lattnervoid Instruction::removeFromParent() { 694b83380f330b1c77bb9b4ad8f63bdcf1a596afd6Chris Lattner getParent()->getInstList().remove(this); 704b83380f330b1c77bb9b4ad8f63bdcf1a596afd6Chris Lattner} 714b83380f330b1c77bb9b4ad8f63bdcf1a596afd6Chris Lattner 724b83380f330b1c77bb9b4ad8f63bdcf1a596afd6Chris Lattnervoid Instruction::eraseFromParent() { 734b83380f330b1c77bb9b4ad8f63bdcf1a596afd6Chris Lattner getParent()->getInstList().erase(this); 744b83380f330b1c77bb9b4ad8f63bdcf1a596afd6Chris Lattner} 75c105645c16f77ee20b853baf717073ad393dd4aaVikram S. Adve 7626bb50ab48c561adfd32d129e0eff0cbf0a04625Owen Anderson/// insertBefore - Insert an unlinked instructions into a basic block 7726bb50ab48c561adfd32d129e0eff0cbf0a04625Owen Anderson/// immediately before the specified instruction. 7826bb50ab48c561adfd32d129e0eff0cbf0a04625Owen Andersonvoid Instruction::insertBefore(Instruction *InsertPos) { 7926bb50ab48c561adfd32d129e0eff0cbf0a04625Owen Anderson InsertPos->getParent()->getInstList().insert(InsertPos, this); 8026bb50ab48c561adfd32d129e0eff0cbf0a04625Owen Anderson} 8126bb50ab48c561adfd32d129e0eff0cbf0a04625Owen Anderson 823ff704fa2b67d6c857142218c5aca3058b6239fcChris Lattner/// insertAfter - Insert an unlinked instructions into a basic block 833ff704fa2b67d6c857142218c5aca3058b6239fcChris Lattner/// immediately after the specified instruction. 843ff704fa2b67d6c857142218c5aca3058b6239fcChris Lattnervoid Instruction::insertAfter(Instruction *InsertPos) { 853ff704fa2b67d6c857142218c5aca3058b6239fcChris Lattner InsertPos->getParent()->getInstList().insertAfter(InsertPos, this); 863ff704fa2b67d6c857142218c5aca3058b6239fcChris Lattner} 873ff704fa2b67d6c857142218c5aca3058b6239fcChris Lattner 880fe34d89126c594e0e8378d978a593350189fedfChris Lattner/// moveBefore - Unlink this instruction from its current basic block and 890fe34d89126c594e0e8378d978a593350189fedfChris Lattner/// insert it into the basic block that MovePos lives in, right before 900fe34d89126c594e0e8378d978a593350189fedfChris Lattner/// MovePos. 910fe34d89126c594e0e8378d978a593350189fedfChris Lattnervoid Instruction::moveBefore(Instruction *MovePos) { 920fe34d89126c594e0e8378d978a593350189fedfChris Lattner MovePos->getParent()->getInstList().splice(MovePos,getParent()->getInstList(), 930fe34d89126c594e0e8378d978a593350189fedfChris Lattner this); 940fe34d89126c594e0e8378d978a593350189fedfChris Lattner} 950fe34d89126c594e0e8378d978a593350189fedfChris Lattner 96125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman/// Set or clear the unsafe-algebra flag on this instruction, which must be an 97125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman/// operator which supports this flag. See LangRef.html for the meaning of this 98125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman/// flag. 99125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilsemanvoid Instruction::setHasUnsafeAlgebra(bool B) { 100125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman assert(isa<FPMathOperator>(this) && "setting fast-math flag on invalid op"); 101125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman cast<FPMathOperator>(this)->setHasUnsafeAlgebra(B); 102125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman} 103125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman 104125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman/// Set or clear the NoNaNs flag on this instruction, which must be an operator 105125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman/// which supports this flag. See LangRef.html for the meaning of this flag. 106125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilsemanvoid Instruction::setHasNoNaNs(bool B) { 107125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman assert(isa<FPMathOperator>(this) && "setting fast-math flag on invalid op"); 108125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman cast<FPMathOperator>(this)->setHasNoNaNs(B); 109125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman} 110125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman 111125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman/// Set or clear the no-infs flag on this instruction, which must be an operator 112125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman/// which supports this flag. See LangRef.html for the meaning of this flag. 113125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilsemanvoid Instruction::setHasNoInfs(bool B) { 114125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman assert(isa<FPMathOperator>(this) && "setting fast-math flag on invalid op"); 115125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman cast<FPMathOperator>(this)->setHasNoInfs(B); 116125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman} 117125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman 118125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman/// Set or clear the no-signed-zeros flag on this instruction, which must be an 119125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman/// operator which supports this flag. See LangRef.html for the meaning of this 120125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman/// flag. 121125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilsemanvoid Instruction::setHasNoSignedZeros(bool B) { 122125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman assert(isa<FPMathOperator>(this) && "setting fast-math flag on invalid op"); 123125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman cast<FPMathOperator>(this)->setHasNoSignedZeros(B); 124125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman} 125125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman 126125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman/// Set or clear the allow-reciprocal flag on this instruction, which must be an 127125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman/// operator which supports this flag. See LangRef.html for the meaning of this 128125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman/// flag. 129125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilsemanvoid Instruction::setHasAllowReciprocal(bool B) { 130125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman assert(isa<FPMathOperator>(this) && "setting fast-math flag on invalid op"); 131125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman cast<FPMathOperator>(this)->setHasAllowReciprocal(B); 132125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman} 133125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman 134125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman/// Convenience function for setting all the fast-math flags on this 135125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman/// instruction, which must be an operator which supports these flags. See 136125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman/// LangRef.html for the meaning of these flats. 137125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilsemanvoid Instruction::setFastMathFlags(FastMathFlags FMF) { 138125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman assert(isa<FPMathOperator>(this) && "setting fast-math flag on invalid op"); 139125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman cast<FPMathOperator>(this)->setFastMathFlags(FMF); 140125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman} 141125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman 142125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman/// Determine whether the unsafe-algebra flag is set. 143125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilsemanbool Instruction::hasUnsafeAlgebra() const { 144125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman assert(isa<FPMathOperator>(this) && "setting fast-math flag on invalid op"); 145125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman return cast<FPMathOperator>(this)->hasUnsafeAlgebra(); 146125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman} 147125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman 148125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman/// Determine whether the no-NaNs flag is set. 149125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilsemanbool Instruction::hasNoNaNs() const { 150125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman assert(isa<FPMathOperator>(this) && "setting fast-math flag on invalid op"); 151125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman return cast<FPMathOperator>(this)->hasNoNaNs(); 152125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman} 153125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman 154125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman/// Determine whether the no-infs flag is set. 155125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilsemanbool Instruction::hasNoInfs() const { 156125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman assert(isa<FPMathOperator>(this) && "setting fast-math flag on invalid op"); 157125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman return cast<FPMathOperator>(this)->hasNoInfs(); 158125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman} 159125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman 160125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman/// Determine whether the no-signed-zeros flag is set. 161125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilsemanbool Instruction::hasNoSignedZeros() const { 162125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman assert(isa<FPMathOperator>(this) && "setting fast-math flag on invalid op"); 163125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman return cast<FPMathOperator>(this)->hasNoSignedZeros(); 164125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman} 165125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman 166125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman/// Determine whether the allow-reciprocal flag is set. 167125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilsemanbool Instruction::hasAllowReciprocal() const { 168125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman assert(isa<FPMathOperator>(this) && "setting fast-math flag on invalid op"); 169125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman return cast<FPMathOperator>(this)->hasAllowReciprocal(); 170125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman} 171125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman 172125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman/// Convenience function for getting all the fast-math flags, which must be an 173125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman/// operator which supports these flags. See LangRef.html for the meaning of 174125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman/// these flats. 175125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael IlsemanFastMathFlags Instruction::getFastMathFlags() const { 176125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman assert(isa<FPMathOperator>(this) && "setting fast-math flag on invalid op"); 177125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman return cast<FPMathOperator>(this)->getFastMathFlags(); 178125fc7fefd4a198dd210cb43f5d8f1ba2c1e2dcfMichael Ilseman} 1790fe34d89126c594e0e8378d978a593350189fedfChris Lattner 1804b896dd613b1d85ee1b261ee470cb72fab24c282Michael Ilseman/// Copy I's fast-math flags 1814b896dd613b1d85ee1b261ee470cb72fab24c282Michael Ilsemanvoid Instruction::copyFastMathFlags(const Instruction *I) { 1824b896dd613b1d85ee1b261ee470cb72fab24c282Michael Ilseman setFastMathFlags(I->getFastMathFlags()); 1834b896dd613b1d85ee1b261ee470cb72fab24c282Michael Ilseman} 1844b896dd613b1d85ee1b261ee470cb72fab24c282Michael Ilseman 1854b896dd613b1d85ee1b261ee470cb72fab24c282Michael Ilseman 186c105645c16f77ee20b853baf717073ad393dd4aaVikram S. Adveconst char *Instruction::getOpcodeName(unsigned OpCode) { 187c105645c16f77ee20b853baf717073ad393dd4aaVikram S. Adve switch (OpCode) { 188c105645c16f77ee20b853baf717073ad393dd4aaVikram S. Adve // Terminators 1890513e9fe03f6e3c7d0272b8f4f82359e8d1a2e44Chris Lattner case Ret: return "ret"; 1900513e9fe03f6e3c7d0272b8f4f82359e8d1a2e44Chris Lattner case Br: return "br"; 191c105645c16f77ee20b853baf717073ad393dd4aaVikram S. Adve case Switch: return "switch"; 192ab21db79ef1d2530880ad11f21f0b87ffca02dd4Chris Lattner case IndirectBr: return "indirectbr"; 193c105645c16f77ee20b853baf717073ad393dd4aaVikram S. Adve case Invoke: return "invoke"; 194dccc03b2423fe65efb5963ae816b99c24fc53374Bill Wendling case Resume: return "resume"; 195b976e668165e1875a8f1eb7af800e33bb1e4393dChris Lattner case Unreachable: return "unreachable"; 196fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman 197c105645c16f77ee20b853baf717073ad393dd4aaVikram S. Adve // Standard binary operators... 198c105645c16f77ee20b853baf717073ad393dd4aaVikram S. Adve case Add: return "add"; 199ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case FAdd: return "fadd"; 200c105645c16f77ee20b853baf717073ad393dd4aaVikram S. Adve case Sub: return "sub"; 201ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case FSub: return "fsub"; 202c105645c16f77ee20b853baf717073ad393dd4aaVikram S. Adve case Mul: return "mul"; 203ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case FMul: return "fmul"; 2041628cec4d7fce310d9cde0bcc73997e5a71692c4Reid Spencer case UDiv: return "udiv"; 2051628cec4d7fce310d9cde0bcc73997e5a71692c4Reid Spencer case SDiv: return "sdiv"; 2061628cec4d7fce310d9cde0bcc73997e5a71692c4Reid Spencer case FDiv: return "fdiv"; 2070a783f783ca05c961234385f5b269d4cf03dbbdbReid Spencer case URem: return "urem"; 2080a783f783ca05c961234385f5b269d4cf03dbbdbReid Spencer case SRem: return "srem"; 2090a783f783ca05c961234385f5b269d4cf03dbbdbReid Spencer case FRem: return "frem"; 210c105645c16f77ee20b853baf717073ad393dd4aaVikram S. Adve 211c105645c16f77ee20b853baf717073ad393dd4aaVikram S. Adve // Logical operators... 212c105645c16f77ee20b853baf717073ad393dd4aaVikram S. Adve case And: return "and"; 213c105645c16f77ee20b853baf717073ad393dd4aaVikram S. Adve case Or : return "or"; 214c105645c16f77ee20b853baf717073ad393dd4aaVikram S. Adve case Xor: return "xor"; 215c105645c16f77ee20b853baf717073ad393dd4aaVikram S. Adve 216c105645c16f77ee20b853baf717073ad393dd4aaVikram S. Adve // Memory instructions... 217c105645c16f77ee20b853baf717073ad393dd4aaVikram S. Adve case Alloca: return "alloca"; 218c105645c16f77ee20b853baf717073ad393dd4aaVikram S. Adve case Load: return "load"; 219c105645c16f77ee20b853baf717073ad393dd4aaVikram S. Adve case Store: return "store"; 220ff03048c1350fcc4fda1ef6d6c57252f3a950854Eli Friedman case AtomicCmpXchg: return "cmpxchg"; 221ff03048c1350fcc4fda1ef6d6c57252f3a950854Eli Friedman case AtomicRMW: return "atomicrmw"; 22247f3513dd574535aeb40c9eb11134f0899e92269Eli Friedman case Fence: return "fence"; 223c105645c16f77ee20b853baf717073ad393dd4aaVikram S. Adve case GetElementPtr: return "getelementptr"; 224fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman 2253da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer // Convert instructions... 2263da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer case Trunc: return "trunc"; 2273da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer case ZExt: return "zext"; 2283da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer case SExt: return "sext"; 2293da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer case FPTrunc: return "fptrunc"; 2303da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer case FPExt: return "fpext"; 2313da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer case FPToUI: return "fptoui"; 2323da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer case FPToSI: return "fptosi"; 2333da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer case UIToFP: return "uitofp"; 2343da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer case SIToFP: return "sitofp"; 2353da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer case IntToPtr: return "inttoptr"; 2363da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer case PtrToInt: return "ptrtoint"; 2373da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer case BitCast: return "bitcast"; 2383da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer 239c105645c16f77ee20b853baf717073ad393dd4aaVikram S. Adve // Other instructions... 24074f1642bc1c2981e4573c9f0690d91b6a9bbc68cReid Spencer case ICmp: return "icmp"; 24174f1642bc1c2981e4573c9f0690d91b6a9bbc68cReid Spencer case FCmp: return "fcmp"; 2423da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer case PHI: return "phi"; 2433da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer case Select: return "select"; 2443da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer case Call: return "call"; 2453da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer case Shl: return "shl"; 2463da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer case LShr: return "lshr"; 2473da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer case AShr: return "ashr"; 2483da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer case VAArg: return "va_arg"; 249b52ee7f5ffd189c4f21ab227c6a24061ef3378fcRobert Bocchino case ExtractElement: return "extractelement"; 2503da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer case InsertElement: return "insertelement"; 2513da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer case ShuffleVector: return "shufflevector"; 25274b5e07cc4a65989eb43bdc016d51db3c192691fMatthijs Kooijman case ExtractValue: return "extractvalue"; 25374b5e07cc4a65989eb43bdc016d51db3c192691fMatthijs Kooijman case InsertValue: return "insertvalue"; 254e6e8826870bee3facb04f950f0bd725f8a88623dBill Wendling case LandingPad: return "landingpad"; 2558f77daef04355c00b78b645f5aae5694e7a8b631Chris Lattner 256c105645c16f77ee20b853baf717073ad393dd4aaVikram S. Adve default: return "<Invalid operator> "; 257c105645c16f77ee20b853baf717073ad393dd4aaVikram S. Adve } 258c105645c16f77ee20b853baf717073ad393dd4aaVikram S. Adve} 259f2da7241f590aaae128ecce7732c6094084df2b6Chris Lattner 26038f14553939e574becab6ea1e0b055d31293b0cfChris Lattner/// isIdenticalTo - Return true if the specified instruction is exactly 26138f14553939e574becab6ea1e0b055d31293b0cfChris Lattner/// identical to the current one. This means that all operands match and any 26238f14553939e574becab6ea1e0b055d31293b0cfChris Lattner/// extra information (e.g. load is volatile) agree. 263e3a0884ddf9009f040d80f5fde3b6d5d70b0fa13Chris Lattnerbool Instruction::isIdenticalTo(const Instruction *I) const { 26475b0edae7275436c1255c10eb98e5b0dffc978f6Dan Gohman return isIdenticalToWhenDefined(I) && 26558cfa3b13752579c86cf85270d49f9ced0942f2fDan Gohman SubclassOptionalData == I->SubclassOptionalData; 26658cfa3b13752579c86cf85270d49f9ced0942f2fDan Gohman} 26758cfa3b13752579c86cf85270d49f9ced0942f2fDan Gohman 26875b0edae7275436c1255c10eb98e5b0dffc978f6Dan Gohman/// isIdenticalToWhenDefined - This is like isIdenticalTo, except that it 26958cfa3b13752579c86cf85270d49f9ced0942f2fDan Gohman/// ignores the SubclassOptionalData flags, which specify conditions 27058cfa3b13752579c86cf85270d49f9ced0942f2fDan Gohman/// under which the instruction's result is undefined. 27158cfa3b13752579c86cf85270d49f9ced0942f2fDan Gohmanbool Instruction::isIdenticalToWhenDefined(const Instruction *I) const { 27238f14553939e574becab6ea1e0b055d31293b0cfChris Lattner if (getOpcode() != I->getOpcode() || 27338f14553939e574becab6ea1e0b055d31293b0cfChris Lattner getNumOperands() != I->getNumOperands() || 27438f14553939e574becab6ea1e0b055d31293b0cfChris Lattner getType() != I->getType()) 27538f14553939e574becab6ea1e0b055d31293b0cfChris Lattner return false; 27638f14553939e574becab6ea1e0b055d31293b0cfChris Lattner 27738f14553939e574becab6ea1e0b055d31293b0cfChris Lattner // We have two instructions of identical opcode and #operands. Check to see 27838f14553939e574becab6ea1e0b055d31293b0cfChris Lattner // if all operands are the same. 27938f14553939e574becab6ea1e0b055d31293b0cfChris Lattner for (unsigned i = 0, e = getNumOperands(); i != e; ++i) 28038f14553939e574becab6ea1e0b055d31293b0cfChris Lattner if (getOperand(i) != I->getOperand(i)) 28138f14553939e574becab6ea1e0b055d31293b0cfChris Lattner return false; 28238f14553939e574becab6ea1e0b055d31293b0cfChris Lattner 28338f14553939e574becab6ea1e0b055d31293b0cfChris Lattner // Check special state that is a part of some instructions. 28438f14553939e574becab6ea1e0b055d31293b0cfChris Lattner if (const LoadInst *LI = dyn_cast<LoadInst>(this)) 2859a8af451a39a38351d87866a1d39e594a0c3341fDan Gohman return LI->isVolatile() == cast<LoadInst>(I)->isVolatile() && 286e5e771263a71536ab2794ae726f43e7ccd2720acEli Friedman LI->getAlignment() == cast<LoadInst>(I)->getAlignment() && 287e5e771263a71536ab2794ae726f43e7ccd2720acEli Friedman LI->getOrdering() == cast<LoadInst>(I)->getOrdering() && 288e5e771263a71536ab2794ae726f43e7ccd2720acEli Friedman LI->getSynchScope() == cast<LoadInst>(I)->getSynchScope(); 28938f14553939e574becab6ea1e0b055d31293b0cfChris Lattner if (const StoreInst *SI = dyn_cast<StoreInst>(this)) 2909a8af451a39a38351d87866a1d39e594a0c3341fDan Gohman return SI->isVolatile() == cast<StoreInst>(I)->isVolatile() && 291e5e771263a71536ab2794ae726f43e7ccd2720acEli Friedman SI->getAlignment() == cast<StoreInst>(I)->getAlignment() && 292e5e771263a71536ab2794ae726f43e7ccd2720acEli Friedman SI->getOrdering() == cast<StoreInst>(I)->getOrdering() && 293e5e771263a71536ab2794ae726f43e7ccd2720acEli Friedman SI->getSynchScope() == cast<StoreInst>(I)->getSynchScope(); 294e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer if (const CmpInst *CI = dyn_cast<CmpInst>(this)) 295e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer return CI->getPredicate() == cast<CmpInst>(I)->getPredicate(); 296e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer if (const CallInst *CI = dyn_cast<CallInst>(this)) 2979a8af451a39a38351d87866a1d39e594a0c3341fDan Gohman return CI->isTailCall() == cast<CallInst>(I)->isTailCall() && 2989a8af451a39a38351d87866a1d39e594a0c3341fDan Gohman CI->getCallingConv() == cast<CallInst>(I)->getCallingConv() && 299f6c63c23203ca4c4aa89efa2bff722bb479cfe3cNick Lewycky CI->getAttributes() == cast<CallInst>(I)->getAttributes(); 3009a8af451a39a38351d87866a1d39e594a0c3341fDan Gohman if (const InvokeInst *CI = dyn_cast<InvokeInst>(this)) 30141fe88b26dab59bedc9e45a43752245b9ec3496aNick Lewycky return CI->getCallingConv() == cast<InvokeInst>(I)->getCallingConv() && 302f6c63c23203ca4c4aa89efa2bff722bb479cfe3cNick Lewycky CI->getAttributes() == cast<InvokeInst>(I)->getAttributes(); 303fc6d3a49867cd38954dc40936a88f1907252c6d2Jay Foad if (const InsertValueInst *IVI = dyn_cast<InsertValueInst>(this)) 304fc6d3a49867cd38954dc40936a88f1907252c6d2Jay Foad return IVI->getIndices() == cast<InsertValueInst>(I)->getIndices(); 305fc6d3a49867cd38954dc40936a88f1907252c6d2Jay Foad if (const ExtractValueInst *EVI = dyn_cast<ExtractValueInst>(this)) 306fc6d3a49867cd38954dc40936a88f1907252c6d2Jay Foad return EVI->getIndices() == cast<ExtractValueInst>(I)->getIndices(); 3078a552bb85a5e9a6c250c0a899941fbd3ae7b5006Eli Friedman if (const FenceInst *FI = dyn_cast<FenceInst>(this)) 3088a552bb85a5e9a6c250c0a899941fbd3ae7b5006Eli Friedman return FI->getOrdering() == cast<FenceInst>(FI)->getOrdering() && 3098a552bb85a5e9a6c250c0a899941fbd3ae7b5006Eli Friedman FI->getSynchScope() == cast<FenceInst>(FI)->getSynchScope(); 31055ba816883842e793cdeb32fcb805c4e011b527fEli Friedman if (const AtomicCmpXchgInst *CXI = dyn_cast<AtomicCmpXchgInst>(this)) 31155ba816883842e793cdeb32fcb805c4e011b527fEli Friedman return CXI->isVolatile() == cast<AtomicCmpXchgInst>(I)->isVolatile() && 31255ba816883842e793cdeb32fcb805c4e011b527fEli Friedman CXI->getOrdering() == cast<AtomicCmpXchgInst>(I)->getOrdering() && 31355ba816883842e793cdeb32fcb805c4e011b527fEli Friedman CXI->getSynchScope() == cast<AtomicCmpXchgInst>(I)->getSynchScope(); 31455ba816883842e793cdeb32fcb805c4e011b527fEli Friedman if (const AtomicRMWInst *RMWI = dyn_cast<AtomicRMWInst>(this)) 31555ba816883842e793cdeb32fcb805c4e011b527fEli Friedman return RMWI->getOperation() == cast<AtomicRMWInst>(I)->getOperation() && 31655ba816883842e793cdeb32fcb805c4e011b527fEli Friedman RMWI->isVolatile() == cast<AtomicRMWInst>(I)->isVolatile() && 31755ba816883842e793cdeb32fcb805c4e011b527fEli Friedman RMWI->getOrdering() == cast<AtomicRMWInst>(I)->getOrdering() && 31855ba816883842e793cdeb32fcb805c4e011b527fEli Friedman RMWI->getSynchScope() == cast<AtomicRMWInst>(I)->getSynchScope(); 3199df72a93ef27a27c6853eed3ed92c9e0b62c9ca6Joel Jones if (const PHINode *thisPHI = dyn_cast<PHINode>(this)) { 3209df72a93ef27a27c6853eed3ed92c9e0b62c9ca6Joel Jones const PHINode *otherPHI = cast<PHINode>(I); 3219df72a93ef27a27c6853eed3ed92c9e0b62c9ca6Joel Jones for (unsigned i = 0, e = thisPHI->getNumOperands(); i != e; ++i) { 3229df72a93ef27a27c6853eed3ed92c9e0b62c9ca6Joel Jones if (thisPHI->getIncomingBlock(i) != otherPHI->getIncomingBlock(i)) 3239df72a93ef27a27c6853eed3ed92c9e0b62c9ca6Joel Jones return false; 3249df72a93ef27a27c6853eed3ed92c9e0b62c9ca6Joel Jones } 3259df72a93ef27a27c6853eed3ed92c9e0b62c9ca6Joel Jones return true; 3269df72a93ef27a27c6853eed3ed92c9e0b62c9ca6Joel Jones } 327e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer return true; 328e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer} 329e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer 330e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer// isSameOperationAs 331194ae785e1f94619cbdcdcf2921caa6997277d32Dan Gohman// This should be kept in sync with isEquivalentOperation in 332194ae785e1f94619cbdcdcf2921caa6997277d32Dan Gohman// lib/Transforms/IPO/MergeFunctions.cpp. 333ec4e85e3364f50802f2007e4b1e23661d4610366Hal Finkelbool Instruction::isSameOperationAs(const Instruction *I, 334ec4e85e3364f50802f2007e4b1e23661d4610366Hal Finkel unsigned flags) const { 335ec4e85e3364f50802f2007e4b1e23661d4610366Hal Finkel bool IgnoreAlignment = flags & CompareIgnoringAlignment; 336ec4e85e3364f50802f2007e4b1e23661d4610366Hal Finkel bool UseScalarTypes = flags & CompareUsingScalarTypes; 337ec4e85e3364f50802f2007e4b1e23661d4610366Hal Finkel 338194ae785e1f94619cbdcdcf2921caa6997277d32Dan Gohman if (getOpcode() != I->getOpcode() || 339194ae785e1f94619cbdcdcf2921caa6997277d32Dan Gohman getNumOperands() != I->getNumOperands() || 340ec4e85e3364f50802f2007e4b1e23661d4610366Hal Finkel (UseScalarTypes ? 341ec4e85e3364f50802f2007e4b1e23661d4610366Hal Finkel getType()->getScalarType() != I->getType()->getScalarType() : 342ec4e85e3364f50802f2007e4b1e23661d4610366Hal Finkel getType() != I->getType())) 343e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer return false; 344e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer 345e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer // We have two instructions of identical opcode and #operands. Check to see 346e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer // if all operands are the same type 347e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer for (unsigned i = 0, e = getNumOperands(); i != e; ++i) 348ec4e85e3364f50802f2007e4b1e23661d4610366Hal Finkel if (UseScalarTypes ? 349ec4e85e3364f50802f2007e4b1e23661d4610366Hal Finkel getOperand(i)->getType()->getScalarType() != 350ec4e85e3364f50802f2007e4b1e23661d4610366Hal Finkel I->getOperand(i)->getType()->getScalarType() : 351ec4e85e3364f50802f2007e4b1e23661d4610366Hal Finkel getOperand(i)->getType() != I->getOperand(i)->getType()) 352e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer return false; 353e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer 354e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer // Check special state that is a part of some instructions. 355e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer if (const LoadInst *LI = dyn_cast<LoadInst>(this)) 3569a8af451a39a38351d87866a1d39e594a0c3341fDan Gohman return LI->isVolatile() == cast<LoadInst>(I)->isVolatile() && 357ec4e85e3364f50802f2007e4b1e23661d4610366Hal Finkel (LI->getAlignment() == cast<LoadInst>(I)->getAlignment() || 358ec4e85e3364f50802f2007e4b1e23661d4610366Hal Finkel IgnoreAlignment) && 359e5e771263a71536ab2794ae726f43e7ccd2720acEli Friedman LI->getOrdering() == cast<LoadInst>(I)->getOrdering() && 360e5e771263a71536ab2794ae726f43e7ccd2720acEli Friedman LI->getSynchScope() == cast<LoadInst>(I)->getSynchScope(); 361e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer if (const StoreInst *SI = dyn_cast<StoreInst>(this)) 3629a8af451a39a38351d87866a1d39e594a0c3341fDan Gohman return SI->isVolatile() == cast<StoreInst>(I)->isVolatile() && 363ec4e85e3364f50802f2007e4b1e23661d4610366Hal Finkel (SI->getAlignment() == cast<StoreInst>(I)->getAlignment() || 364ec4e85e3364f50802f2007e4b1e23661d4610366Hal Finkel IgnoreAlignment) && 365e5e771263a71536ab2794ae726f43e7ccd2720acEli Friedman SI->getOrdering() == cast<StoreInst>(I)->getOrdering() && 366e5e771263a71536ab2794ae726f43e7ccd2720acEli Friedman SI->getSynchScope() == cast<StoreInst>(I)->getSynchScope(); 367e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer if (const CmpInst *CI = dyn_cast<CmpInst>(this)) 368e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer return CI->getPredicate() == cast<CmpInst>(I)->getPredicate(); 369ddb6db4fa11d06217d01d8431596131abdfb7ef0Chris Lattner if (const CallInst *CI = dyn_cast<CallInst>(this)) 3709a8af451a39a38351d87866a1d39e594a0c3341fDan Gohman return CI->isTailCall() == cast<CallInst>(I)->isTailCall() && 3719a8af451a39a38351d87866a1d39e594a0c3341fDan Gohman CI->getCallingConv() == cast<CallInst>(I)->getCallingConv() && 372f6c63c23203ca4c4aa89efa2bff722bb479cfe3cNick Lewycky CI->getAttributes() == cast<CallInst>(I)->getAttributes(); 3739a8af451a39a38351d87866a1d39e594a0c3341fDan Gohman if (const InvokeInst *CI = dyn_cast<InvokeInst>(this)) 37441fe88b26dab59bedc9e45a43752245b9ec3496aNick Lewycky return CI->getCallingConv() == cast<InvokeInst>(I)->getCallingConv() && 375f6c63c23203ca4c4aa89efa2bff722bb479cfe3cNick Lewycky CI->getAttributes() == 376f6c63c23203ca4c4aa89efa2bff722bb479cfe3cNick Lewycky cast<InvokeInst>(I)->getAttributes(); 377fc6d3a49867cd38954dc40936a88f1907252c6d2Jay Foad if (const InsertValueInst *IVI = dyn_cast<InsertValueInst>(this)) 378fc6d3a49867cd38954dc40936a88f1907252c6d2Jay Foad return IVI->getIndices() == cast<InsertValueInst>(I)->getIndices(); 379fc6d3a49867cd38954dc40936a88f1907252c6d2Jay Foad if (const ExtractValueInst *EVI = dyn_cast<ExtractValueInst>(this)) 380fc6d3a49867cd38954dc40936a88f1907252c6d2Jay Foad return EVI->getIndices() == cast<ExtractValueInst>(I)->getIndices(); 3818a552bb85a5e9a6c250c0a899941fbd3ae7b5006Eli Friedman if (const FenceInst *FI = dyn_cast<FenceInst>(this)) 38255ba816883842e793cdeb32fcb805c4e011b527fEli Friedman return FI->getOrdering() == cast<FenceInst>(I)->getOrdering() && 38355ba816883842e793cdeb32fcb805c4e011b527fEli Friedman FI->getSynchScope() == cast<FenceInst>(I)->getSynchScope(); 38455ba816883842e793cdeb32fcb805c4e011b527fEli Friedman if (const AtomicCmpXchgInst *CXI = dyn_cast<AtomicCmpXchgInst>(this)) 38555ba816883842e793cdeb32fcb805c4e011b527fEli Friedman return CXI->isVolatile() == cast<AtomicCmpXchgInst>(I)->isVolatile() && 38655ba816883842e793cdeb32fcb805c4e011b527fEli Friedman CXI->getOrdering() == cast<AtomicCmpXchgInst>(I)->getOrdering() && 38755ba816883842e793cdeb32fcb805c4e011b527fEli Friedman CXI->getSynchScope() == cast<AtomicCmpXchgInst>(I)->getSynchScope(); 38855ba816883842e793cdeb32fcb805c4e011b527fEli Friedman if (const AtomicRMWInst *RMWI = dyn_cast<AtomicRMWInst>(this)) 38955ba816883842e793cdeb32fcb805c4e011b527fEli Friedman return RMWI->getOperation() == cast<AtomicRMWInst>(I)->getOperation() && 39055ba816883842e793cdeb32fcb805c4e011b527fEli Friedman RMWI->isVolatile() == cast<AtomicRMWInst>(I)->isVolatile() && 39155ba816883842e793cdeb32fcb805c4e011b527fEli Friedman RMWI->getOrdering() == cast<AtomicRMWInst>(I)->getOrdering() && 39255ba816883842e793cdeb32fcb805c4e011b527fEli Friedman RMWI->getSynchScope() == cast<AtomicRMWInst>(I)->getSynchScope(); 393e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer 39438f14553939e574becab6ea1e0b055d31293b0cfChris Lattner return true; 39538f14553939e574becab6ea1e0b055d31293b0cfChris Lattner} 39638f14553939e574becab6ea1e0b055d31293b0cfChris Lattner 3977ae40e7d8ac43feaa5b3107e02c9b3a77fe729f2Chris Lattner/// isUsedOutsideOfBlock - Return true if there are any uses of I outside of the 3987ae40e7d8ac43feaa5b3107e02c9b3a77fe729f2Chris Lattner/// specified block. Note that PHI nodes are considered to evaluate their 3997ae40e7d8ac43feaa5b3107e02c9b3a77fe729f2Chris Lattner/// operands in the corresponding predecessor block. 4007ae40e7d8ac43feaa5b3107e02c9b3a77fe729f2Chris Lattnerbool Instruction::isUsedOutsideOfBlock(const BasicBlock *BB) const { 40160ad781c61815ca5b8dc2a45a102e1c8af65992fGabor Greif for (const_use_iterator UI = use_begin(), E = use_end(); UI != E; ++UI) { 4027ae40e7d8ac43feaa5b3107e02c9b3a77fe729f2Chris Lattner // PHI nodes uses values in the corresponding predecessor block. For other 4037ae40e7d8ac43feaa5b3107e02c9b3a77fe729f2Chris Lattner // instructions, just check to see whether the parent of the use matches up. 404a8b9df7bd96e0b0bc6dec448d30b7d72180b6595Gabor Greif const User *U = *UI; 405a8b9df7bd96e0b0bc6dec448d30b7d72180b6595Gabor Greif const PHINode *PN = dyn_cast<PHINode>(U); 4067ae40e7d8ac43feaa5b3107e02c9b3a77fe729f2Chris Lattner if (PN == 0) { 407a8b9df7bd96e0b0bc6dec448d30b7d72180b6595Gabor Greif if (cast<Instruction>(U)->getParent() != BB) 4087ae40e7d8ac43feaa5b3107e02c9b3a77fe729f2Chris Lattner return true; 4097ae40e7d8ac43feaa5b3107e02c9b3a77fe729f2Chris Lattner continue; 4107ae40e7d8ac43feaa5b3107e02c9b3a77fe729f2Chris Lattner } 411a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 412a36791da41cf4f635e50077b290676b873836bdaGabor Greif if (PN->getIncomingBlock(UI) != BB) 4137ae40e7d8ac43feaa5b3107e02c9b3a77fe729f2Chris Lattner return true; 4147ae40e7d8ac43feaa5b3107e02c9b3a77fe729f2Chris Lattner } 415a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar return false; 4167ae40e7d8ac43feaa5b3107e02c9b3a77fe729f2Chris Lattner} 4177ae40e7d8ac43feaa5b3107e02c9b3a77fe729f2Chris Lattner 418d96288a2ff188bb1fb1b86fb89b1ac82f6310a5cChris Lattner/// mayReadFromMemory - Return true if this instruction may read memory. 419d96288a2ff188bb1fb1b86fb89b1ac82f6310a5cChris Lattner/// 420d96288a2ff188bb1fb1b86fb89b1ac82f6310a5cChris Lattnerbool Instruction::mayReadFromMemory() const { 421d96288a2ff188bb1fb1b86fb89b1ac82f6310a5cChris Lattner switch (getOpcode()) { 422d96288a2ff188bb1fb1b86fb89b1ac82f6310a5cChris Lattner default: return false; 423d96288a2ff188bb1fb1b86fb89b1ac82f6310a5cChris Lattner case Instruction::VAArg: 424748118d8aa8a66597437e6970ab389c988bbdb8bChris Lattner case Instruction::Load: 4258a552bb85a5e9a6c250c0a899941fbd3ae7b5006Eli Friedman case Instruction::Fence: // FIXME: refine definition of mayReadFromMemory 42655ba816883842e793cdeb32fcb805c4e011b527fEli Friedman case Instruction::AtomicCmpXchg: 42755ba816883842e793cdeb32fcb805c4e011b527fEli Friedman case Instruction::AtomicRMW: 428d96288a2ff188bb1fb1b86fb89b1ac82f6310a5cChris Lattner return true; 429d96288a2ff188bb1fb1b86fb89b1ac82f6310a5cChris Lattner case Instruction::Call: 430d96288a2ff188bb1fb1b86fb89b1ac82f6310a5cChris Lattner return !cast<CallInst>(this)->doesNotAccessMemory(); 431d96288a2ff188bb1fb1b86fb89b1ac82f6310a5cChris Lattner case Instruction::Invoke: 432d96288a2ff188bb1fb1b86fb89b1ac82f6310a5cChris Lattner return !cast<InvokeInst>(this)->doesNotAccessMemory(); 433748118d8aa8a66597437e6970ab389c988bbdb8bChris Lattner case Instruction::Store: 434e5e771263a71536ab2794ae726f43e7ccd2720acEli Friedman return !cast<StoreInst>(this)->isUnordered(); 435d96288a2ff188bb1fb1b86fb89b1ac82f6310a5cChris Lattner } 436d96288a2ff188bb1fb1b86fb89b1ac82f6310a5cChris Lattner} 4377ae40e7d8ac43feaa5b3107e02c9b3a77fe729f2Chris Lattner 438bb5493d9fa8845f002613ac013087b347a052357Chris Lattner/// mayWriteToMemory - Return true if this instruction may modify memory. 439bb5493d9fa8845f002613ac013087b347a052357Chris Lattner/// 440bb5493d9fa8845f002613ac013087b347a052357Chris Lattnerbool Instruction::mayWriteToMemory() const { 441bb5493d9fa8845f002613ac013087b347a052357Chris Lattner switch (getOpcode()) { 442bb5493d9fa8845f002613ac013087b347a052357Chris Lattner default: return false; 4438a552bb85a5e9a6c250c0a899941fbd3ae7b5006Eli Friedman case Instruction::Fence: // FIXME: refine definition of mayWriteToMemory 444a3355ffb3d30d19d226bbb75707991c60f236e37Duncan Sands case Instruction::Store: 445bb5493d9fa8845f002613ac013087b347a052357Chris Lattner case Instruction::VAArg: 44655ba816883842e793cdeb32fcb805c4e011b527fEli Friedman case Instruction::AtomicCmpXchg: 44755ba816883842e793cdeb32fcb805c4e011b527fEli Friedman case Instruction::AtomicRMW: 448bb5493d9fa8845f002613ac013087b347a052357Chris Lattner return true; 449bb5493d9fa8845f002613ac013087b347a052357Chris Lattner case Instruction::Call: 450a3355ffb3d30d19d226bbb75707991c60f236e37Duncan Sands return !cast<CallInst>(this)->onlyReadsMemory(); 451d96288a2ff188bb1fb1b86fb89b1ac82f6310a5cChris Lattner case Instruction::Invoke: 452d96288a2ff188bb1fb1b86fb89b1ac82f6310a5cChris Lattner return !cast<InvokeInst>(this)->onlyReadsMemory(); 453bb5493d9fa8845f002613ac013087b347a052357Chris Lattner case Instruction::Load: 454e5e771263a71536ab2794ae726f43e7ccd2720acEli Friedman return !cast<LoadInst>(this)->isUnordered(); 455bb5493d9fa8845f002613ac013087b347a052357Chris Lattner } 456bb5493d9fa8845f002613ac013087b347a052357Chris Lattner} 457f2da7241f590aaae128ecce7732c6094084df2b6Chris Lattner 4587af1c78b98d2df7d0ab9154461ca3d835706716eDuncan Sandsbool Instruction::mayThrow() const { 4597af1c78b98d2df7d0ab9154461ca3d835706716eDuncan Sands if (const CallInst *CI = dyn_cast<CallInst>(this)) 4607af1c78b98d2df7d0ab9154461ca3d835706716eDuncan Sands return !CI->doesNotThrow(); 46155fdb4eec073fe7fd480ffa7e2a3b05acfacd5b1Bill Wendling return isa<ResumeInst>(this); 4627af1c78b98d2df7d0ab9154461ca3d835706716eDuncan Sands} 4637af1c78b98d2df7d0ab9154461ca3d835706716eDuncan Sands 46403544ec2a43fab162d25cf44627d1d08430bcccdNadav Rotembool Instruction::mayReturn() const { 46503544ec2a43fab162d25cf44627d1d08430bcccdNadav Rotem if (const CallInst *CI = dyn_cast<CallInst>(this)) 46603544ec2a43fab162d25cf44627d1d08430bcccdNadav Rotem return !CI->doesNotReturn(); 46703544ec2a43fab162d25cf44627d1d08430bcccdNadav Rotem return true; 46803544ec2a43fab162d25cf44627d1d08430bcccdNadav Rotem} 46903544ec2a43fab162d25cf44627d1d08430bcccdNadav Rotem 470f2da7241f590aaae128ecce7732c6094084df2b6Chris Lattner/// isAssociative - Return true if the instruction is associative: 471f2da7241f590aaae128ecce7732c6094084df2b6Chris Lattner/// 472ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman/// Associative operators satisfy: x op (y op z) === (x op y) op z 473f2da7241f590aaae128ecce7732c6094084df2b6Chris Lattner/// 474ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman/// In LLVM, the Add, Mul, And, Or, and Xor operators are associative. 475f2da7241f590aaae128ecce7732c6094084df2b6Chris Lattner/// 4760d7ce5ffa4aa853b75e1015c62e27bd9f23ef73bDuncan Sandsbool Instruction::isAssociative(unsigned Opcode) { 477ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman return Opcode == And || Opcode == Or || Opcode == Xor || 478ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman Opcode == Add || Opcode == Mul; 479f2da7241f590aaae128ecce7732c6094084df2b6Chris Lattner} 480f2da7241f590aaae128ecce7732c6094084df2b6Chris Lattner 4819b7f6f2de89a321f7eae5e942c8668cb50acfd1dShuxin Yangbool Instruction::isAssociative() const { 4829b7f6f2de89a321f7eae5e942c8668cb50acfd1dShuxin Yang unsigned Opcode = getOpcode(); 4839b7f6f2de89a321f7eae5e942c8668cb50acfd1dShuxin Yang if (isAssociative(Opcode)) 4849b7f6f2de89a321f7eae5e942c8668cb50acfd1dShuxin Yang return true; 4859b7f6f2de89a321f7eae5e942c8668cb50acfd1dShuxin Yang 4869b7f6f2de89a321f7eae5e942c8668cb50acfd1dShuxin Yang switch (Opcode) { 4879b7f6f2de89a321f7eae5e942c8668cb50acfd1dShuxin Yang case FMul: 4889b7f6f2de89a321f7eae5e942c8668cb50acfd1dShuxin Yang case FAdd: 4899b7f6f2de89a321f7eae5e942c8668cb50acfd1dShuxin Yang return cast<FPMathOperator>(this)->hasUnsafeAlgebra(); 4909b7f6f2de89a321f7eae5e942c8668cb50acfd1dShuxin Yang default: 4919b7f6f2de89a321f7eae5e942c8668cb50acfd1dShuxin Yang return false; 4929b7f6f2de89a321f7eae5e942c8668cb50acfd1dShuxin Yang } 4939b7f6f2de89a321f7eae5e942c8668cb50acfd1dShuxin Yang} 4949b7f6f2de89a321f7eae5e942c8668cb50acfd1dShuxin Yang 495f2da7241f590aaae128ecce7732c6094084df2b6Chris Lattner/// isCommutative - Return true if the instruction is commutative: 496f2da7241f590aaae128ecce7732c6094084df2b6Chris Lattner/// 4976b63452c3ad26678b32f93dbca55902a313ee4e9Misha Brukman/// Commutative operators satisfy: (x op y) === (y op x) 498f2da7241f590aaae128ecce7732c6094084df2b6Chris Lattner/// 499f2da7241f590aaae128ecce7732c6094084df2b6Chris Lattner/// In LLVM, these are the associative operators, plus SetEQ and SetNE, when 500f2da7241f590aaae128ecce7732c6094084df2b6Chris Lattner/// applied to any type. 501f2da7241f590aaae128ecce7732c6094084df2b6Chris Lattner/// 502f2da7241f590aaae128ecce7732c6094084df2b6Chris Lattnerbool Instruction::isCommutative(unsigned op) { 503f2da7241f590aaae128ecce7732c6094084df2b6Chris Lattner switch (op) { 504f2da7241f590aaae128ecce7732c6094084df2b6Chris Lattner case Add: 505ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case FAdd: 506f2da7241f590aaae128ecce7732c6094084df2b6Chris Lattner case Mul: 507ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case FMul: 508fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman case And: 509f2da7241f590aaae128ecce7732c6094084df2b6Chris Lattner case Or: 510f2da7241f590aaae128ecce7732c6094084df2b6Chris Lattner case Xor: 511f2da7241f590aaae128ecce7732c6094084df2b6Chris Lattner return true; 512f2da7241f590aaae128ecce7732c6094084df2b6Chris Lattner default: 513f2da7241f590aaae128ecce7732c6094084df2b6Chris Lattner return false; 514f2da7241f590aaae128ecce7732c6094084df2b6Chris Lattner } 515f2da7241f590aaae128ecce7732c6094084df2b6Chris Lattner} 516741bb0019de9aa28a731b4eef2422a3397f99cd0Tanya Lattner 517c038a7833565ecf92a699371d448135a097c9e2fDuncan Sands/// isIdempotent - Return true if the instruction is idempotent: 518c038a7833565ecf92a699371d448135a097c9e2fDuncan Sands/// 519c038a7833565ecf92a699371d448135a097c9e2fDuncan Sands/// Idempotent operators satisfy: x op x === x 520c038a7833565ecf92a699371d448135a097c9e2fDuncan Sands/// 521c038a7833565ecf92a699371d448135a097c9e2fDuncan Sands/// In LLVM, the And and Or operators are idempotent. 522c038a7833565ecf92a699371d448135a097c9e2fDuncan Sands/// 523c038a7833565ecf92a699371d448135a097c9e2fDuncan Sandsbool Instruction::isIdempotent(unsigned Opcode) { 524c038a7833565ecf92a699371d448135a097c9e2fDuncan Sands return Opcode == And || Opcode == Or; 525c038a7833565ecf92a699371d448135a097c9e2fDuncan Sands} 526c038a7833565ecf92a699371d448135a097c9e2fDuncan Sands 527c038a7833565ecf92a699371d448135a097c9e2fDuncan Sands/// isNilpotent - Return true if the instruction is nilpotent: 528c038a7833565ecf92a699371d448135a097c9e2fDuncan Sands/// 529c038a7833565ecf92a699371d448135a097c9e2fDuncan Sands/// Nilpotent operators satisfy: x op x === Id, 530c038a7833565ecf92a699371d448135a097c9e2fDuncan Sands/// 531c038a7833565ecf92a699371d448135a097c9e2fDuncan Sands/// where Id is the identity for the operator, i.e. a constant such that 532c038a7833565ecf92a699371d448135a097c9e2fDuncan Sands/// x op Id === x and Id op x === x for all x. 533c038a7833565ecf92a699371d448135a097c9e2fDuncan Sands/// 534c038a7833565ecf92a699371d448135a097c9e2fDuncan Sands/// In LLVM, the Xor operator is nilpotent. 535c038a7833565ecf92a699371d448135a097c9e2fDuncan Sands/// 536c038a7833565ecf92a699371d448135a097c9e2fDuncan Sandsbool Instruction::isNilpotent(unsigned Opcode) { 537c038a7833565ecf92a699371d448135a097c9e2fDuncan Sands return Opcode == Xor; 538c038a7833565ecf92a699371d448135a097c9e2fDuncan Sands} 539c038a7833565ecf92a699371d448135a097c9e2fDuncan Sands 54050b6e33584f4e4cf75c7795b1f1a90731861c825Devang PatelInstruction *Instruction::clone() const { 54150b6e33584f4e4cf75c7795b1f1a90731861c825Devang Patel Instruction *New = clone_impl(); 54250b6e33584f4e4cf75c7795b1f1a90731861c825Devang Patel New->SubclassOptionalData = SubclassOptionalData; 543508b19a5a41a4b82be4ae71e6ea5c691bea99b96Chris Lattner if (!hasMetadata()) 544508b19a5a41a4b82be4ae71e6ea5c691bea99b96Chris Lattner return New; 545407a6169b729c72c3a7ddb01b8454ab0b4f6897cMichael Ilseman 546508b19a5a41a4b82be4ae71e6ea5c691bea99b96Chris Lattner // Otherwise, enumerate and copy over metadata from the old instruction to the 547508b19a5a41a4b82be4ae71e6ea5c691bea99b96Chris Lattner // new one. 548508b19a5a41a4b82be4ae71e6ea5c691bea99b96Chris Lattner SmallVector<std::pair<unsigned, MDNode*>, 4> TheMDs; 5494baa510f48000308251a0d7c6be491d11c20d30bChris Lattner getAllMetadataOtherThanDebugLoc(TheMDs); 550508b19a5a41a4b82be4ae71e6ea5c691bea99b96Chris Lattner for (unsigned i = 0, e = TheMDs.size(); i != e; ++i) 551508b19a5a41a4b82be4ae71e6ea5c691bea99b96Chris Lattner New->setMetadata(TheMDs[i].first, TheMDs[i].second); 552407a6169b729c72c3a7ddb01b8454ab0b4f6897cMichael Ilseman 5534baa510f48000308251a0d7c6be491d11c20d30bChris Lattner New->setDebugLoc(getDebugLoc()); 55450b6e33584f4e4cf75c7795b1f1a90731861c825Devang Patel return New; 55550b6e33584f4e4cf75c7795b1f1a90731861c825Devang Patel} 556