InstructionSimplify.cpp revision 6844c8ea5a67e551be7106d6b7b9e1a64eecbe51
19f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner//===- InstructionSimplify.cpp - Fold instruction operands ----------------===// 29f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner// 39f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner// The LLVM Compiler Infrastructure 49f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner// 59f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner// This file is distributed under the University of Illinois Open Source 69f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner// License. See LICENSE.TXT for details. 79f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner// 89f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner//===----------------------------------------------------------------------===// 99f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner// 109f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner// This file implements routines for folding instructions into simpler forms 119f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner// that do not require creating new instructions. For example, this does 129f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner// constant folding, and can handle identities like (X&0)->0. 139f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner// 149f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner//===----------------------------------------------------------------------===// 159f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner 169f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner#include "llvm/Analysis/InstructionSimplify.h" 179f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner#include "llvm/Analysis/ConstantFolding.h" 1840d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner#include "llvm/Support/ValueHandle.h" 199f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner#include "llvm/Instructions.h" 20d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner#include "llvm/Support/PatternMatch.h" 219f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattnerusing namespace llvm; 22d06094f0682f2ede03caff4892b1a57469896d48Chris Lattnerusing namespace llvm::PatternMatch; 239f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner 248aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner/// SimplifyAddInst - Given operands for an Add, see if we can 25d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner/// fold the result. If not, this returns null. 268aee8efc0c2e387faa7dae39fdf613a22889b566Chris LattnerValue *llvm::SimplifyAddInst(Value *Op0, Value *Op1, bool isNSW, bool isNUW, 27d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner const TargetData *TD) { 28d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (Constant *CLHS = dyn_cast<Constant>(Op0)) { 29d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (Constant *CRHS = dyn_cast<Constant>(Op1)) { 30d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner Constant *Ops[] = { CLHS, CRHS }; 318aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner return ConstantFoldInstOperands(Instruction::Add, CLHS->getType(), 328aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner Ops, 2, TD); 338aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner } 348aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner 358aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner // Canonicalize the constant to the RHS. 368aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner std::swap(Op0, Op1); 378aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner } 388aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner 398aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner if (Constant *Op1C = dyn_cast<Constant>(Op1)) { 408aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner // X + undef -> undef 418aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner if (isa<UndefValue>(Op1C)) 428aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner return Op1C; 438aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner 448aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner // X + 0 --> X 458aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner if (Op1C->isNullValue()) 468aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner return Op0; 478aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner } 488aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner 498aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner // FIXME: Could pull several more out of instcombine. 508aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner return 0; 518aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner} 528aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner 538aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner/// SimplifyAndInst - Given operands for an And, see if we can 548aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner/// fold the result. If not, this returns null. 558aee8efc0c2e387faa7dae39fdf613a22889b566Chris LattnerValue *llvm::SimplifyAndInst(Value *Op0, Value *Op1, const TargetData *TD) { 568aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner if (Constant *CLHS = dyn_cast<Constant>(Op0)) { 578aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner if (Constant *CRHS = dyn_cast<Constant>(Op1)) { 588aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner Constant *Ops[] = { CLHS, CRHS }; 59d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return ConstantFoldInstOperands(Instruction::And, CLHS->getType(), 60d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner Ops, 2, TD); 61d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner } 62d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner 63d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // Canonicalize the constant to the RHS. 64d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner std::swap(Op0, Op1); 65d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner } 66d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner 67d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // X & undef -> 0 68d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (isa<UndefValue>(Op1)) 69d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Constant::getNullValue(Op0->getType()); 70d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner 71d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // X & X = X 72d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (Op0 == Op1) 73d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Op0; 74d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner 75d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // X & <0,0> = <0,0> 76d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (isa<ConstantAggregateZero>(Op1)) 77d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Op1; 78d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner 79d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // X & <-1,-1> = X 80d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (ConstantVector *CP = dyn_cast<ConstantVector>(Op1)) 81d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (CP->isAllOnesValue()) 82d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Op0; 83d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner 84d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (ConstantInt *Op1CI = dyn_cast<ConstantInt>(Op1)) { 85d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // X & 0 = 0 86d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (Op1CI->isZero()) 87d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Op1CI; 88d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // X & -1 = X 89d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (Op1CI->isAllOnesValue()) 90d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Op0; 91d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner } 92d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner 93d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // A & ~A = ~A & A = 0 94d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner Value *A, *B; 9570ce6d0819ffd5822bb176fffe94bcf29a1deda4Chris Lattner if ((match(Op0, m_Not(m_Value(A))) && A == Op1) || 9670ce6d0819ffd5822bb176fffe94bcf29a1deda4Chris Lattner (match(Op1, m_Not(m_Value(A))) && A == Op0)) 97d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Constant::getNullValue(Op0->getType()); 98d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner 99d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // (A | ?) & A = A 100d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (match(Op0, m_Or(m_Value(A), m_Value(B))) && 101d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner (A == Op1 || B == Op1)) 102d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Op1; 103d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner 104d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // A & (A | ?) = A 105d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (match(Op1, m_Or(m_Value(A), m_Value(B))) && 106d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner (A == Op0 || B == Op0)) 107d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Op0; 108d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner 1096844c8ea5a67e551be7106d6b7b9e1a64eecbe51Benjamin Kramer // (A & B) & A -> A & B 1106844c8ea5a67e551be7106d6b7b9e1a64eecbe51Benjamin Kramer if (match(Op0, m_And(m_Value(A), m_Value(B))) && 1116844c8ea5a67e551be7106d6b7b9e1a64eecbe51Benjamin Kramer (A == Op1 || B == Op1)) 1126844c8ea5a67e551be7106d6b7b9e1a64eecbe51Benjamin Kramer return Op0; 1136844c8ea5a67e551be7106d6b7b9e1a64eecbe51Benjamin Kramer 1146844c8ea5a67e551be7106d6b7b9e1a64eecbe51Benjamin Kramer // A & (A & B) -> A & B 1156844c8ea5a67e551be7106d6b7b9e1a64eecbe51Benjamin Kramer if (match(Op1, m_And(m_Value(A), m_Value(B))) && 1166844c8ea5a67e551be7106d6b7b9e1a64eecbe51Benjamin Kramer (A == Op0 || B == Op0)) 1176844c8ea5a67e551be7106d6b7b9e1a64eecbe51Benjamin Kramer return Op1; 1186844c8ea5a67e551be7106d6b7b9e1a64eecbe51Benjamin Kramer 119d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return 0; 120d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner} 1219f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner 122d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner/// SimplifyOrInst - Given operands for an Or, see if we can 1239f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner/// fold the result. If not, this returns null. 1248aee8efc0c2e387faa7dae39fdf613a22889b566Chris LattnerValue *llvm::SimplifyOrInst(Value *Op0, Value *Op1, const TargetData *TD) { 125d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (Constant *CLHS = dyn_cast<Constant>(Op0)) { 126d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (Constant *CRHS = dyn_cast<Constant>(Op1)) { 127d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner Constant *Ops[] = { CLHS, CRHS }; 128d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return ConstantFoldInstOperands(Instruction::Or, CLHS->getType(), 129d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner Ops, 2, TD); 130d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner } 131d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner 132d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // Canonicalize the constant to the RHS. 133d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner std::swap(Op0, Op1); 134d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner } 135d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner 136d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // X | undef -> -1 137d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (isa<UndefValue>(Op1)) 138d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Constant::getAllOnesValue(Op0->getType()); 139d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner 140d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // X | X = X 141d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (Op0 == Op1) 142d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Op0; 143d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner 144d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // X | <0,0> = X 145d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (isa<ConstantAggregateZero>(Op1)) 146d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Op0; 147d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner 148d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // X | <-1,-1> = <-1,-1> 149d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (ConstantVector *CP = dyn_cast<ConstantVector>(Op1)) 150d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (CP->isAllOnesValue()) 151d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Op1; 152d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner 153d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (ConstantInt *Op1CI = dyn_cast<ConstantInt>(Op1)) { 154d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // X | 0 = X 155d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (Op1CI->isZero()) 156d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Op0; 157d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // X | -1 = -1 158d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (Op1CI->isAllOnesValue()) 159d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Op1CI; 160d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner } 161d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner 162d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // A | ~A = ~A | A = -1 163d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner Value *A, *B; 16470ce6d0819ffd5822bb176fffe94bcf29a1deda4Chris Lattner if ((match(Op0, m_Not(m_Value(A))) && A == Op1) || 16570ce6d0819ffd5822bb176fffe94bcf29a1deda4Chris Lattner (match(Op1, m_Not(m_Value(A))) && A == Op0)) 166d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Constant::getAllOnesValue(Op0->getType()); 167d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner 168d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // (A & ?) | A = A 169d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (match(Op0, m_And(m_Value(A), m_Value(B))) && 170d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner (A == Op1 || B == Op1)) 171d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Op1; 172d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner 173d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // A | (A & ?) = A 174d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (match(Op1, m_And(m_Value(A), m_Value(B))) && 175d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner (A == Op0 || B == Op0)) 176d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Op0; 177d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner 1786844c8ea5a67e551be7106d6b7b9e1a64eecbe51Benjamin Kramer // (A | B) | A -> A | B 1796844c8ea5a67e551be7106d6b7b9e1a64eecbe51Benjamin Kramer if (match(Op0, m_Or(m_Value(A), m_Value(B))) && 1806844c8ea5a67e551be7106d6b7b9e1a64eecbe51Benjamin Kramer (A == Op1 || B == Op1)) 1816844c8ea5a67e551be7106d6b7b9e1a64eecbe51Benjamin Kramer return Op0; 1826844c8ea5a67e551be7106d6b7b9e1a64eecbe51Benjamin Kramer 1836844c8ea5a67e551be7106d6b7b9e1a64eecbe51Benjamin Kramer // A | (A | B) -> A | B 1846844c8ea5a67e551be7106d6b7b9e1a64eecbe51Benjamin Kramer if (match(Op1, m_Or(m_Value(A), m_Value(B))) && 1856844c8ea5a67e551be7106d6b7b9e1a64eecbe51Benjamin Kramer (A == Op0 || B == Op0)) 1866844c8ea5a67e551be7106d6b7b9e1a64eecbe51Benjamin Kramer return Op1; 1876844c8ea5a67e551be7106d6b7b9e1a64eecbe51Benjamin Kramer 1889f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner return 0; 1899f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner} 1909f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner 191d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner 192210c5d4880b525e064088b6fec713260128c16ebChris Lattnerstatic const Type *GetCompareTy(Value *Op) { 193210c5d4880b525e064088b6fec713260128c16ebChris Lattner return CmpInst::makeCmpResultType(Op->getType()); 194210c5d4880b525e064088b6fec713260128c16ebChris Lattner} 195210c5d4880b525e064088b6fec713260128c16ebChris Lattner 1969f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner 1979dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner/// SimplifyICmpInst - Given operands for an ICmpInst, see if we can 1989dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner/// fold the result. If not, this returns null. 1999dbb42944c4d7caddab21016b24cca31019a3fafChris LattnerValue *llvm::SimplifyICmpInst(unsigned Predicate, Value *LHS, Value *RHS, 2009dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner const TargetData *TD) { 2019f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner CmpInst::Predicate Pred = (CmpInst::Predicate)Predicate; 2029dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner assert(CmpInst::isIntPredicate(Pred) && "Not an integer compare!"); 2039f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner 204d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (Constant *CLHS = dyn_cast<Constant>(LHS)) { 2058f73deaa8732a556046bf4ac6207be55972e3b74Chris Lattner if (Constant *CRHS = dyn_cast<Constant>(RHS)) 2068f73deaa8732a556046bf4ac6207be55972e3b74Chris Lattner return ConstantFoldCompareInstOperands(Pred, CLHS, CRHS, TD); 207d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner 208d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // If we have a constant, make sure it is on the RHS. 209d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner std::swap(LHS, RHS); 210d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner Pred = CmpInst::getSwappedPredicate(Pred); 211d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner } 2129f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner 213210c5d4880b525e064088b6fec713260128c16ebChris Lattner // ITy - This is the return type of the compare we're considering. 214210c5d4880b525e064088b6fec713260128c16ebChris Lattner const Type *ITy = GetCompareTy(LHS); 215210c5d4880b525e064088b6fec713260128c16ebChris Lattner 216210c5d4880b525e064088b6fec713260128c16ebChris Lattner // icmp X, X -> true/false 217c8e14b3d37b80abb6adb4b831af0452d9ecbf2b2Chris Lattner // X icmp undef -> true/false. For example, icmp ugt %X, undef -> false 218c8e14b3d37b80abb6adb4b831af0452d9ecbf2b2Chris Lattner // because X could be 0. 219c8e14b3d37b80abb6adb4b831af0452d9ecbf2b2Chris Lattner if (LHS == RHS || isa<UndefValue>(RHS)) 220210c5d4880b525e064088b6fec713260128c16ebChris Lattner return ConstantInt::get(ITy, CmpInst::isTrueWhenEqual(Pred)); 221210c5d4880b525e064088b6fec713260128c16ebChris Lattner 222210c5d4880b525e064088b6fec713260128c16ebChris Lattner // icmp <global/alloca*/null>, <global/alloca*/null> - Global/Stack value 223210c5d4880b525e064088b6fec713260128c16ebChris Lattner // addresses never equal each other! We already know that Op0 != Op1. 224210c5d4880b525e064088b6fec713260128c16ebChris Lattner if ((isa<GlobalValue>(LHS) || isa<AllocaInst>(LHS) || 225210c5d4880b525e064088b6fec713260128c16ebChris Lattner isa<ConstantPointerNull>(LHS)) && 226210c5d4880b525e064088b6fec713260128c16ebChris Lattner (isa<GlobalValue>(RHS) || isa<AllocaInst>(RHS) || 227210c5d4880b525e064088b6fec713260128c16ebChris Lattner isa<ConstantPointerNull>(RHS))) 228210c5d4880b525e064088b6fec713260128c16ebChris Lattner return ConstantInt::get(ITy, CmpInst::isFalseWhenEqual(Pred)); 229210c5d4880b525e064088b6fec713260128c16ebChris Lattner 230210c5d4880b525e064088b6fec713260128c16ebChris Lattner // See if we are doing a comparison with a constant. 231210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (ConstantInt *CI = dyn_cast<ConstantInt>(RHS)) { 232210c5d4880b525e064088b6fec713260128c16ebChris Lattner // If we have an icmp le or icmp ge instruction, turn it into the 233210c5d4880b525e064088b6fec713260128c16ebChris Lattner // appropriate icmp lt or icmp gt instruction. This allows us to rely on 234210c5d4880b525e064088b6fec713260128c16ebChris Lattner // them being folded in the code below. 235210c5d4880b525e064088b6fec713260128c16ebChris Lattner switch (Pred) { 236210c5d4880b525e064088b6fec713260128c16ebChris Lattner default: break; 237210c5d4880b525e064088b6fec713260128c16ebChris Lattner case ICmpInst::ICMP_ULE: 238210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (CI->isMaxValue(false)) // A <=u MAX -> TRUE 239210c5d4880b525e064088b6fec713260128c16ebChris Lattner return ConstantInt::getTrue(CI->getContext()); 240210c5d4880b525e064088b6fec713260128c16ebChris Lattner break; 241210c5d4880b525e064088b6fec713260128c16ebChris Lattner case ICmpInst::ICMP_SLE: 242210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (CI->isMaxValue(true)) // A <=s MAX -> TRUE 243210c5d4880b525e064088b6fec713260128c16ebChris Lattner return ConstantInt::getTrue(CI->getContext()); 244210c5d4880b525e064088b6fec713260128c16ebChris Lattner break; 245210c5d4880b525e064088b6fec713260128c16ebChris Lattner case ICmpInst::ICMP_UGE: 246210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (CI->isMinValue(false)) // A >=u MIN -> TRUE 247210c5d4880b525e064088b6fec713260128c16ebChris Lattner return ConstantInt::getTrue(CI->getContext()); 248210c5d4880b525e064088b6fec713260128c16ebChris Lattner break; 249210c5d4880b525e064088b6fec713260128c16ebChris Lattner case ICmpInst::ICMP_SGE: 250210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (CI->isMinValue(true)) // A >=s MIN -> TRUE 251210c5d4880b525e064088b6fec713260128c16ebChris Lattner return ConstantInt::getTrue(CI->getContext()); 252210c5d4880b525e064088b6fec713260128c16ebChris Lattner break; 253210c5d4880b525e064088b6fec713260128c16ebChris Lattner } 254210c5d4880b525e064088b6fec713260128c16ebChris Lattner } 255210c5d4880b525e064088b6fec713260128c16ebChris Lattner 256210c5d4880b525e064088b6fec713260128c16ebChris Lattner 2579dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner return 0; 2589dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner} 2599dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner 2609dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner/// SimplifyFCmpInst - Given operands for an FCmpInst, see if we can 2619dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner/// fold the result. If not, this returns null. 2629dbb42944c4d7caddab21016b24cca31019a3fafChris LattnerValue *llvm::SimplifyFCmpInst(unsigned Predicate, Value *LHS, Value *RHS, 2639dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner const TargetData *TD) { 2649dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner CmpInst::Predicate Pred = (CmpInst::Predicate)Predicate; 2659dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner assert(CmpInst::isFPPredicate(Pred) && "Not an FP compare!"); 2669dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner 267d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (Constant *CLHS = dyn_cast<Constant>(LHS)) { 2689dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner if (Constant *CRHS = dyn_cast<Constant>(RHS)) 2699dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner return ConstantFoldCompareInstOperands(Pred, CLHS, CRHS, TD); 270d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner 271d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // If we have a constant, make sure it is on the RHS. 272d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner std::swap(LHS, RHS); 273d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner Pred = CmpInst::getSwappedPredicate(Pred); 274d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner } 2759dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner 276210c5d4880b525e064088b6fec713260128c16ebChris Lattner // Fold trivial predicates. 277210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (Pred == FCmpInst::FCMP_FALSE) 278210c5d4880b525e064088b6fec713260128c16ebChris Lattner return ConstantInt::get(GetCompareTy(LHS), 0); 279210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (Pred == FCmpInst::FCMP_TRUE) 280210c5d4880b525e064088b6fec713260128c16ebChris Lattner return ConstantInt::get(GetCompareTy(LHS), 1); 281210c5d4880b525e064088b6fec713260128c16ebChris Lattner 282210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (isa<UndefValue>(RHS)) // fcmp pred X, undef -> undef 283210c5d4880b525e064088b6fec713260128c16ebChris Lattner return UndefValue::get(GetCompareTy(LHS)); 284210c5d4880b525e064088b6fec713260128c16ebChris Lattner 285210c5d4880b525e064088b6fec713260128c16ebChris Lattner // fcmp x,x -> true/false. Not all compares are foldable. 286210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (LHS == RHS) { 287210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (CmpInst::isTrueWhenEqual(Pred)) 288210c5d4880b525e064088b6fec713260128c16ebChris Lattner return ConstantInt::get(GetCompareTy(LHS), 1); 289210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (CmpInst::isFalseWhenEqual(Pred)) 290210c5d4880b525e064088b6fec713260128c16ebChris Lattner return ConstantInt::get(GetCompareTy(LHS), 0); 291210c5d4880b525e064088b6fec713260128c16ebChris Lattner } 292210c5d4880b525e064088b6fec713260128c16ebChris Lattner 293210c5d4880b525e064088b6fec713260128c16ebChris Lattner // Handle fcmp with constant RHS 294210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (Constant *RHSC = dyn_cast<Constant>(RHS)) { 295210c5d4880b525e064088b6fec713260128c16ebChris Lattner // If the constant is a nan, see if we can fold the comparison based on it. 296210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (ConstantFP *CFP = dyn_cast<ConstantFP>(RHSC)) { 297210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (CFP->getValueAPF().isNaN()) { 298210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (FCmpInst::isOrdered(Pred)) // True "if ordered and foo" 299210c5d4880b525e064088b6fec713260128c16ebChris Lattner return ConstantInt::getFalse(CFP->getContext()); 300210c5d4880b525e064088b6fec713260128c16ebChris Lattner assert(FCmpInst::isUnordered(Pred) && 301210c5d4880b525e064088b6fec713260128c16ebChris Lattner "Comparison must be either ordered or unordered!"); 302210c5d4880b525e064088b6fec713260128c16ebChris Lattner // True if unordered. 303210c5d4880b525e064088b6fec713260128c16ebChris Lattner return ConstantInt::getTrue(CFP->getContext()); 304210c5d4880b525e064088b6fec713260128c16ebChris Lattner } 3056b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman // Check whether the constant is an infinity. 3066b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman if (CFP->getValueAPF().isInfinity()) { 3076b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman if (CFP->getValueAPF().isNegative()) { 3086b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman switch (Pred) { 3096b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman case FCmpInst::FCMP_OLT: 3106b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman // No value is ordered and less than negative infinity. 3116b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman return ConstantInt::getFalse(CFP->getContext()); 3126b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman case FCmpInst::FCMP_UGE: 3136b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman // All values are unordered with or at least negative infinity. 3146b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman return ConstantInt::getTrue(CFP->getContext()); 3156b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman default: 3166b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman break; 3176b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman } 3186b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman } else { 3196b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman switch (Pred) { 3206b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman case FCmpInst::FCMP_OGT: 3216b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman // No value is ordered and greater than infinity. 3226b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman return ConstantInt::getFalse(CFP->getContext()); 3236b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman case FCmpInst::FCMP_ULE: 3246b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman // All values are unordered with and at most infinity. 3256b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman return ConstantInt::getTrue(CFP->getContext()); 3266b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman default: 3276b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman break; 3286b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman } 3296b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman } 3306b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman } 331210c5d4880b525e064088b6fec713260128c16ebChris Lattner } 332210c5d4880b525e064088b6fec713260128c16ebChris Lattner } 333210c5d4880b525e064088b6fec713260128c16ebChris Lattner 3349f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner return 0; 3359f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner} 3369f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner 337047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner/// SimplifySelectInst - Given operands for a SelectInst, see if we can fold 338047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner/// the result. If not, this returns null. 339047542669a20505fc7c5f2d93caa5610aa3db2c5Chris LattnerValue *llvm::SimplifySelectInst(Value *CondVal, Value *TrueVal, Value *FalseVal, 340047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner const TargetData *TD) { 341047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner // select true, X, Y -> X 342047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner // select false, X, Y -> Y 343047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner if (ConstantInt *CB = dyn_cast<ConstantInt>(CondVal)) 344047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner return CB->getZExtValue() ? TrueVal : FalseVal; 345047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner 346047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner // select C, X, X -> X 347047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner if (TrueVal == FalseVal) 348047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner return TrueVal; 349047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner 350047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner if (isa<UndefValue>(TrueVal)) // select C, undef, X -> X 351047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner return FalseVal; 352047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner if (isa<UndefValue>(FalseVal)) // select C, X, undef -> X 353047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner return TrueVal; 354047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner if (isa<UndefValue>(CondVal)) { // select undef, X, Y -> X or Y 355047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner if (isa<Constant>(TrueVal)) 356047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner return TrueVal; 357047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner return FalseVal; 358047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner } 359047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner 360047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner 361047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner 362047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner return 0; 363047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner} 364047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner 365047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner 366c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner/// SimplifyGEPInst - Given operands for an GetElementPtrInst, see if we can 367c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner/// fold the result. If not, this returns null. 368c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris LattnerValue *llvm::SimplifyGEPInst(Value *const *Ops, unsigned NumOps, 369c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner const TargetData *TD) { 370c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner // getelementptr P -> P. 371c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner if (NumOps == 1) 372c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner return Ops[0]; 373c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner 374c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner // TODO. 375c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner //if (isa<UndefValue>(Ops[0])) 376c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner // return UndefValue::get(GEP.getType()); 377c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner 378c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner // getelementptr P, 0 -> P. 379c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner if (NumOps == 2) 380c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner if (ConstantInt *C = dyn_cast<ConstantInt>(Ops[1])) 381c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner if (C->isZero()) 382c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner return Ops[0]; 383c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner 384c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner // Check to see if this is constant foldable. 385c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner for (unsigned i = 0; i != NumOps; ++i) 386c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner if (!isa<Constant>(Ops[i])) 387c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner return 0; 388c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner 389c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner return ConstantExpr::getGetElementPtr(cast<Constant>(Ops[0]), 390c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner (Constant *const*)Ops+1, NumOps-1); 391c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner} 392c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner 393c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner 394d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner//=== Helper functions for higher up the class hierarchy. 3959dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner 396d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner/// SimplifyBinOp - Given operands for a BinaryOperator, see if we can 397d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner/// fold the result. If not, this returns null. 398d06094f0682f2ede03caff4892b1a57469896d48Chris LattnerValue *llvm::SimplifyBinOp(unsigned Opcode, Value *LHS, Value *RHS, 399d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner const TargetData *TD) { 400d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner switch (Opcode) { 401d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner case Instruction::And: return SimplifyAndInst(LHS, RHS, TD); 402d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner case Instruction::Or: return SimplifyOrInst(LHS, RHS, TD); 403d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner default: 404d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (Constant *CLHS = dyn_cast<Constant>(LHS)) 405d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (Constant *CRHS = dyn_cast<Constant>(RHS)) { 406d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner Constant *COps[] = {CLHS, CRHS}; 407d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return ConstantFoldInstOperands(Opcode, LHS->getType(), COps, 2, TD); 408d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner } 409d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return 0; 410d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner } 411d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner} 4129dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner 4139dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner/// SimplifyCmpInst - Given operands for a CmpInst, see if we can 4149dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner/// fold the result. 4159dbb42944c4d7caddab21016b24cca31019a3fafChris LattnerValue *llvm::SimplifyCmpInst(unsigned Predicate, Value *LHS, Value *RHS, 4169dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner const TargetData *TD) { 4179dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner if (CmpInst::isIntPredicate((CmpInst::Predicate)Predicate)) 4189dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner return SimplifyICmpInst(Predicate, LHS, RHS, TD); 4199dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner return SimplifyFCmpInst(Predicate, LHS, RHS, TD); 4209dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner} 4219dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner 422e34537856a544c83513e390ac9552a8bc3823346Chris Lattner 423e34537856a544c83513e390ac9552a8bc3823346Chris Lattner/// SimplifyInstruction - See if we can compute a simplified version of this 424e34537856a544c83513e390ac9552a8bc3823346Chris Lattner/// instruction. If not, this returns null. 425e34537856a544c83513e390ac9552a8bc3823346Chris LattnerValue *llvm::SimplifyInstruction(Instruction *I, const TargetData *TD) { 426e34537856a544c83513e390ac9552a8bc3823346Chris Lattner switch (I->getOpcode()) { 427e34537856a544c83513e390ac9552a8bc3823346Chris Lattner default: 428e34537856a544c83513e390ac9552a8bc3823346Chris Lattner return ConstantFoldInstruction(I, TD); 4298aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner case Instruction::Add: 4308aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner return SimplifyAddInst(I->getOperand(0), I->getOperand(1), 4318aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner cast<BinaryOperator>(I)->hasNoSignedWrap(), 4328aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner cast<BinaryOperator>(I)->hasNoUnsignedWrap(), TD); 433e34537856a544c83513e390ac9552a8bc3823346Chris Lattner case Instruction::And: 434e34537856a544c83513e390ac9552a8bc3823346Chris Lattner return SimplifyAndInst(I->getOperand(0), I->getOperand(1), TD); 435e34537856a544c83513e390ac9552a8bc3823346Chris Lattner case Instruction::Or: 436e34537856a544c83513e390ac9552a8bc3823346Chris Lattner return SimplifyOrInst(I->getOperand(0), I->getOperand(1), TD); 437e34537856a544c83513e390ac9552a8bc3823346Chris Lattner case Instruction::ICmp: 438e34537856a544c83513e390ac9552a8bc3823346Chris Lattner return SimplifyICmpInst(cast<ICmpInst>(I)->getPredicate(), 439e34537856a544c83513e390ac9552a8bc3823346Chris Lattner I->getOperand(0), I->getOperand(1), TD); 440e34537856a544c83513e390ac9552a8bc3823346Chris Lattner case Instruction::FCmp: 441e34537856a544c83513e390ac9552a8bc3823346Chris Lattner return SimplifyFCmpInst(cast<FCmpInst>(I)->getPredicate(), 442e34537856a544c83513e390ac9552a8bc3823346Chris Lattner I->getOperand(0), I->getOperand(1), TD); 443047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner case Instruction::Select: 444047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner return SimplifySelectInst(I->getOperand(0), I->getOperand(1), 445047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner I->getOperand(2), TD); 446c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner case Instruction::GetElementPtr: { 447c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner SmallVector<Value*, 8> Ops(I->op_begin(), I->op_end()); 448c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner return SimplifyGEPInst(&Ops[0], Ops.size(), TD); 449c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner } 450e34537856a544c83513e390ac9552a8bc3823346Chris Lattner } 451e34537856a544c83513e390ac9552a8bc3823346Chris Lattner} 452e34537856a544c83513e390ac9552a8bc3823346Chris Lattner 45340d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner/// ReplaceAndSimplifyAllUses - Perform From->replaceAllUsesWith(To) and then 45440d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner/// delete the From instruction. In addition to a basic RAUW, this does a 45540d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner/// recursive simplification of the newly formed instructions. This catches 45640d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner/// things where one simplification exposes other opportunities. This only 45740d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner/// simplifies and deletes scalar operations, it does not change the CFG. 45840d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner/// 45940d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattnervoid llvm::ReplaceAndSimplifyAllUses(Instruction *From, Value *To, 46040d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner const TargetData *TD) { 46140d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner assert(From != To && "ReplaceAndSimplifyAllUses(X,X) is not valid!"); 46240d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner 463d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner // FromHandle/ToHandle - This keeps a WeakVH on the from/to values so that 464d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner // we can know if it gets deleted out from under us or replaced in a 465d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner // recursive simplification. 46640d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner WeakVH FromHandle(From); 467d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner WeakVH ToHandle(To); 468e2f93131fb78cf5650db9ca78b4aec3cc45f00beEli Friedman 46940d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner while (!From->use_empty()) { 47040d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner // Update the instruction to use the new value. 471d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner Use &TheUse = From->use_begin().getUse(); 472d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner Instruction *User = cast<Instruction>(TheUse.getUser()); 473d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner TheUse = To; 474d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner 475d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner // Check to see if the instruction can be folded due to the operand 476d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner // replacement. For example changing (or X, Y) into (or X, -1) can replace 477d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner // the 'or' with -1. 478d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner Value *SimplifiedVal; 479d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner { 480d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner // Sanity check to make sure 'User' doesn't dangle across 481d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner // SimplifyInstruction. 482d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner AssertingVH<> UserHandle(User); 48340d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner 484d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner SimplifiedVal = SimplifyInstruction(User, TD); 485d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner if (SimplifiedVal == 0) continue; 48640d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner } 487d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner 488d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner // Recursively simplify this user to the new value. 489d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner ReplaceAndSimplifyAllUses(User, SimplifiedVal, TD); 490d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner From = dyn_cast_or_null<Instruction>((Value*)FromHandle); 491d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner To = ToHandle; 492d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner 493d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner assert(ToHandle && "To value deleted by recursive simplification?"); 494d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner 495d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner // If the recursive simplification ended up revisiting and deleting 496d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner // 'From' then we're done. 497d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner if (From == 0) 498d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner return; 49940d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner } 500d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner 501d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner // If 'From' has value handles referring to it, do a real RAUW to update them. 502d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner From->replaceAllUsesWith(To); 503d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner 50440d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner From->eraseFromParent(); 50540d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner} 50640d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner 507