1210e45af3a579beeefb001c8f13c94e80407aad5Chris Lattner//===- PHITransAddr.cpp - PHI Translation for Addresses -------------------===// 2210e45af3a579beeefb001c8f13c94e80407aad5Chris Lattner// 3210e45af3a579beeefb001c8f13c94e80407aad5Chris Lattner// The LLVM Compiler Infrastructure 4210e45af3a579beeefb001c8f13c94e80407aad5Chris Lattner// 5210e45af3a579beeefb001c8f13c94e80407aad5Chris Lattner// This file is distributed under the University of Illinois Open Source 6210e45af3a579beeefb001c8f13c94e80407aad5Chris Lattner// License. See LICENSE.TXT for details. 7210e45af3a579beeefb001c8f13c94e80407aad5Chris Lattner// 8210e45af3a579beeefb001c8f13c94e80407aad5Chris Lattner//===----------------------------------------------------------------------===// 9210e45af3a579beeefb001c8f13c94e80407aad5Chris Lattner// 10210e45af3a579beeefb001c8f13c94e80407aad5Chris Lattner// This file implements the PHITransAddr class. 11210e45af3a579beeefb001c8f13c94e80407aad5Chris Lattner// 12210e45af3a579beeefb001c8f13c94e80407aad5Chris Lattner//===----------------------------------------------------------------------===// 13210e45af3a579beeefb001c8f13c94e80407aad5Chris Lattner 14210e45af3a579beeefb001c8f13c94e80407aad5Chris Lattner#include "llvm/Analysis/PHITransAddr.h" 15d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/Analysis/Dominators.h" 16d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/Analysis/InstructionSimplify.h" 17f0426601977c3e386d2d26c72a2cca691dc42072Dan Gohman#include "llvm/Analysis/ValueTracking.h" 180b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/Constants.h" 190b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/Instructions.h" 202a0f3ccc9c10186309d5d6a0c4cebe8b477f352aDavid Greene#include "llvm/Support/Debug.h" 2188fc03c461276f56a2005808cf10faa4cd857e5cDan Gohman#include "llvm/Support/ErrorHandling.h" 227dedbf4ce3e1b62b4e0b000b38d244b50029c315Chris Lattner#include "llvm/Support/raw_ostream.h" 23210e45af3a579beeefb001c8f13c94e80407aad5Chris Lattnerusing namespace llvm; 24210e45af3a579beeefb001c8f13c94e80407aad5Chris Lattner 256fcca1cc874c2b374b05399be92c5c1ea2086cc0Chris Lattnerstatic bool CanPHITrans(Instruction *Inst) { 269a8641201b2db8427be2a6531c043f384562c081Chris Lattner if (isa<PHINode>(Inst) || 276fcca1cc874c2b374b05399be92c5c1ea2086cc0Chris Lattner isa<GetElementPtrInst>(Inst)) 289a8641201b2db8427be2a6531c043f384562c081Chris Lattner return true; 29ce562622118c40d5a24a07960c15cd4912db0cbfDan Gohman 30ce562622118c40d5a24a07960c15cd4912db0cbfDan Gohman if (isa<CastInst>(Inst) && 31f0426601977c3e386d2d26c72a2cca691dc42072Dan Gohman isSafeToSpeculativelyExecute(Inst)) 32ce562622118c40d5a24a07960c15cd4912db0cbfDan Gohman return true; 337feccd2af9160e28724eaa6701e49bf1c0db4920Dan Gohman 3434f849098bfb8850fa34fbd115ba9b2e55c85a32Chris Lattner if (Inst->getOpcode() == Instruction::Add && 356fcca1cc874c2b374b05399be92c5c1ea2086cc0Chris Lattner isa<ConstantInt>(Inst->getOperand(1))) 366fcca1cc874c2b374b05399be92c5c1ea2086cc0Chris Lattner return true; 377feccd2af9160e28724eaa6701e49bf1c0db4920Dan Gohman 389a8641201b2db8427be2a6531c043f384562c081Chris Lattner // cerr << "MEMDEP: Could not PHI translate: " << *Pointer; 399a8641201b2db8427be2a6531c043f384562c081Chris Lattner // if (isa<BitCastInst>(PtrInst) || isa<GetElementPtrInst>(PtrInst)) 409a8641201b2db8427be2a6531c043f384562c081Chris Lattner // cerr << "OP:\t\t\t\t" << *PtrInst->getOperand(0); 419a8641201b2db8427be2a6531c043f384562c081Chris Lattner return false; 42210e45af3a579beeefb001c8f13c94e80407aad5Chris Lattner} 43210e45af3a579beeefb001c8f13c94e80407aad5Chris Lattner 44286c4dc355b8be6806081b23c3097485821c7642Manman Ren#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP) 457dedbf4ce3e1b62b4e0b000b38d244b50029c315Chris Lattnervoid PHITransAddr::dump() const { 467dedbf4ce3e1b62b4e0b000b38d244b50029c315Chris Lattner if (Addr == 0) { 472a0f3ccc9c10186309d5d6a0c4cebe8b477f352aDavid Greene dbgs() << "PHITransAddr: null\n"; 487dedbf4ce3e1b62b4e0b000b38d244b50029c315Chris Lattner return; 497dedbf4ce3e1b62b4e0b000b38d244b50029c315Chris Lattner } 502a0f3ccc9c10186309d5d6a0c4cebe8b477f352aDavid Greene dbgs() << "PHITransAddr: " << *Addr << "\n"; 517dedbf4ce3e1b62b4e0b000b38d244b50029c315Chris Lattner for (unsigned i = 0, e = InstInputs.size(); i != e; ++i) 522a0f3ccc9c10186309d5d6a0c4cebe8b477f352aDavid Greene dbgs() << " Input #" << i << " is " << *InstInputs[i] << "\n"; 537dedbf4ce3e1b62b4e0b000b38d244b50029c315Chris Lattner} 54cc77eece74c8db09acc2af425e7e6c88a5bb30d1Manman Ren#endif 557dedbf4ce3e1b62b4e0b000b38d244b50029c315Chris Lattner 567dedbf4ce3e1b62b4e0b000b38d244b50029c315Chris Lattner 577dedbf4ce3e1b62b4e0b000b38d244b50029c315Chris Lattnerstatic bool VerifySubExpr(Value *Expr, 587dedbf4ce3e1b62b4e0b000b38d244b50029c315Chris Lattner SmallVectorImpl<Instruction*> &InstInputs) { 597dedbf4ce3e1b62b4e0b000b38d244b50029c315Chris Lattner // If this is a non-instruction value, there is nothing to do. 607dedbf4ce3e1b62b4e0b000b38d244b50029c315Chris Lattner Instruction *I = dyn_cast<Instruction>(Expr); 617dedbf4ce3e1b62b4e0b000b38d244b50029c315Chris Lattner if (I == 0) return true; 627feccd2af9160e28724eaa6701e49bf1c0db4920Dan Gohman 637dedbf4ce3e1b62b4e0b000b38d244b50029c315Chris Lattner // If it's an instruction, it is either in Tmp or its operands recursively 647dedbf4ce3e1b62b4e0b000b38d244b50029c315Chris Lattner // are. 657dedbf4ce3e1b62b4e0b000b38d244b50029c315Chris Lattner SmallVectorImpl<Instruction*>::iterator Entry = 667dedbf4ce3e1b62b4e0b000b38d244b50029c315Chris Lattner std::find(InstInputs.begin(), InstInputs.end(), I); 677dedbf4ce3e1b62b4e0b000b38d244b50029c315Chris Lattner if (Entry != InstInputs.end()) { 687dedbf4ce3e1b62b4e0b000b38d244b50029c315Chris Lattner InstInputs.erase(Entry); 697dedbf4ce3e1b62b4e0b000b38d244b50029c315Chris Lattner return true; 707dedbf4ce3e1b62b4e0b000b38d244b50029c315Chris Lattner } 717feccd2af9160e28724eaa6701e49bf1c0db4920Dan Gohman 727dedbf4ce3e1b62b4e0b000b38d244b50029c315Chris Lattner // If it isn't in the InstInputs list it is a subexpr incorporated into the 737dedbf4ce3e1b62b4e0b000b38d244b50029c315Chris Lattner // address. Sanity check that it is phi translatable. 747dedbf4ce3e1b62b4e0b000b38d244b50029c315Chris Lattner if (!CanPHITrans(I)) { 7588fc03c461276f56a2005808cf10faa4cd857e5cDan Gohman errs() << "Non phi translatable instruction found in PHITransAddr:\n"; 76a8e21d485a71116f187523460efd367763cd8d59David Greene errs() << *I << '\n'; 7788fc03c461276f56a2005808cf10faa4cd857e5cDan Gohman llvm_unreachable("Either something is missing from InstInputs or " 7888fc03c461276f56a2005808cf10faa4cd857e5cDan Gohman "CanPHITrans is wrong."); 797dedbf4ce3e1b62b4e0b000b38d244b50029c315Chris Lattner } 807feccd2af9160e28724eaa6701e49bf1c0db4920Dan Gohman 817dedbf4ce3e1b62b4e0b000b38d244b50029c315Chris Lattner // Validate the operands of the instruction. 827dedbf4ce3e1b62b4e0b000b38d244b50029c315Chris Lattner for (unsigned i = 0, e = I->getNumOperands(); i != e; ++i) 837dedbf4ce3e1b62b4e0b000b38d244b50029c315Chris Lattner if (!VerifySubExpr(I->getOperand(i), InstInputs)) 847dedbf4ce3e1b62b4e0b000b38d244b50029c315Chris Lattner return false; 857dedbf4ce3e1b62b4e0b000b38d244b50029c315Chris Lattner 867dedbf4ce3e1b62b4e0b000b38d244b50029c315Chris Lattner return true; 877dedbf4ce3e1b62b4e0b000b38d244b50029c315Chris Lattner} 887dedbf4ce3e1b62b4e0b000b38d244b50029c315Chris Lattner 897dedbf4ce3e1b62b4e0b000b38d244b50029c315Chris Lattner/// Verify - Check internal consistency of this data structure. If the 907dedbf4ce3e1b62b4e0b000b38d244b50029c315Chris Lattner/// structure is valid, it returns true. If invalid, it prints errors and 917dedbf4ce3e1b62b4e0b000b38d244b50029c315Chris Lattner/// returns false. 927dedbf4ce3e1b62b4e0b000b38d244b50029c315Chris Lattnerbool PHITransAddr::Verify() const { 937dedbf4ce3e1b62b4e0b000b38d244b50029c315Chris Lattner if (Addr == 0) return true; 947feccd2af9160e28724eaa6701e49bf1c0db4920Dan Gohman 957feccd2af9160e28724eaa6701e49bf1c0db4920Dan Gohman SmallVector<Instruction*, 8> Tmp(InstInputs.begin(), InstInputs.end()); 967feccd2af9160e28724eaa6701e49bf1c0db4920Dan Gohman 977dedbf4ce3e1b62b4e0b000b38d244b50029c315Chris Lattner if (!VerifySubExpr(Addr, Tmp)) 987dedbf4ce3e1b62b4e0b000b38d244b50029c315Chris Lattner return false; 997feccd2af9160e28724eaa6701e49bf1c0db4920Dan Gohman 1007dedbf4ce3e1b62b4e0b000b38d244b50029c315Chris Lattner if (!Tmp.empty()) { 10188fc03c461276f56a2005808cf10faa4cd857e5cDan Gohman errs() << "PHITransAddr contains extra instructions:\n"; 1027dedbf4ce3e1b62b4e0b000b38d244b50029c315Chris Lattner for (unsigned i = 0, e = InstInputs.size(); i != e; ++i) 103a8e21d485a71116f187523460efd367763cd8d59David Greene errs() << " InstInput #" << i << " is " << *InstInputs[i] << "\n"; 10488fc03c461276f56a2005808cf10faa4cd857e5cDan Gohman llvm_unreachable("This is unexpected."); 1057dedbf4ce3e1b62b4e0b000b38d244b50029c315Chris Lattner } 1067feccd2af9160e28724eaa6701e49bf1c0db4920Dan Gohman 1077dedbf4ce3e1b62b4e0b000b38d244b50029c315Chris Lattner // a-ok. 1087dedbf4ce3e1b62b4e0b000b38d244b50029c315Chris Lattner return true; 1097dedbf4ce3e1b62b4e0b000b38d244b50029c315Chris Lattner} 1107dedbf4ce3e1b62b4e0b000b38d244b50029c315Chris Lattner 1117dedbf4ce3e1b62b4e0b000b38d244b50029c315Chris Lattner 1126fcca1cc874c2b374b05399be92c5c1ea2086cc0Chris Lattner/// IsPotentiallyPHITranslatable - If this needs PHI translation, return true 1136fcca1cc874c2b374b05399be92c5c1ea2086cc0Chris Lattner/// if we have some hope of doing it. This should be used as a filter to 1146fcca1cc874c2b374b05399be92c5c1ea2086cc0Chris Lattner/// avoid calling PHITranslateValue in hopeless situations. 1156fcca1cc874c2b374b05399be92c5c1ea2086cc0Chris Lattnerbool PHITransAddr::IsPotentiallyPHITranslatable() const { 1166fcca1cc874c2b374b05399be92c5c1ea2086cc0Chris Lattner // If the input value is not an instruction, or if it is not defined in CurBB, 1176fcca1cc874c2b374b05399be92c5c1ea2086cc0Chris Lattner // then we don't need to phi translate it. 1186fcca1cc874c2b374b05399be92c5c1ea2086cc0Chris Lattner Instruction *Inst = dyn_cast<Instruction>(Addr); 1196fcca1cc874c2b374b05399be92c5c1ea2086cc0Chris Lattner return Inst == 0 || CanPHITrans(Inst); 1206fcca1cc874c2b374b05399be92c5c1ea2086cc0Chris Lattner} 1216fcca1cc874c2b374b05399be92c5c1ea2086cc0Chris Lattner 1229a8641201b2db8427be2a6531c043f384562c081Chris Lattner 1237feccd2af9160e28724eaa6701e49bf1c0db4920Dan Gohmanstatic void RemoveInstInputs(Value *V, 12443678f41a37c077f28517c2e4889cca88cada6ceChris Lattner SmallVectorImpl<Instruction*> &InstInputs) { 1256200e53f55536f812153ad910e6a69139592301bChris Lattner Instruction *I = dyn_cast<Instruction>(V); 1266200e53f55536f812153ad910e6a69139592301bChris Lattner if (I == 0) return; 1277feccd2af9160e28724eaa6701e49bf1c0db4920Dan Gohman 12843678f41a37c077f28517c2e4889cca88cada6ceChris Lattner // If the instruction is in the InstInputs list, remove it. 12943678f41a37c077f28517c2e4889cca88cada6ceChris Lattner SmallVectorImpl<Instruction*>::iterator Entry = 13043678f41a37c077f28517c2e4889cca88cada6ceChris Lattner std::find(InstInputs.begin(), InstInputs.end(), I); 13143678f41a37c077f28517c2e4889cca88cada6ceChris Lattner if (Entry != InstInputs.end()) { 13243678f41a37c077f28517c2e4889cca88cada6ceChris Lattner InstInputs.erase(Entry); 13343678f41a37c077f28517c2e4889cca88cada6ceChris Lattner return; 13443678f41a37c077f28517c2e4889cca88cada6ceChris Lattner } 1357feccd2af9160e28724eaa6701e49bf1c0db4920Dan Gohman 1366200e53f55536f812153ad910e6a69139592301bChris Lattner assert(!isa<PHINode>(I) && "Error, removing something that isn't an input"); 1377feccd2af9160e28724eaa6701e49bf1c0db4920Dan Gohman 13843678f41a37c077f28517c2e4889cca88cada6ceChris Lattner // Otherwise, it must have instruction inputs itself. Zap them recursively. 13943678f41a37c077f28517c2e4889cca88cada6ceChris Lattner for (unsigned i = 0, e = I->getNumOperands(); i != e; ++i) { 1406200e53f55536f812153ad910e6a69139592301bChris Lattner if (Instruction *Op = dyn_cast<Instruction>(I->getOperand(i))) 14143678f41a37c077f28517c2e4889cca88cada6ceChris Lattner RemoveInstInputs(Op, InstInputs); 14243678f41a37c077f28517c2e4889cca88cada6ceChris Lattner } 14343678f41a37c077f28517c2e4889cca88cada6ceChris Lattner} 14443678f41a37c077f28517c2e4889cca88cada6ceChris Lattner 1459a8641201b2db8427be2a6531c043f384562c081Chris LattnerValue *PHITransAddr::PHITranslateSubExpr(Value *V, BasicBlock *CurBB, 1466d8f2ca646bc283c31f48b6816d5194c836dfec6Daniel Dunbar BasicBlock *PredBB, 1476d8f2ca646bc283c31f48b6816d5194c836dfec6Daniel Dunbar const DominatorTree *DT) { 1489a8641201b2db8427be2a6531c043f384562c081Chris Lattner // If this is a non-instruction value, it can't require PHI translation. 1499a8641201b2db8427be2a6531c043f384562c081Chris Lattner Instruction *Inst = dyn_cast<Instruction>(V); 1509a8641201b2db8427be2a6531c043f384562c081Chris Lattner if (Inst == 0) return V; 1517feccd2af9160e28724eaa6701e49bf1c0db4920Dan Gohman 152af50315a29600188a6ff8b935beca6f1b59edf48Chris Lattner // Determine whether 'Inst' is an input to our PHI translatable expression. 153af50315a29600188a6ff8b935beca6f1b59edf48Chris Lattner bool isInput = std::count(InstInputs.begin(), InstInputs.end(), Inst); 154af50315a29600188a6ff8b935beca6f1b59edf48Chris Lattner 155af50315a29600188a6ff8b935beca6f1b59edf48Chris Lattner // Handle inputs instructions if needed. 156af50315a29600188a6ff8b935beca6f1b59edf48Chris Lattner if (isInput) { 157af50315a29600188a6ff8b935beca6f1b59edf48Chris Lattner if (Inst->getParent() != CurBB) { 158af50315a29600188a6ff8b935beca6f1b59edf48Chris Lattner // If it is an input defined in a different block, then it remains an 159af50315a29600188a6ff8b935beca6f1b59edf48Chris Lattner // input. 160af50315a29600188a6ff8b935beca6f1b59edf48Chris Lattner return Inst; 161af50315a29600188a6ff8b935beca6f1b59edf48Chris Lattner } 162e09e98c2de28a7dbbc4d3712c174596443a7a3f1Chris Lattner 163e09e98c2de28a7dbbc4d3712c174596443a7a3f1Chris Lattner // If 'Inst' is defined in this block and is an input that needs to be phi 164e09e98c2de28a7dbbc4d3712c174596443a7a3f1Chris Lattner // translated, we need to incorporate the value into the expression or fail. 165e09e98c2de28a7dbbc4d3712c174596443a7a3f1Chris Lattner 1666200e53f55536f812153ad910e6a69139592301bChris Lattner // In either case, the instruction itself isn't an input any longer. 1676200e53f55536f812153ad910e6a69139592301bChris Lattner InstInputs.erase(std::find(InstInputs.begin(), InstInputs.end(), Inst)); 1687feccd2af9160e28724eaa6701e49bf1c0db4920Dan Gohman 1696fcca1cc874c2b374b05399be92c5c1ea2086cc0Chris Lattner // If this is a PHI, go ahead and translate it. 1706fcca1cc874c2b374b05399be92c5c1ea2086cc0Chris Lattner if (PHINode *PN = dyn_cast<PHINode>(Inst)) 1716200e53f55536f812153ad910e6a69139592301bChris Lattner return AddAsInput(PN->getIncomingValueForBlock(PredBB)); 1727feccd2af9160e28724eaa6701e49bf1c0db4920Dan Gohman 1736fcca1cc874c2b374b05399be92c5c1ea2086cc0Chris Lattner // If this is a non-phi value, and it is analyzable, we can incorporate it 1746fcca1cc874c2b374b05399be92c5c1ea2086cc0Chris Lattner // into the expression by making all instruction operands be inputs. 1756fcca1cc874c2b374b05399be92c5c1ea2086cc0Chris Lattner if (!CanPHITrans(Inst)) 1766fcca1cc874c2b374b05399be92c5c1ea2086cc0Chris Lattner return 0; 1777feccd2af9160e28724eaa6701e49bf1c0db4920Dan Gohman 1786fcca1cc874c2b374b05399be92c5c1ea2086cc0Chris Lattner // All instruction operands are now inputs (and of course, they may also be 1796fcca1cc874c2b374b05399be92c5c1ea2086cc0Chris Lattner // defined in this block, so they may need to be phi translated themselves. 1806fcca1cc874c2b374b05399be92c5c1ea2086cc0Chris Lattner for (unsigned i = 0, e = Inst->getNumOperands(); i != e; ++i) 1816fcca1cc874c2b374b05399be92c5c1ea2086cc0Chris Lattner if (Instruction *Op = dyn_cast<Instruction>(Inst->getOperand(i))) 1826fcca1cc874c2b374b05399be92c5c1ea2086cc0Chris Lattner InstInputs.push_back(Op); 1836fcca1cc874c2b374b05399be92c5c1ea2086cc0Chris Lattner } 1846fcca1cc874c2b374b05399be92c5c1ea2086cc0Chris Lattner 1856fcca1cc874c2b374b05399be92c5c1ea2086cc0Chris Lattner // Ok, it must be an intermediate result (either because it started that way 1866fcca1cc874c2b374b05399be92c5c1ea2086cc0Chris Lattner // or because we just incorporated it into the expression). See if its 1876fcca1cc874c2b374b05399be92c5c1ea2086cc0Chris Lattner // operands need to be phi translated, and if so, reconstruct it. 1887feccd2af9160e28724eaa6701e49bf1c0db4920Dan Gohman 189ce562622118c40d5a24a07960c15cd4912db0cbfDan Gohman if (CastInst *Cast = dyn_cast<CastInst>(Inst)) { 190f0426601977c3e386d2d26c72a2cca691dc42072Dan Gohman if (!isSafeToSpeculativelyExecute(Cast)) return 0; 191ce562622118c40d5a24a07960c15cd4912db0cbfDan Gohman Value *PHIIn = PHITranslateSubExpr(Cast->getOperand(0), CurBB, PredBB, DT); 1926fcca1cc874c2b374b05399be92c5c1ea2086cc0Chris Lattner if (PHIIn == 0) return 0; 193ce562622118c40d5a24a07960c15cd4912db0cbfDan Gohman if (PHIIn == Cast->getOperand(0)) 194ce562622118c40d5a24a07960c15cd4912db0cbfDan Gohman return Cast; 1957feccd2af9160e28724eaa6701e49bf1c0db4920Dan Gohman 1966fcca1cc874c2b374b05399be92c5c1ea2086cc0Chris Lattner // Find an available version of this cast. 1977feccd2af9160e28724eaa6701e49bf1c0db4920Dan Gohman 1986fcca1cc874c2b374b05399be92c5c1ea2086cc0Chris Lattner // Constants are trivial to find. 1996fcca1cc874c2b374b05399be92c5c1ea2086cc0Chris Lattner if (Constant *C = dyn_cast<Constant>(PHIIn)) 200ce562622118c40d5a24a07960c15cd4912db0cbfDan Gohman return AddAsInput(ConstantExpr::getCast(Cast->getOpcode(), 201ce562622118c40d5a24a07960c15cd4912db0cbfDan Gohman C, Cast->getType())); 2027feccd2af9160e28724eaa6701e49bf1c0db4920Dan Gohman 203ce562622118c40d5a24a07960c15cd4912db0cbfDan Gohman // Otherwise we have to see if a casted version of the incoming pointer 2046fcca1cc874c2b374b05399be92c5c1ea2086cc0Chris Lattner // is available. If so, we can use it, otherwise we have to fail. 2056fcca1cc874c2b374b05399be92c5c1ea2086cc0Chris Lattner for (Value::use_iterator UI = PHIIn->use_begin(), E = PHIIn->use_end(); 2066fcca1cc874c2b374b05399be92c5c1ea2086cc0Chris Lattner UI != E; ++UI) { 207ce562622118c40d5a24a07960c15cd4912db0cbfDan Gohman if (CastInst *CastI = dyn_cast<CastInst>(*UI)) 208ce562622118c40d5a24a07960c15cd4912db0cbfDan Gohman if (CastI->getOpcode() == Cast->getOpcode() && 209ce562622118c40d5a24a07960c15cd4912db0cbfDan Gohman CastI->getType() == Cast->getType() && 210ce562622118c40d5a24a07960c15cd4912db0cbfDan Gohman (!DT || DT->dominates(CastI->getParent(), PredBB))) 211ce562622118c40d5a24a07960c15cd4912db0cbfDan Gohman return CastI; 2126fcca1cc874c2b374b05399be92c5c1ea2086cc0Chris Lattner } 2136fcca1cc874c2b374b05399be92c5c1ea2086cc0Chris Lattner return 0; 2146fcca1cc874c2b374b05399be92c5c1ea2086cc0Chris Lattner } 2157feccd2af9160e28724eaa6701e49bf1c0db4920Dan Gohman 2166fcca1cc874c2b374b05399be92c5c1ea2086cc0Chris Lattner // Handle getelementptr with at least one PHI translatable operand. 2176fcca1cc874c2b374b05399be92c5c1ea2086cc0Chris Lattner if (GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(Inst)) { 2186fcca1cc874c2b374b05399be92c5c1ea2086cc0Chris Lattner SmallVector<Value*, 8> GEPOps; 2196fcca1cc874c2b374b05399be92c5c1ea2086cc0Chris Lattner bool AnyChanged = false; 2206fcca1cc874c2b374b05399be92c5c1ea2086cc0Chris Lattner for (unsigned i = 0, e = GEP->getNumOperands(); i != e; ++i) { 2216d8f2ca646bc283c31f48b6816d5194c836dfec6Daniel Dunbar Value *GEPOp = PHITranslateSubExpr(GEP->getOperand(i), CurBB, PredBB, DT); 2226fcca1cc874c2b374b05399be92c5c1ea2086cc0Chris Lattner if (GEPOp == 0) return 0; 2237feccd2af9160e28724eaa6701e49bf1c0db4920Dan Gohman 2246045417fcc21b1c0663120b9f24ec822f5d17cfeChris Lattner AnyChanged |= GEPOp != GEP->getOperand(i); 2256fcca1cc874c2b374b05399be92c5c1ea2086cc0Chris Lattner GEPOps.push_back(GEPOp); 2269a8641201b2db8427be2a6531c043f384562c081Chris Lattner } 2277feccd2af9160e28724eaa6701e49bf1c0db4920Dan Gohman 2286fcca1cc874c2b374b05399be92c5c1ea2086cc0Chris Lattner if (!AnyChanged) 2296fcca1cc874c2b374b05399be92c5c1ea2086cc0Chris Lattner return GEP; 2307feccd2af9160e28724eaa6701e49bf1c0db4920Dan Gohman 2316fcca1cc874c2b374b05399be92c5c1ea2086cc0Chris Lattner // Simplify the GEP to handle 'gep x, 0' -> x etc. 2320aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyGEPInst(GEPOps, TD, TLI, DT)) { 2336200e53f55536f812153ad910e6a69139592301bChris Lattner for (unsigned i = 0, e = GEPOps.size(); i != e; ++i) 2346200e53f55536f812153ad910e6a69139592301bChris Lattner RemoveInstInputs(GEPOps[i], InstInputs); 2357feccd2af9160e28724eaa6701e49bf1c0db4920Dan Gohman 2366200e53f55536f812153ad910e6a69139592301bChris Lattner return AddAsInput(V); 2376200e53f55536f812153ad910e6a69139592301bChris Lattner } 2387feccd2af9160e28724eaa6701e49bf1c0db4920Dan Gohman 2396fcca1cc874c2b374b05399be92c5c1ea2086cc0Chris Lattner // Scan to see if we have this GEP available. 2406fcca1cc874c2b374b05399be92c5c1ea2086cc0Chris Lattner Value *APHIOp = GEPOps[0]; 2416fcca1cc874c2b374b05399be92c5c1ea2086cc0Chris Lattner for (Value::use_iterator UI = APHIOp->use_begin(), E = APHIOp->use_end(); 2426fcca1cc874c2b374b05399be92c5c1ea2086cc0Chris Lattner UI != E; ++UI) { 2436fcca1cc874c2b374b05399be92c5c1ea2086cc0Chris Lattner if (GetElementPtrInst *GEPI = dyn_cast<GetElementPtrInst>(*UI)) 2446fcca1cc874c2b374b05399be92c5c1ea2086cc0Chris Lattner if (GEPI->getType() == GEP->getType() && 2456fcca1cc874c2b374b05399be92c5c1ea2086cc0Chris Lattner GEPI->getNumOperands() == GEPOps.size() && 2466d8f2ca646bc283c31f48b6816d5194c836dfec6Daniel Dunbar GEPI->getParent()->getParent() == CurBB->getParent() && 2476d8f2ca646bc283c31f48b6816d5194c836dfec6Daniel Dunbar (!DT || DT->dominates(GEPI->getParent(), PredBB))) { 2486fcca1cc874c2b374b05399be92c5c1ea2086cc0Chris Lattner bool Mismatch = false; 2496fcca1cc874c2b374b05399be92c5c1ea2086cc0Chris Lattner for (unsigned i = 0, e = GEPOps.size(); i != e; ++i) 2506fcca1cc874c2b374b05399be92c5c1ea2086cc0Chris Lattner if (GEPI->getOperand(i) != GEPOps[i]) { 2516fcca1cc874c2b374b05399be92c5c1ea2086cc0Chris Lattner Mismatch = true; 2526fcca1cc874c2b374b05399be92c5c1ea2086cc0Chris Lattner break; 2536fcca1cc874c2b374b05399be92c5c1ea2086cc0Chris Lattner } 2546fcca1cc874c2b374b05399be92c5c1ea2086cc0Chris Lattner if (!Mismatch) 2556fcca1cc874c2b374b05399be92c5c1ea2086cc0Chris Lattner return GEPI; 2566fcca1cc874c2b374b05399be92c5c1ea2086cc0Chris Lattner } 2579a8641201b2db8427be2a6531c043f384562c081Chris Lattner } 2586fcca1cc874c2b374b05399be92c5c1ea2086cc0Chris Lattner return 0; 2596fcca1cc874c2b374b05399be92c5c1ea2086cc0Chris Lattner } 2607feccd2af9160e28724eaa6701e49bf1c0db4920Dan Gohman 2616fcca1cc874c2b374b05399be92c5c1ea2086cc0Chris Lattner // Handle add with a constant RHS. 2626fcca1cc874c2b374b05399be92c5c1ea2086cc0Chris Lattner if (Inst->getOpcode() == Instruction::Add && 2636fcca1cc874c2b374b05399be92c5c1ea2086cc0Chris Lattner isa<ConstantInt>(Inst->getOperand(1))) { 2646fcca1cc874c2b374b05399be92c5c1ea2086cc0Chris Lattner // PHI translate the LHS. 2656fcca1cc874c2b374b05399be92c5c1ea2086cc0Chris Lattner Constant *RHS = cast<ConstantInt>(Inst->getOperand(1)); 2666fcca1cc874c2b374b05399be92c5c1ea2086cc0Chris Lattner bool isNSW = cast<BinaryOperator>(Inst)->hasNoSignedWrap(); 2676fcca1cc874c2b374b05399be92c5c1ea2086cc0Chris Lattner bool isNUW = cast<BinaryOperator>(Inst)->hasNoUnsignedWrap(); 2687feccd2af9160e28724eaa6701e49bf1c0db4920Dan Gohman 2696d8f2ca646bc283c31f48b6816d5194c836dfec6Daniel Dunbar Value *LHS = PHITranslateSubExpr(Inst->getOperand(0), CurBB, PredBB, DT); 2706fcca1cc874c2b374b05399be92c5c1ea2086cc0Chris Lattner if (LHS == 0) return 0; 2717feccd2af9160e28724eaa6701e49bf1c0db4920Dan Gohman 2726fcca1cc874c2b374b05399be92c5c1ea2086cc0Chris Lattner // If the PHI translated LHS is an add of a constant, fold the immediates. 2736fcca1cc874c2b374b05399be92c5c1ea2086cc0Chris Lattner if (BinaryOperator *BOp = dyn_cast<BinaryOperator>(LHS)) 2746fcca1cc874c2b374b05399be92c5c1ea2086cc0Chris Lattner if (BOp->getOpcode() == Instruction::Add) 2756fcca1cc874c2b374b05399be92c5c1ea2086cc0Chris Lattner if (ConstantInt *CI = dyn_cast<ConstantInt>(BOp->getOperand(1))) { 2766fcca1cc874c2b374b05399be92c5c1ea2086cc0Chris Lattner LHS = BOp->getOperand(0); 2776fcca1cc874c2b374b05399be92c5c1ea2086cc0Chris Lattner RHS = ConstantExpr::getAdd(RHS, CI); 2786fcca1cc874c2b374b05399be92c5c1ea2086cc0Chris Lattner isNSW = isNUW = false; 2797feccd2af9160e28724eaa6701e49bf1c0db4920Dan Gohman 2806200e53f55536f812153ad910e6a69139592301bChris Lattner // If the old 'LHS' was an input, add the new 'LHS' as an input. 2816200e53f55536f812153ad910e6a69139592301bChris Lattner if (std::count(InstInputs.begin(), InstInputs.end(), BOp)) { 2826200e53f55536f812153ad910e6a69139592301bChris Lattner RemoveInstInputs(BOp, InstInputs); 2836200e53f55536f812153ad910e6a69139592301bChris Lattner AddAsInput(LHS); 2846200e53f55536f812153ad910e6a69139592301bChris Lattner } 2856fcca1cc874c2b374b05399be92c5c1ea2086cc0Chris Lattner } 2867feccd2af9160e28724eaa6701e49bf1c0db4920Dan Gohman 2876fcca1cc874c2b374b05399be92c5c1ea2086cc0Chris Lattner // See if the add simplifies away. 288618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *Res = SimplifyAddInst(LHS, RHS, isNSW, isNUW, TD, TLI, DT)) { 2896200e53f55536f812153ad910e6a69139592301bChris Lattner // If we simplified the operands, the LHS is no longer an input, but Res 2906200e53f55536f812153ad910e6a69139592301bChris Lattner // is. 2916200e53f55536f812153ad910e6a69139592301bChris Lattner RemoveInstInputs(LHS, InstInputs); 2926200e53f55536f812153ad910e6a69139592301bChris Lattner return AddAsInput(Res); 2936200e53f55536f812153ad910e6a69139592301bChris Lattner } 2944d3a16f81b2a0f0211b58f2c1e5a28e2bbd432c7Chris Lattner 2954d3a16f81b2a0f0211b58f2c1e5a28e2bbd432c7Chris Lattner // If we didn't modify the add, just return it. 2964d3a16f81b2a0f0211b58f2c1e5a28e2bbd432c7Chris Lattner if (LHS == Inst->getOperand(0) && RHS == Inst->getOperand(1)) 2974d3a16f81b2a0f0211b58f2c1e5a28e2bbd432c7Chris Lattner return Inst; 2987feccd2af9160e28724eaa6701e49bf1c0db4920Dan Gohman 2996fcca1cc874c2b374b05399be92c5c1ea2086cc0Chris Lattner // Otherwise, see if we have this add available somewhere. 3006fcca1cc874c2b374b05399be92c5c1ea2086cc0Chris Lattner for (Value::use_iterator UI = LHS->use_begin(), E = LHS->use_end(); 3016fcca1cc874c2b374b05399be92c5c1ea2086cc0Chris Lattner UI != E; ++UI) { 3026fcca1cc874c2b374b05399be92c5c1ea2086cc0Chris Lattner if (BinaryOperator *BO = dyn_cast<BinaryOperator>(*UI)) 303eddc65aa0da35ee906e27cc7a13f44260c70007cChris Lattner if (BO->getOpcode() == Instruction::Add && 304eddc65aa0da35ee906e27cc7a13f44260c70007cChris Lattner BO->getOperand(0) == LHS && BO->getOperand(1) == RHS && 3056d8f2ca646bc283c31f48b6816d5194c836dfec6Daniel Dunbar BO->getParent()->getParent() == CurBB->getParent() && 3066d8f2ca646bc283c31f48b6816d5194c836dfec6Daniel Dunbar (!DT || DT->dominates(BO->getParent(), PredBB))) 3076fcca1cc874c2b374b05399be92c5c1ea2086cc0Chris Lattner return BO; 3089a8641201b2db8427be2a6531c043f384562c081Chris Lattner } 3097feccd2af9160e28724eaa6701e49bf1c0db4920Dan Gohman 3109a8641201b2db8427be2a6531c043f384562c081Chris Lattner return 0; 3119a8641201b2db8427be2a6531c043f384562c081Chris Lattner } 3127feccd2af9160e28724eaa6701e49bf1c0db4920Dan Gohman 3136fcca1cc874c2b374b05399be92c5c1ea2086cc0Chris Lattner // Otherwise, we failed. 3146fcca1cc874c2b374b05399be92c5c1ea2086cc0Chris Lattner return 0; 315210e45af3a579beeefb001c8f13c94e80407aad5Chris Lattner} 316210e45af3a579beeefb001c8f13c94e80407aad5Chris Lattner 3179a8641201b2db8427be2a6531c043f384562c081Chris Lattner 3189a8641201b2db8427be2a6531c043f384562c081Chris Lattner/// PHITranslateValue - PHI translate the current address up the CFG from 3196d8f2ca646bc283c31f48b6816d5194c836dfec6Daniel Dunbar/// CurBB to Pred, updating our state to reflect any needed changes. If the 3206d8f2ca646bc283c31f48b6816d5194c836dfec6Daniel Dunbar/// dominator tree DT is non-null, the translated value must dominate 3216d8f2ca646bc283c31f48b6816d5194c836dfec6Daniel Dunbar/// PredBB. This returns true on failure and sets Addr to null. 3226d8f2ca646bc283c31f48b6816d5194c836dfec6Daniel Dunbarbool PHITransAddr::PHITranslateValue(BasicBlock *CurBB, BasicBlock *PredBB, 3236d8f2ca646bc283c31f48b6816d5194c836dfec6Daniel Dunbar const DominatorTree *DT) { 3247dedbf4ce3e1b62b4e0b000b38d244b50029c315Chris Lattner assert(Verify() && "Invalid PHITransAddr!"); 3256d8f2ca646bc283c31f48b6816d5194c836dfec6Daniel Dunbar Addr = PHITranslateSubExpr(Addr, CurBB, PredBB, DT); 3267dedbf4ce3e1b62b4e0b000b38d244b50029c315Chris Lattner assert(Verify() && "Invalid PHITransAddr!"); 3279a8641201b2db8427be2a6531c043f384562c081Chris Lattner 3286d8f2ca646bc283c31f48b6816d5194c836dfec6Daniel Dunbar if (DT) { 3296d8f2ca646bc283c31f48b6816d5194c836dfec6Daniel Dunbar // Make sure the value is live in the predecessor. 3306d8f2ca646bc283c31f48b6816d5194c836dfec6Daniel Dunbar if (Instruction *Inst = dyn_cast_or_null<Instruction>(Addr)) 3316d8f2ca646bc283c31f48b6816d5194c836dfec6Daniel Dunbar if (!DT->dominates(Inst->getParent(), PredBB)) 3326d8f2ca646bc283c31f48b6816d5194c836dfec6Daniel Dunbar Addr = 0; 3336d8f2ca646bc283c31f48b6816d5194c836dfec6Daniel Dunbar } 3348c0c99016b4348bf9cc294a0f2dd60a219d4506cDaniel Dunbar 3356d8f2ca646bc283c31f48b6816d5194c836dfec6Daniel Dunbar return Addr == 0; 3366d8f2ca646bc283c31f48b6816d5194c836dfec6Daniel Dunbar} 3378c0c99016b4348bf9cc294a0f2dd60a219d4506cDaniel Dunbar 3389a8641201b2db8427be2a6531c043f384562c081Chris Lattner/// PHITranslateWithInsertion - PHI translate this value into the specified 3399a8641201b2db8427be2a6531c043f384562c081Chris Lattner/// predecessor block, inserting a computation of the value if it is 3409a8641201b2db8427be2a6531c043f384562c081Chris Lattner/// unavailable. 3419a8641201b2db8427be2a6531c043f384562c081Chris Lattner/// 3429a8641201b2db8427be2a6531c043f384562c081Chris Lattner/// All newly created instructions are added to the NewInsts list. This 3439a8641201b2db8427be2a6531c043f384562c081Chris Lattner/// returns null on failure. 3449a8641201b2db8427be2a6531c043f384562c081Chris Lattner/// 3459a8641201b2db8427be2a6531c043f384562c081Chris LattnerValue *PHITransAddr:: 3469a8641201b2db8427be2a6531c043f384562c081Chris LattnerPHITranslateWithInsertion(BasicBlock *CurBB, BasicBlock *PredBB, 3479a8641201b2db8427be2a6531c043f384562c081Chris Lattner const DominatorTree &DT, 3489a8641201b2db8427be2a6531c043f384562c081Chris Lattner SmallVectorImpl<Instruction*> &NewInsts) { 3499a8641201b2db8427be2a6531c043f384562c081Chris Lattner unsigned NISize = NewInsts.size(); 3507feccd2af9160e28724eaa6701e49bf1c0db4920Dan Gohman 3519a8641201b2db8427be2a6531c043f384562c081Chris Lattner // Attempt to PHI translate with insertion. 3529a8641201b2db8427be2a6531c043f384562c081Chris Lattner Addr = InsertPHITranslatedSubExpr(Addr, CurBB, PredBB, DT, NewInsts); 3537feccd2af9160e28724eaa6701e49bf1c0db4920Dan Gohman 3549a8641201b2db8427be2a6531c043f384562c081Chris Lattner // If successful, return the new value. 3559a8641201b2db8427be2a6531c043f384562c081Chris Lattner if (Addr) return Addr; 3567feccd2af9160e28724eaa6701e49bf1c0db4920Dan Gohman 3579a8641201b2db8427be2a6531c043f384562c081Chris Lattner // If not, destroy any intermediate instructions inserted. 3589a8641201b2db8427be2a6531c043f384562c081Chris Lattner while (NewInsts.size() != NISize) 3599a8641201b2db8427be2a6531c043f384562c081Chris Lattner NewInsts.pop_back_val()->eraseFromParent(); 3609a8641201b2db8427be2a6531c043f384562c081Chris Lattner return 0; 3619a8641201b2db8427be2a6531c043f384562c081Chris Lattner} 3629a8641201b2db8427be2a6531c043f384562c081Chris Lattner 3639a8641201b2db8427be2a6531c043f384562c081Chris Lattner 364210e45af3a579beeefb001c8f13c94e80407aad5Chris Lattner/// InsertPHITranslatedPointer - Insert a computation of the PHI translated 365210e45af3a579beeefb001c8f13c94e80407aad5Chris Lattner/// version of 'V' for the edge PredBB->CurBB into the end of the PredBB 366210e45af3a579beeefb001c8f13c94e80407aad5Chris Lattner/// block. All newly created instructions are added to the NewInsts list. 367210e45af3a579beeefb001c8f13c94e80407aad5Chris Lattner/// This returns null on failure. 368210e45af3a579beeefb001c8f13c94e80407aad5Chris Lattner/// 369210e45af3a579beeefb001c8f13c94e80407aad5Chris LattnerValue *PHITransAddr:: 3709a8641201b2db8427be2a6531c043f384562c081Chris LattnerInsertPHITranslatedSubExpr(Value *InVal, BasicBlock *CurBB, 3719a8641201b2db8427be2a6531c043f384562c081Chris Lattner BasicBlock *PredBB, const DominatorTree &DT, 3729a8641201b2db8427be2a6531c043f384562c081Chris Lattner SmallVectorImpl<Instruction*> &NewInsts) { 373210e45af3a579beeefb001c8f13c94e80407aad5Chris Lattner // See if we have a version of this value already available and dominating 3749a8641201b2db8427be2a6531c043f384562c081Chris Lattner // PredBB. If so, there is no need to insert a new instance of it. 3756d8f2ca646bc283c31f48b6816d5194c836dfec6Daniel Dunbar PHITransAddr Tmp(InVal, TD); 3766d8f2ca646bc283c31f48b6816d5194c836dfec6Daniel Dunbar if (!Tmp.PHITranslateValue(CurBB, PredBB, &DT)) 3776d8f2ca646bc283c31f48b6816d5194c836dfec6Daniel Dunbar return Tmp.getAddr(); 378210e45af3a579beeefb001c8f13c94e80407aad5Chris Lattner 3799a8641201b2db8427be2a6531c043f384562c081Chris Lattner // If we don't have an available version of this value, it must be an 3809a8641201b2db8427be2a6531c043f384562c081Chris Lattner // instruction. 3819a8641201b2db8427be2a6531c043f384562c081Chris Lattner Instruction *Inst = cast<Instruction>(InVal); 3827feccd2af9160e28724eaa6701e49bf1c0db4920Dan Gohman 383ce562622118c40d5a24a07960c15cd4912db0cbfDan Gohman // Handle cast of PHI translatable value. 384ce562622118c40d5a24a07960c15cd4912db0cbfDan Gohman if (CastInst *Cast = dyn_cast<CastInst>(Inst)) { 385f0426601977c3e386d2d26c72a2cca691dc42072Dan Gohman if (!isSafeToSpeculativelyExecute(Cast)) return 0; 386ce562622118c40d5a24a07960c15cd4912db0cbfDan Gohman Value *OpVal = InsertPHITranslatedSubExpr(Cast->getOperand(0), 3879a8641201b2db8427be2a6531c043f384562c081Chris Lattner CurBB, PredBB, DT, NewInsts); 3889a8641201b2db8427be2a6531c043f384562c081Chris Lattner if (OpVal == 0) return 0; 3897feccd2af9160e28724eaa6701e49bf1c0db4920Dan Gohman 390ce562622118c40d5a24a07960c15cd4912db0cbfDan Gohman // Otherwise insert a cast at the end of PredBB. 391ce562622118c40d5a24a07960c15cd4912db0cbfDan Gohman CastInst *New = CastInst::Create(Cast->getOpcode(), 392ce562622118c40d5a24a07960c15cd4912db0cbfDan Gohman OpVal, InVal->getType(), 393ce562622118c40d5a24a07960c15cd4912db0cbfDan Gohman InVal->getName()+".phi.trans.insert", 394ce562622118c40d5a24a07960c15cd4912db0cbfDan Gohman PredBB->getTerminator()); 3959a8641201b2db8427be2a6531c043f384562c081Chris Lattner NewInsts.push_back(New); 3969a8641201b2db8427be2a6531c043f384562c081Chris Lattner return New; 3979a8641201b2db8427be2a6531c043f384562c081Chris Lattner } 3987feccd2af9160e28724eaa6701e49bf1c0db4920Dan Gohman 3999a8641201b2db8427be2a6531c043f384562c081Chris Lattner // Handle getelementptr with at least one PHI operand. 4009a8641201b2db8427be2a6531c043f384562c081Chris Lattner if (GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(Inst)) { 4019a8641201b2db8427be2a6531c043f384562c081Chris Lattner SmallVector<Value*, 8> GEPOps; 4029a8641201b2db8427be2a6531c043f384562c081Chris Lattner BasicBlock *CurBB = GEP->getParent(); 4039a8641201b2db8427be2a6531c043f384562c081Chris Lattner for (unsigned i = 0, e = GEP->getNumOperands(); i != e; ++i) { 4049a8641201b2db8427be2a6531c043f384562c081Chris Lattner Value *OpVal = InsertPHITranslatedSubExpr(GEP->getOperand(i), 4059a8641201b2db8427be2a6531c043f384562c081Chris Lattner CurBB, PredBB, DT, NewInsts); 4069a8641201b2db8427be2a6531c043f384562c081Chris Lattner if (OpVal == 0) return 0; 4079a8641201b2db8427be2a6531c043f384562c081Chris Lattner GEPOps.push_back(OpVal); 4089a8641201b2db8427be2a6531c043f384562c081Chris Lattner } 4097feccd2af9160e28724eaa6701e49bf1c0db4920Dan Gohman 4107feccd2af9160e28724eaa6701e49bf1c0db4920Dan Gohman GetElementPtrInst *Result = 4112eb40f6d86ab44e7e642ea665afb28604008d367Frits van Bommel GetElementPtrInst::Create(GEPOps[0], makeArrayRef(GEPOps).slice(1), 412a9203109f4ac95aa7e9624f2838e3d89623ec902Jay Foad InVal->getName()+".phi.trans.insert", 413a9203109f4ac95aa7e9624f2838e3d89623ec902Jay Foad PredBB->getTerminator()); 4149a8641201b2db8427be2a6531c043f384562c081Chris Lattner Result->setIsInBounds(GEP->isInBounds()); 4159a8641201b2db8427be2a6531c043f384562c081Chris Lattner NewInsts.push_back(Result); 4169a8641201b2db8427be2a6531c043f384562c081Chris Lattner return Result; 4179a8641201b2db8427be2a6531c043f384562c081Chris Lattner } 4187feccd2af9160e28724eaa6701e49bf1c0db4920Dan Gohman 4199a8641201b2db8427be2a6531c043f384562c081Chris Lattner#if 0 4209a8641201b2db8427be2a6531c043f384562c081Chris Lattner // FIXME: This code works, but it is unclear that we actually want to insert 4219a8641201b2db8427be2a6531c043f384562c081Chris Lattner // a big chain of computation in order to make a value available in a block. 4229a8641201b2db8427be2a6531c043f384562c081Chris Lattner // This needs to be evaluated carefully to consider its cost trade offs. 4237feccd2af9160e28724eaa6701e49bf1c0db4920Dan Gohman 4249a8641201b2db8427be2a6531c043f384562c081Chris Lattner // Handle add with a constant RHS. 4259a8641201b2db8427be2a6531c043f384562c081Chris Lattner if (Inst->getOpcode() == Instruction::Add && 4269a8641201b2db8427be2a6531c043f384562c081Chris Lattner isa<ConstantInt>(Inst->getOperand(1))) { 4279a8641201b2db8427be2a6531c043f384562c081Chris Lattner // PHI translate the LHS. 4289a8641201b2db8427be2a6531c043f384562c081Chris Lattner Value *OpVal = InsertPHITranslatedSubExpr(Inst->getOperand(0), 4299a8641201b2db8427be2a6531c043f384562c081Chris Lattner CurBB, PredBB, DT, NewInsts); 4309a8641201b2db8427be2a6531c043f384562c081Chris Lattner if (OpVal == 0) return 0; 4317feccd2af9160e28724eaa6701e49bf1c0db4920Dan Gohman 4329a8641201b2db8427be2a6531c043f384562c081Chris Lattner BinaryOperator *Res = BinaryOperator::CreateAdd(OpVal, Inst->getOperand(1), 4339a8641201b2db8427be2a6531c043f384562c081Chris Lattner InVal->getName()+".phi.trans.insert", 4349a8641201b2db8427be2a6531c043f384562c081Chris Lattner PredBB->getTerminator()); 4359a8641201b2db8427be2a6531c043f384562c081Chris Lattner Res->setHasNoSignedWrap(cast<BinaryOperator>(Inst)->hasNoSignedWrap()); 4369a8641201b2db8427be2a6531c043f384562c081Chris Lattner Res->setHasNoUnsignedWrap(cast<BinaryOperator>(Inst)->hasNoUnsignedWrap()); 4379a8641201b2db8427be2a6531c043f384562c081Chris Lattner NewInsts.push_back(Res); 4389a8641201b2db8427be2a6531c043f384562c081Chris Lattner return Res; 4399a8641201b2db8427be2a6531c043f384562c081Chris Lattner } 4409a8641201b2db8427be2a6531c043f384562c081Chris Lattner#endif 4417feccd2af9160e28724eaa6701e49bf1c0db4920Dan Gohman 442210e45af3a579beeefb001c8f13c94e80407aad5Chris Lattner return 0; 443210e45af3a579beeefb001c8f13c94e80407aad5Chris Lattner} 444