InstructionSimplify.cpp revision 92826def593df7a422c7b07f09342febce81ddd3
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 } 2551ac7c9979a2d723ff4649ffad58df02732872a5fDuncan Sands 2561ac7c9979a2d723ff4649ffad58df02732872a5fDuncan Sands // If the comparison is with the result of a select instruction, check whether 2571ac7c9979a2d723ff4649ffad58df02732872a5fDuncan Sands // comparing with either branch of the select always yields the same value. 2581ac7c9979a2d723ff4649ffad58df02732872a5fDuncan Sands if (isa<SelectInst>(LHS) || isa<SelectInst>(RHS)) { 2591ac7c9979a2d723ff4649ffad58df02732872a5fDuncan Sands // Make sure the select is on the LHS. 2601ac7c9979a2d723ff4649ffad58df02732872a5fDuncan Sands if (!isa<SelectInst>(LHS)) { 2611ac7c9979a2d723ff4649ffad58df02732872a5fDuncan Sands std::swap(LHS, RHS); 2621ac7c9979a2d723ff4649ffad58df02732872a5fDuncan Sands Pred = CmpInst::getSwappedPredicate(Pred); 2631ac7c9979a2d723ff4649ffad58df02732872a5fDuncan Sands } 2641ac7c9979a2d723ff4649ffad58df02732872a5fDuncan Sands SelectInst *SI = cast<SelectInst>(LHS); 2651ac7c9979a2d723ff4649ffad58df02732872a5fDuncan Sands // Now that we have "icmp select(cond, TV, FV), RHS", analyse it. 2661ac7c9979a2d723ff4649ffad58df02732872a5fDuncan Sands // Does "icmp TV, RHS" simplify? 2671ac7c9979a2d723ff4649ffad58df02732872a5fDuncan Sands if (Value *TCmp = SimplifyICmpInst(Pred, SI->getTrueValue(), RHS, TD)) 2681ac7c9979a2d723ff4649ffad58df02732872a5fDuncan Sands // It does! Does "icmp FV, RHS" simplify? 2691ac7c9979a2d723ff4649ffad58df02732872a5fDuncan Sands if (Value *FCmp = SimplifyICmpInst(Pred, SI->getFalseValue(), RHS, TD)) 2701ac7c9979a2d723ff4649ffad58df02732872a5fDuncan Sands // It does! If they simplified to the same value, then use it as the 2711ac7c9979a2d723ff4649ffad58df02732872a5fDuncan Sands // result of the original comparison. 2721ac7c9979a2d723ff4649ffad58df02732872a5fDuncan Sands if (TCmp == FCmp) 2731ac7c9979a2d723ff4649ffad58df02732872a5fDuncan Sands return TCmp; 2741ac7c9979a2d723ff4649ffad58df02732872a5fDuncan Sands } 2751ac7c9979a2d723ff4649ffad58df02732872a5fDuncan Sands 2769dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner return 0; 2779dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner} 2789dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner 2799dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner/// SimplifyFCmpInst - Given operands for an FCmpInst, see if we can 2809dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner/// fold the result. If not, this returns null. 2819dbb42944c4d7caddab21016b24cca31019a3fafChris LattnerValue *llvm::SimplifyFCmpInst(unsigned Predicate, Value *LHS, Value *RHS, 2829dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner const TargetData *TD) { 2839dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner CmpInst::Predicate Pred = (CmpInst::Predicate)Predicate; 2849dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner assert(CmpInst::isFPPredicate(Pred) && "Not an FP compare!"); 2859dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner 286d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (Constant *CLHS = dyn_cast<Constant>(LHS)) { 2879dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner if (Constant *CRHS = dyn_cast<Constant>(RHS)) 2889dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner return ConstantFoldCompareInstOperands(Pred, CLHS, CRHS, TD); 289d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner 290d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // If we have a constant, make sure it is on the RHS. 291d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner std::swap(LHS, RHS); 292d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner Pred = CmpInst::getSwappedPredicate(Pred); 293d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner } 2949dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner 295210c5d4880b525e064088b6fec713260128c16ebChris Lattner // Fold trivial predicates. 296210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (Pred == FCmpInst::FCMP_FALSE) 297210c5d4880b525e064088b6fec713260128c16ebChris Lattner return ConstantInt::get(GetCompareTy(LHS), 0); 298210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (Pred == FCmpInst::FCMP_TRUE) 299210c5d4880b525e064088b6fec713260128c16ebChris Lattner return ConstantInt::get(GetCompareTy(LHS), 1); 300210c5d4880b525e064088b6fec713260128c16ebChris Lattner 301210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (isa<UndefValue>(RHS)) // fcmp pred X, undef -> undef 302210c5d4880b525e064088b6fec713260128c16ebChris Lattner return UndefValue::get(GetCompareTy(LHS)); 303210c5d4880b525e064088b6fec713260128c16ebChris Lattner 304210c5d4880b525e064088b6fec713260128c16ebChris Lattner // fcmp x,x -> true/false. Not all compares are foldable. 305210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (LHS == RHS) { 306210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (CmpInst::isTrueWhenEqual(Pred)) 307210c5d4880b525e064088b6fec713260128c16ebChris Lattner return ConstantInt::get(GetCompareTy(LHS), 1); 308210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (CmpInst::isFalseWhenEqual(Pred)) 309210c5d4880b525e064088b6fec713260128c16ebChris Lattner return ConstantInt::get(GetCompareTy(LHS), 0); 310210c5d4880b525e064088b6fec713260128c16ebChris Lattner } 311210c5d4880b525e064088b6fec713260128c16ebChris Lattner 312210c5d4880b525e064088b6fec713260128c16ebChris Lattner // Handle fcmp with constant RHS 313210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (Constant *RHSC = dyn_cast<Constant>(RHS)) { 314210c5d4880b525e064088b6fec713260128c16ebChris Lattner // If the constant is a nan, see if we can fold the comparison based on it. 315210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (ConstantFP *CFP = dyn_cast<ConstantFP>(RHSC)) { 316210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (CFP->getValueAPF().isNaN()) { 317210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (FCmpInst::isOrdered(Pred)) // True "if ordered and foo" 318210c5d4880b525e064088b6fec713260128c16ebChris Lattner return ConstantInt::getFalse(CFP->getContext()); 319210c5d4880b525e064088b6fec713260128c16ebChris Lattner assert(FCmpInst::isUnordered(Pred) && 320210c5d4880b525e064088b6fec713260128c16ebChris Lattner "Comparison must be either ordered or unordered!"); 321210c5d4880b525e064088b6fec713260128c16ebChris Lattner // True if unordered. 322210c5d4880b525e064088b6fec713260128c16ebChris Lattner return ConstantInt::getTrue(CFP->getContext()); 323210c5d4880b525e064088b6fec713260128c16ebChris Lattner } 3246b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman // Check whether the constant is an infinity. 3256b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman if (CFP->getValueAPF().isInfinity()) { 3266b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman if (CFP->getValueAPF().isNegative()) { 3276b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman switch (Pred) { 3286b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman case FCmpInst::FCMP_OLT: 3296b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman // No value is ordered and less than negative infinity. 3306b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman return ConstantInt::getFalse(CFP->getContext()); 3316b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman case FCmpInst::FCMP_UGE: 3326b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman // All values are unordered with or at least negative infinity. 3336b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman return ConstantInt::getTrue(CFP->getContext()); 3346b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman default: 3356b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman break; 3366b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman } 3376b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman } else { 3386b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman switch (Pred) { 3396b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman case FCmpInst::FCMP_OGT: 3406b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman // No value is ordered and greater than infinity. 3416b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman return ConstantInt::getFalse(CFP->getContext()); 3426b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman case FCmpInst::FCMP_ULE: 3436b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman // All values are unordered with and at most infinity. 3446b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman return ConstantInt::getTrue(CFP->getContext()); 3456b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman default: 3466b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman break; 3476b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman } 3486b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman } 3496b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman } 350210c5d4880b525e064088b6fec713260128c16ebChris Lattner } 351210c5d4880b525e064088b6fec713260128c16ebChris Lattner } 352210c5d4880b525e064088b6fec713260128c16ebChris Lattner 35392826def593df7a422c7b07f09342febce81ddd3Duncan Sands // If the comparison is with the result of a select instruction, check whether 35492826def593df7a422c7b07f09342febce81ddd3Duncan Sands // comparing with either branch of the select always yields the same value. 35592826def593df7a422c7b07f09342febce81ddd3Duncan Sands if (isa<SelectInst>(LHS) || isa<SelectInst>(RHS)) { 35692826def593df7a422c7b07f09342febce81ddd3Duncan Sands // Make sure the select is on the LHS. 35792826def593df7a422c7b07f09342febce81ddd3Duncan Sands if (!isa<SelectInst>(LHS)) { 35892826def593df7a422c7b07f09342febce81ddd3Duncan Sands std::swap(LHS, RHS); 35992826def593df7a422c7b07f09342febce81ddd3Duncan Sands Pred = CmpInst::getSwappedPredicate(Pred); 36092826def593df7a422c7b07f09342febce81ddd3Duncan Sands } 36192826def593df7a422c7b07f09342febce81ddd3Duncan Sands SelectInst *SI = cast<SelectInst>(LHS); 36292826def593df7a422c7b07f09342febce81ddd3Duncan Sands // Now that we have "fcmp select(cond, TV, FV), RHS", analyse it. 36392826def593df7a422c7b07f09342febce81ddd3Duncan Sands // Does "fcmp TV, RHS" simplify? 36492826def593df7a422c7b07f09342febce81ddd3Duncan Sands if (Value *TCmp = SimplifyFCmpInst(Pred, SI->getTrueValue(), RHS, TD)) 36592826def593df7a422c7b07f09342febce81ddd3Duncan Sands // It does! Does "fcmp FV, RHS" simplify? 36692826def593df7a422c7b07f09342febce81ddd3Duncan Sands if (Value *FCmp = SimplifyFCmpInst(Pred, SI->getFalseValue(), RHS, TD)) 36792826def593df7a422c7b07f09342febce81ddd3Duncan Sands // It does! If they simplified to the same value, then use it as the 36892826def593df7a422c7b07f09342febce81ddd3Duncan Sands // result of the original comparison. 36992826def593df7a422c7b07f09342febce81ddd3Duncan Sands if (TCmp == FCmp) 37092826def593df7a422c7b07f09342febce81ddd3Duncan Sands return TCmp; 37192826def593df7a422c7b07f09342febce81ddd3Duncan Sands } 37292826def593df7a422c7b07f09342febce81ddd3Duncan Sands 3739f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner return 0; 3749f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner} 3759f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner 376047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner/// SimplifySelectInst - Given operands for a SelectInst, see if we can fold 377047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner/// the result. If not, this returns null. 378047542669a20505fc7c5f2d93caa5610aa3db2c5Chris LattnerValue *llvm::SimplifySelectInst(Value *CondVal, Value *TrueVal, Value *FalseVal, 379047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner const TargetData *TD) { 380047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner // select true, X, Y -> X 381047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner // select false, X, Y -> Y 382047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner if (ConstantInt *CB = dyn_cast<ConstantInt>(CondVal)) 383047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner return CB->getZExtValue() ? TrueVal : FalseVal; 384047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner 385047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner // select C, X, X -> X 386047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner if (TrueVal == FalseVal) 387047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner return TrueVal; 388047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner 389047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner if (isa<UndefValue>(TrueVal)) // select C, undef, X -> X 390047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner return FalseVal; 391047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner if (isa<UndefValue>(FalseVal)) // select C, X, undef -> X 392047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner return TrueVal; 393047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner if (isa<UndefValue>(CondVal)) { // select undef, X, Y -> X or Y 394047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner if (isa<Constant>(TrueVal)) 395047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner return TrueVal; 396047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner return FalseVal; 397047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner } 398047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner 399047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner 400047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner 401047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner return 0; 402047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner} 403047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner 404047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner 405c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner/// SimplifyGEPInst - Given operands for an GetElementPtrInst, see if we can 406c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner/// fold the result. If not, this returns null. 407c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris LattnerValue *llvm::SimplifyGEPInst(Value *const *Ops, unsigned NumOps, 408c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner const TargetData *TD) { 409c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner // getelementptr P -> P. 410c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner if (NumOps == 1) 411c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner return Ops[0]; 412c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner 413c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner // TODO. 414c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner //if (isa<UndefValue>(Ops[0])) 415c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner // return UndefValue::get(GEP.getType()); 416c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner 417c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner // getelementptr P, 0 -> P. 418c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner if (NumOps == 2) 419c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner if (ConstantInt *C = dyn_cast<ConstantInt>(Ops[1])) 420c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner if (C->isZero()) 421c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner return Ops[0]; 422c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner 423c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner // Check to see if this is constant foldable. 424c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner for (unsigned i = 0; i != NumOps; ++i) 425c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner if (!isa<Constant>(Ops[i])) 426c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner return 0; 427c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner 428c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner return ConstantExpr::getGetElementPtr(cast<Constant>(Ops[0]), 429c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner (Constant *const*)Ops+1, NumOps-1); 430c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner} 431c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner 432c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner 433d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner//=== Helper functions for higher up the class hierarchy. 4349dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner 435d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner/// SimplifyBinOp - Given operands for a BinaryOperator, see if we can 436d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner/// fold the result. If not, this returns null. 437d06094f0682f2ede03caff4892b1a57469896d48Chris LattnerValue *llvm::SimplifyBinOp(unsigned Opcode, Value *LHS, Value *RHS, 438d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner const TargetData *TD) { 439d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner switch (Opcode) { 440d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner case Instruction::And: return SimplifyAndInst(LHS, RHS, TD); 441d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner case Instruction::Or: return SimplifyOrInst(LHS, RHS, TD); 442d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner default: 443d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (Constant *CLHS = dyn_cast<Constant>(LHS)) 444d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (Constant *CRHS = dyn_cast<Constant>(RHS)) { 445d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner Constant *COps[] = {CLHS, CRHS}; 446d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return ConstantFoldInstOperands(Opcode, LHS->getType(), COps, 2, TD); 447d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner } 448d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return 0; 449d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner } 450d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner} 4519dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner 4529dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner/// SimplifyCmpInst - Given operands for a CmpInst, see if we can 4539dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner/// fold the result. 4549dbb42944c4d7caddab21016b24cca31019a3fafChris LattnerValue *llvm::SimplifyCmpInst(unsigned Predicate, Value *LHS, Value *RHS, 4559dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner const TargetData *TD) { 4569dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner if (CmpInst::isIntPredicate((CmpInst::Predicate)Predicate)) 4579dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner return SimplifyICmpInst(Predicate, LHS, RHS, TD); 4589dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner return SimplifyFCmpInst(Predicate, LHS, RHS, TD); 4599dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner} 4609dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner 461e34537856a544c83513e390ac9552a8bc3823346Chris Lattner 462e34537856a544c83513e390ac9552a8bc3823346Chris Lattner/// SimplifyInstruction - See if we can compute a simplified version of this 463e34537856a544c83513e390ac9552a8bc3823346Chris Lattner/// instruction. If not, this returns null. 464e34537856a544c83513e390ac9552a8bc3823346Chris LattnerValue *llvm::SimplifyInstruction(Instruction *I, const TargetData *TD) { 465e34537856a544c83513e390ac9552a8bc3823346Chris Lattner switch (I->getOpcode()) { 466e34537856a544c83513e390ac9552a8bc3823346Chris Lattner default: 467e34537856a544c83513e390ac9552a8bc3823346Chris Lattner return ConstantFoldInstruction(I, TD); 4688aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner case Instruction::Add: 4694e282decf3960bfa6b1fe3fd77bb51ff96121515Owen Anderson return SimplifyAddInst(I->getOperand(0), I->getOperand(1), 4704e282decf3960bfa6b1fe3fd77bb51ff96121515Owen Anderson cast<BinaryOperator>(I)->hasNoSignedWrap(), 4714e282decf3960bfa6b1fe3fd77bb51ff96121515Owen Anderson cast<BinaryOperator>(I)->hasNoUnsignedWrap(), TD); 472e34537856a544c83513e390ac9552a8bc3823346Chris Lattner case Instruction::And: 4734e282decf3960bfa6b1fe3fd77bb51ff96121515Owen Anderson return SimplifyAndInst(I->getOperand(0), I->getOperand(1), TD); 474e34537856a544c83513e390ac9552a8bc3823346Chris Lattner case Instruction::Or: 4754e282decf3960bfa6b1fe3fd77bb51ff96121515Owen Anderson return SimplifyOrInst(I->getOperand(0), I->getOperand(1), TD); 476e34537856a544c83513e390ac9552a8bc3823346Chris Lattner case Instruction::ICmp: 4774e282decf3960bfa6b1fe3fd77bb51ff96121515Owen Anderson return SimplifyICmpInst(cast<ICmpInst>(I)->getPredicate(), 4784e282decf3960bfa6b1fe3fd77bb51ff96121515Owen Anderson I->getOperand(0), I->getOperand(1), TD); 479e34537856a544c83513e390ac9552a8bc3823346Chris Lattner case Instruction::FCmp: 4804e282decf3960bfa6b1fe3fd77bb51ff96121515Owen Anderson return SimplifyFCmpInst(cast<FCmpInst>(I)->getPredicate(), 4814e282decf3960bfa6b1fe3fd77bb51ff96121515Owen Anderson I->getOperand(0), I->getOperand(1), TD); 482047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner case Instruction::Select: 4834e282decf3960bfa6b1fe3fd77bb51ff96121515Owen Anderson return SimplifySelectInst(I->getOperand(0), I->getOperand(1), 484047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner I->getOperand(2), TD); 485c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner case Instruction::GetElementPtr: { 486c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner SmallVector<Value*, 8> Ops(I->op_begin(), I->op_end()); 4874e282decf3960bfa6b1fe3fd77bb51ff96121515Owen Anderson return SimplifyGEPInst(&Ops[0], Ops.size(), TD); 488c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner } 489e34537856a544c83513e390ac9552a8bc3823346Chris Lattner } 490e34537856a544c83513e390ac9552a8bc3823346Chris Lattner} 491e34537856a544c83513e390ac9552a8bc3823346Chris Lattner 49240d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner/// ReplaceAndSimplifyAllUses - Perform From->replaceAllUsesWith(To) and then 49340d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner/// delete the From instruction. In addition to a basic RAUW, this does a 49440d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner/// recursive simplification of the newly formed instructions. This catches 49540d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner/// things where one simplification exposes other opportunities. This only 49640d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner/// simplifies and deletes scalar operations, it does not change the CFG. 49740d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner/// 49840d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattnervoid llvm::ReplaceAndSimplifyAllUses(Instruction *From, Value *To, 49940d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner const TargetData *TD) { 50040d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner assert(From != To && "ReplaceAndSimplifyAllUses(X,X) is not valid!"); 50140d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner 502d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner // FromHandle/ToHandle - This keeps a WeakVH on the from/to values so that 503d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner // we can know if it gets deleted out from under us or replaced in a 504d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner // recursive simplification. 50540d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner WeakVH FromHandle(From); 506d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner WeakVH ToHandle(To); 507e2f93131fb78cf5650db9ca78b4aec3cc45f00beEli Friedman 50840d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner while (!From->use_empty()) { 50940d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner // Update the instruction to use the new value. 510d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner Use &TheUse = From->use_begin().getUse(); 511d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner Instruction *User = cast<Instruction>(TheUse.getUser()); 512d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner TheUse = To; 513d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner 514d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner // Check to see if the instruction can be folded due to the operand 515d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner // replacement. For example changing (or X, Y) into (or X, -1) can replace 516d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner // the 'or' with -1. 517d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner Value *SimplifiedVal; 518d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner { 519d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner // Sanity check to make sure 'User' doesn't dangle across 520d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner // SimplifyInstruction. 521d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner AssertingVH<> UserHandle(User); 52240d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner 523d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner SimplifiedVal = SimplifyInstruction(User, TD); 524d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner if (SimplifiedVal == 0) continue; 52540d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner } 526d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner 527d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner // Recursively simplify this user to the new value. 528d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner ReplaceAndSimplifyAllUses(User, SimplifiedVal, TD); 529d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner From = dyn_cast_or_null<Instruction>((Value*)FromHandle); 530d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner To = ToHandle; 531d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner 532d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner assert(ToHandle && "To value deleted by recursive simplification?"); 533d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner 534d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner // If the recursive simplification ended up revisiting and deleting 535d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner // 'From' then we're done. 536d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner if (From == 0) 537d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner return; 53840d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner } 539d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner 540d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner // If 'From' has value handles referring to it, do a real RAUW to update them. 541d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner From->replaceAllUsesWith(To); 542d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner 54340d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner From->eraseFromParent(); 54440d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner} 54540d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner 546