InstructionSimplify.cpp revision 6b617a7213e159097a7e5c7216ed9b04921de4e1
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 109d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return 0; 110d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner} 1119f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner 112d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner/// SimplifyOrInst - Given operands for an Or, see if we can 1139f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner/// fold the result. If not, this returns null. 1148aee8efc0c2e387faa7dae39fdf613a22889b566Chris LattnerValue *llvm::SimplifyOrInst(Value *Op0, Value *Op1, const TargetData *TD) { 115d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (Constant *CLHS = dyn_cast<Constant>(Op0)) { 116d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (Constant *CRHS = dyn_cast<Constant>(Op1)) { 117d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner Constant *Ops[] = { CLHS, CRHS }; 118d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return ConstantFoldInstOperands(Instruction::Or, CLHS->getType(), 119d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner Ops, 2, TD); 120d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner } 121d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner 122d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // Canonicalize the constant to the RHS. 123d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner std::swap(Op0, Op1); 124d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner } 125d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner 126d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // X | undef -> -1 127d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (isa<UndefValue>(Op1)) 128d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Constant::getAllOnesValue(Op0->getType()); 129d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner 130d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // X | X = X 131d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (Op0 == Op1) 132d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Op0; 133d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner 134d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // X | <0,0> = X 135d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (isa<ConstantAggregateZero>(Op1)) 136d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Op0; 137d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner 138d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // X | <-1,-1> = <-1,-1> 139d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (ConstantVector *CP = dyn_cast<ConstantVector>(Op1)) 140d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (CP->isAllOnesValue()) 141d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Op1; 142d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner 143d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (ConstantInt *Op1CI = dyn_cast<ConstantInt>(Op1)) { 144d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // X | 0 = X 145d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (Op1CI->isZero()) 146d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Op0; 147d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // X | -1 = -1 148d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (Op1CI->isAllOnesValue()) 149d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Op1CI; 150d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner } 151d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner 152d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // A | ~A = ~A | A = -1 153d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner Value *A, *B; 15470ce6d0819ffd5822bb176fffe94bcf29a1deda4Chris Lattner if ((match(Op0, m_Not(m_Value(A))) && A == Op1) || 15570ce6d0819ffd5822bb176fffe94bcf29a1deda4Chris Lattner (match(Op1, m_Not(m_Value(A))) && A == Op0)) 156d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Constant::getAllOnesValue(Op0->getType()); 157d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner 158d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // (A & ?) | A = A 159d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (match(Op0, m_And(m_Value(A), m_Value(B))) && 160d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner (A == Op1 || B == Op1)) 161d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Op1; 162d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner 163d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // A | (A & ?) = A 164d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (match(Op1, m_And(m_Value(A), m_Value(B))) && 165d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner (A == Op0 || B == Op0)) 166d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Op0; 167d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner 1689f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner return 0; 1699f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner} 1709f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner 171d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner 172210c5d4880b525e064088b6fec713260128c16ebChris Lattnerstatic const Type *GetCompareTy(Value *Op) { 173210c5d4880b525e064088b6fec713260128c16ebChris Lattner return CmpInst::makeCmpResultType(Op->getType()); 174210c5d4880b525e064088b6fec713260128c16ebChris Lattner} 175210c5d4880b525e064088b6fec713260128c16ebChris Lattner 1769f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner 1779dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner/// SimplifyICmpInst - Given operands for an ICmpInst, see if we can 1789dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner/// fold the result. If not, this returns null. 1799dbb42944c4d7caddab21016b24cca31019a3fafChris LattnerValue *llvm::SimplifyICmpInst(unsigned Predicate, Value *LHS, Value *RHS, 1809dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner const TargetData *TD) { 1819f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner CmpInst::Predicate Pred = (CmpInst::Predicate)Predicate; 1829dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner assert(CmpInst::isIntPredicate(Pred) && "Not an integer compare!"); 1839f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner 184d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (Constant *CLHS = dyn_cast<Constant>(LHS)) { 1858f73deaa8732a556046bf4ac6207be55972e3b74Chris Lattner if (Constant *CRHS = dyn_cast<Constant>(RHS)) 1868f73deaa8732a556046bf4ac6207be55972e3b74Chris Lattner return ConstantFoldCompareInstOperands(Pred, CLHS, CRHS, TD); 187d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner 188d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // If we have a constant, make sure it is on the RHS. 189d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner std::swap(LHS, RHS); 190d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner Pred = CmpInst::getSwappedPredicate(Pred); 191d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner } 1929f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner 193210c5d4880b525e064088b6fec713260128c16ebChris Lattner // ITy - This is the return type of the compare we're considering. 194210c5d4880b525e064088b6fec713260128c16ebChris Lattner const Type *ITy = GetCompareTy(LHS); 195210c5d4880b525e064088b6fec713260128c16ebChris Lattner 196210c5d4880b525e064088b6fec713260128c16ebChris Lattner // icmp X, X -> true/false 1979f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner if (LHS == RHS) 198210c5d4880b525e064088b6fec713260128c16ebChris Lattner return ConstantInt::get(ITy, CmpInst::isTrueWhenEqual(Pred)); 199210c5d4880b525e064088b6fec713260128c16ebChris Lattner 200210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (isa<UndefValue>(RHS)) // X icmp undef -> undef 201210c5d4880b525e064088b6fec713260128c16ebChris Lattner return UndefValue::get(ITy); 202210c5d4880b525e064088b6fec713260128c16ebChris Lattner 203210c5d4880b525e064088b6fec713260128c16ebChris Lattner // icmp <global/alloca*/null>, <global/alloca*/null> - Global/Stack value 204210c5d4880b525e064088b6fec713260128c16ebChris Lattner // addresses never equal each other! We already know that Op0 != Op1. 205210c5d4880b525e064088b6fec713260128c16ebChris Lattner if ((isa<GlobalValue>(LHS) || isa<AllocaInst>(LHS) || 206210c5d4880b525e064088b6fec713260128c16ebChris Lattner isa<ConstantPointerNull>(LHS)) && 207210c5d4880b525e064088b6fec713260128c16ebChris Lattner (isa<GlobalValue>(RHS) || isa<AllocaInst>(RHS) || 208210c5d4880b525e064088b6fec713260128c16ebChris Lattner isa<ConstantPointerNull>(RHS))) 209210c5d4880b525e064088b6fec713260128c16ebChris Lattner return ConstantInt::get(ITy, CmpInst::isFalseWhenEqual(Pred)); 210210c5d4880b525e064088b6fec713260128c16ebChris Lattner 211210c5d4880b525e064088b6fec713260128c16ebChris Lattner // See if we are doing a comparison with a constant. 212210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (ConstantInt *CI = dyn_cast<ConstantInt>(RHS)) { 213210c5d4880b525e064088b6fec713260128c16ebChris Lattner // If we have an icmp le or icmp ge instruction, turn it into the 214210c5d4880b525e064088b6fec713260128c16ebChris Lattner // appropriate icmp lt or icmp gt instruction. This allows us to rely on 215210c5d4880b525e064088b6fec713260128c16ebChris Lattner // them being folded in the code below. 216210c5d4880b525e064088b6fec713260128c16ebChris Lattner switch (Pred) { 217210c5d4880b525e064088b6fec713260128c16ebChris Lattner default: break; 218210c5d4880b525e064088b6fec713260128c16ebChris Lattner case ICmpInst::ICMP_ULE: 219210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (CI->isMaxValue(false)) // A <=u MAX -> TRUE 220210c5d4880b525e064088b6fec713260128c16ebChris Lattner return ConstantInt::getTrue(CI->getContext()); 221210c5d4880b525e064088b6fec713260128c16ebChris Lattner break; 222210c5d4880b525e064088b6fec713260128c16ebChris Lattner case ICmpInst::ICMP_SLE: 223210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (CI->isMaxValue(true)) // A <=s MAX -> TRUE 224210c5d4880b525e064088b6fec713260128c16ebChris Lattner return ConstantInt::getTrue(CI->getContext()); 225210c5d4880b525e064088b6fec713260128c16ebChris Lattner break; 226210c5d4880b525e064088b6fec713260128c16ebChris Lattner case ICmpInst::ICMP_UGE: 227210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (CI->isMinValue(false)) // A >=u MIN -> TRUE 228210c5d4880b525e064088b6fec713260128c16ebChris Lattner return ConstantInt::getTrue(CI->getContext()); 229210c5d4880b525e064088b6fec713260128c16ebChris Lattner break; 230210c5d4880b525e064088b6fec713260128c16ebChris Lattner case ICmpInst::ICMP_SGE: 231210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (CI->isMinValue(true)) // A >=s MIN -> TRUE 232210c5d4880b525e064088b6fec713260128c16ebChris Lattner return ConstantInt::getTrue(CI->getContext()); 233210c5d4880b525e064088b6fec713260128c16ebChris Lattner break; 234210c5d4880b525e064088b6fec713260128c16ebChris Lattner } 235210c5d4880b525e064088b6fec713260128c16ebChris Lattner } 236210c5d4880b525e064088b6fec713260128c16ebChris Lattner 237210c5d4880b525e064088b6fec713260128c16ebChris Lattner 2389dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner return 0; 2399dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner} 2409dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner 2419dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner/// SimplifyFCmpInst - Given operands for an FCmpInst, see if we can 2429dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner/// fold the result. If not, this returns null. 2439dbb42944c4d7caddab21016b24cca31019a3fafChris LattnerValue *llvm::SimplifyFCmpInst(unsigned Predicate, Value *LHS, Value *RHS, 2449dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner const TargetData *TD) { 2459dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner CmpInst::Predicate Pred = (CmpInst::Predicate)Predicate; 2469dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner assert(CmpInst::isFPPredicate(Pred) && "Not an FP compare!"); 2479dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner 248d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (Constant *CLHS = dyn_cast<Constant>(LHS)) { 2499dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner if (Constant *CRHS = dyn_cast<Constant>(RHS)) 2509dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner return ConstantFoldCompareInstOperands(Pred, CLHS, CRHS, TD); 251d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner 252d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // If we have a constant, make sure it is on the RHS. 253d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner std::swap(LHS, RHS); 254d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner Pred = CmpInst::getSwappedPredicate(Pred); 255d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner } 2569dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner 257210c5d4880b525e064088b6fec713260128c16ebChris Lattner // Fold trivial predicates. 258210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (Pred == FCmpInst::FCMP_FALSE) 259210c5d4880b525e064088b6fec713260128c16ebChris Lattner return ConstantInt::get(GetCompareTy(LHS), 0); 260210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (Pred == FCmpInst::FCMP_TRUE) 261210c5d4880b525e064088b6fec713260128c16ebChris Lattner return ConstantInt::get(GetCompareTy(LHS), 1); 262210c5d4880b525e064088b6fec713260128c16ebChris Lattner 263210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (isa<UndefValue>(RHS)) // fcmp pred X, undef -> undef 264210c5d4880b525e064088b6fec713260128c16ebChris Lattner return UndefValue::get(GetCompareTy(LHS)); 265210c5d4880b525e064088b6fec713260128c16ebChris Lattner 266210c5d4880b525e064088b6fec713260128c16ebChris Lattner // fcmp x,x -> true/false. Not all compares are foldable. 267210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (LHS == RHS) { 268210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (CmpInst::isTrueWhenEqual(Pred)) 269210c5d4880b525e064088b6fec713260128c16ebChris Lattner return ConstantInt::get(GetCompareTy(LHS), 1); 270210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (CmpInst::isFalseWhenEqual(Pred)) 271210c5d4880b525e064088b6fec713260128c16ebChris Lattner return ConstantInt::get(GetCompareTy(LHS), 0); 272210c5d4880b525e064088b6fec713260128c16ebChris Lattner } 273210c5d4880b525e064088b6fec713260128c16ebChris Lattner 274210c5d4880b525e064088b6fec713260128c16ebChris Lattner // Handle fcmp with constant RHS 275210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (Constant *RHSC = dyn_cast<Constant>(RHS)) { 276210c5d4880b525e064088b6fec713260128c16ebChris Lattner // If the constant is a nan, see if we can fold the comparison based on it. 277210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (ConstantFP *CFP = dyn_cast<ConstantFP>(RHSC)) { 278210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (CFP->getValueAPF().isNaN()) { 279210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (FCmpInst::isOrdered(Pred)) // True "if ordered and foo" 280210c5d4880b525e064088b6fec713260128c16ebChris Lattner return ConstantInt::getFalse(CFP->getContext()); 281210c5d4880b525e064088b6fec713260128c16ebChris Lattner assert(FCmpInst::isUnordered(Pred) && 282210c5d4880b525e064088b6fec713260128c16ebChris Lattner "Comparison must be either ordered or unordered!"); 283210c5d4880b525e064088b6fec713260128c16ebChris Lattner // True if unordered. 284210c5d4880b525e064088b6fec713260128c16ebChris Lattner return ConstantInt::getTrue(CFP->getContext()); 285210c5d4880b525e064088b6fec713260128c16ebChris Lattner } 2866b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman // Check whether the constant is an infinity. 2876b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman if (CFP->getValueAPF().isInfinity()) { 2886b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman if (CFP->getValueAPF().isNegative()) { 2896b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman switch (Pred) { 2906b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman case FCmpInst::FCMP_OLT: 2916b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman // No value is ordered and less than negative infinity. 2926b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman return ConstantInt::getFalse(CFP->getContext()); 2936b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman case FCmpInst::FCMP_UGE: 2946b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman // All values are unordered with or at least negative infinity. 2956b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman return ConstantInt::getTrue(CFP->getContext()); 2966b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman default: 2976b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman break; 2986b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman } 2996b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman } else { 3006b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman switch (Pred) { 3016b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman case FCmpInst::FCMP_OGT: 3026b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman // No value is ordered and greater than infinity. 3036b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman return ConstantInt::getFalse(CFP->getContext()); 3046b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman case FCmpInst::FCMP_ULE: 3056b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman // All values are unordered with and at most infinity. 3066b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman return ConstantInt::getTrue(CFP->getContext()); 3076b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman default: 3086b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman break; 3096b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman } 3106b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman } 3116b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman } 312210c5d4880b525e064088b6fec713260128c16ebChris Lattner } 313210c5d4880b525e064088b6fec713260128c16ebChris Lattner } 314210c5d4880b525e064088b6fec713260128c16ebChris Lattner 3159f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner return 0; 3169f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner} 3179f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner 318c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner/// SimplifyGEPInst - Given operands for an GetElementPtrInst, see if we can 319c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner/// fold the result. If not, this returns null. 320c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris LattnerValue *llvm::SimplifyGEPInst(Value *const *Ops, unsigned NumOps, 321c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner const TargetData *TD) { 322c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner // getelementptr P -> P. 323c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner if (NumOps == 1) 324c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner return Ops[0]; 325c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner 326c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner // TODO. 327c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner //if (isa<UndefValue>(Ops[0])) 328c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner // return UndefValue::get(GEP.getType()); 329c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner 330c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner // getelementptr P, 0 -> P. 331c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner if (NumOps == 2) 332c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner if (ConstantInt *C = dyn_cast<ConstantInt>(Ops[1])) 333c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner if (C->isZero()) 334c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner return Ops[0]; 335c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner 336c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner // Check to see if this is constant foldable. 337c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner for (unsigned i = 0; i != NumOps; ++i) 338c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner if (!isa<Constant>(Ops[i])) 339c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner return 0; 340c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner 341c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner return ConstantExpr::getGetElementPtr(cast<Constant>(Ops[0]), 342c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner (Constant *const*)Ops+1, NumOps-1); 343c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner} 344c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner 345c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner 346d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner//=== Helper functions for higher up the class hierarchy. 3479dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner 348d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner/// SimplifyBinOp - Given operands for a BinaryOperator, see if we can 349d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner/// fold the result. If not, this returns null. 350d06094f0682f2ede03caff4892b1a57469896d48Chris LattnerValue *llvm::SimplifyBinOp(unsigned Opcode, Value *LHS, Value *RHS, 351d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner const TargetData *TD) { 352d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner switch (Opcode) { 353d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner case Instruction::And: return SimplifyAndInst(LHS, RHS, TD); 354d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner case Instruction::Or: return SimplifyOrInst(LHS, RHS, TD); 355d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner default: 356d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (Constant *CLHS = dyn_cast<Constant>(LHS)) 357d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (Constant *CRHS = dyn_cast<Constant>(RHS)) { 358d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner Constant *COps[] = {CLHS, CRHS}; 359d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return ConstantFoldInstOperands(Opcode, LHS->getType(), COps, 2, TD); 360d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner } 361d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return 0; 362d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner } 363d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner} 3649dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner 3659dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner/// SimplifyCmpInst - Given operands for a CmpInst, see if we can 3669dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner/// fold the result. 3679dbb42944c4d7caddab21016b24cca31019a3fafChris LattnerValue *llvm::SimplifyCmpInst(unsigned Predicate, Value *LHS, Value *RHS, 3689dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner const TargetData *TD) { 3699dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner if (CmpInst::isIntPredicate((CmpInst::Predicate)Predicate)) 3709dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner return SimplifyICmpInst(Predicate, LHS, RHS, TD); 3719dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner return SimplifyFCmpInst(Predicate, LHS, RHS, TD); 3729dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner} 3739dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner 374e34537856a544c83513e390ac9552a8bc3823346Chris Lattner 375e34537856a544c83513e390ac9552a8bc3823346Chris Lattner/// SimplifyInstruction - See if we can compute a simplified version of this 376e34537856a544c83513e390ac9552a8bc3823346Chris Lattner/// instruction. If not, this returns null. 377e34537856a544c83513e390ac9552a8bc3823346Chris LattnerValue *llvm::SimplifyInstruction(Instruction *I, const TargetData *TD) { 378e34537856a544c83513e390ac9552a8bc3823346Chris Lattner switch (I->getOpcode()) { 379e34537856a544c83513e390ac9552a8bc3823346Chris Lattner default: 380e34537856a544c83513e390ac9552a8bc3823346Chris Lattner return ConstantFoldInstruction(I, TD); 3818aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner case Instruction::Add: 3828aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner return SimplifyAddInst(I->getOperand(0), I->getOperand(1), 3838aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner cast<BinaryOperator>(I)->hasNoSignedWrap(), 3848aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner cast<BinaryOperator>(I)->hasNoUnsignedWrap(), TD); 385e34537856a544c83513e390ac9552a8bc3823346Chris Lattner case Instruction::And: 386e34537856a544c83513e390ac9552a8bc3823346Chris Lattner return SimplifyAndInst(I->getOperand(0), I->getOperand(1), TD); 387e34537856a544c83513e390ac9552a8bc3823346Chris Lattner case Instruction::Or: 388e34537856a544c83513e390ac9552a8bc3823346Chris Lattner return SimplifyOrInst(I->getOperand(0), I->getOperand(1), TD); 389e34537856a544c83513e390ac9552a8bc3823346Chris Lattner case Instruction::ICmp: 390e34537856a544c83513e390ac9552a8bc3823346Chris Lattner return SimplifyICmpInst(cast<ICmpInst>(I)->getPredicate(), 391e34537856a544c83513e390ac9552a8bc3823346Chris Lattner I->getOperand(0), I->getOperand(1), TD); 392e34537856a544c83513e390ac9552a8bc3823346Chris Lattner case Instruction::FCmp: 393e34537856a544c83513e390ac9552a8bc3823346Chris Lattner return SimplifyFCmpInst(cast<FCmpInst>(I)->getPredicate(), 394e34537856a544c83513e390ac9552a8bc3823346Chris Lattner I->getOperand(0), I->getOperand(1), TD); 395c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner case Instruction::GetElementPtr: { 396c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner SmallVector<Value*, 8> Ops(I->op_begin(), I->op_end()); 397c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner return SimplifyGEPInst(&Ops[0], Ops.size(), TD); 398c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner } 399e34537856a544c83513e390ac9552a8bc3823346Chris Lattner } 400e34537856a544c83513e390ac9552a8bc3823346Chris Lattner} 401e34537856a544c83513e390ac9552a8bc3823346Chris Lattner 40240d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner/// ReplaceAndSimplifyAllUses - Perform From->replaceAllUsesWith(To) and then 40340d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner/// delete the From instruction. In addition to a basic RAUW, this does a 40440d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner/// recursive simplification of the newly formed instructions. This catches 40540d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner/// things where one simplification exposes other opportunities. This only 40640d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner/// simplifies and deletes scalar operations, it does not change the CFG. 40740d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner/// 40840d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattnervoid llvm::ReplaceAndSimplifyAllUses(Instruction *From, Value *To, 40940d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner const TargetData *TD) { 41040d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner assert(From != To && "ReplaceAndSimplifyAllUses(X,X) is not valid!"); 41140d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner 41240d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner // FromHandle - This keeps a weakvh on the from value so that we can know if 41340d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner // it gets deleted out from under us in a recursive simplification. 41440d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner WeakVH FromHandle(From); 41540d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner 41640d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner while (!From->use_empty()) { 41740d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner // Update the instruction to use the new value. 41840d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner Use &U = From->use_begin().getUse(); 41940d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner Instruction *User = cast<Instruction>(U.getUser()); 42040d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner U = To; 42140d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner 42240d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner // See if we can simplify it. 42340d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner if (Value *V = SimplifyInstruction(User, TD)) { 42440d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner // Recursively simplify this. 42540d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner ReplaceAndSimplifyAllUses(User, V, TD); 42640d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner 42740d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner // If the recursive simplification ended up revisiting and deleting 'From' 42840d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner // then we're done. 42940d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner if (FromHandle == 0) 43040d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner return; 43140d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner } 43240d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner } 43340d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner From->eraseFromParent(); 43440d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner} 43540d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner 436