ScalarReplAggregates.cpp revision 8fbbb3980755d74539a0aed02bc18842ed2bd18d
1ed7b41ea90a17c826f195acbc456c4bb733113d6Chris Lattner//===- ScalarReplAggregates.cpp - Scalar Replacement of Aggregates --------===// 2fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman// 3b576c94c15af9a440f69d9d03c2afead7971118cJohn Criswell// The LLVM Compiler Infrastructure 4b576c94c15af9a440f69d9d03c2afead7971118cJohn Criswell// 54ee451de366474b9c228b4e5fa573795a715216dChris Lattner// This file is distributed under the University of Illinois Open Source 64ee451de366474b9c228b4e5fa573795a715216dChris Lattner// License. See LICENSE.TXT for details. 7fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman// 8b576c94c15af9a440f69d9d03c2afead7971118cJohn Criswell//===----------------------------------------------------------------------===// 9ed7b41ea90a17c826f195acbc456c4bb733113d6Chris Lattner// 10ed7b41ea90a17c826f195acbc456c4bb733113d6Chris Lattner// This transformation implements the well known scalar replacement of 11ed7b41ea90a17c826f195acbc456c4bb733113d6Chris Lattner// aggregates transformation. This xform breaks up alloca instructions of 12ed7b41ea90a17c826f195acbc456c4bb733113d6Chris Lattner// aggregate type (structure or array) into individual alloca instructions for 1338aec325604635380421a27e39ab06d55ed2458dChris Lattner// each member (if possible). Then, if possible, it transforms the individual 1438aec325604635380421a27e39ab06d55ed2458dChris Lattner// alloca instructions into nice clean scalar SSA form. 1538aec325604635380421a27e39ab06d55ed2458dChris Lattner// 1638aec325604635380421a27e39ab06d55ed2458dChris Lattner// This combines a simple SRoA algorithm with the Mem2Reg algorithm because 1738aec325604635380421a27e39ab06d55ed2458dChris Lattner// often interact, especially for C++ programs. As such, iterating between 1838aec325604635380421a27e39ab06d55ed2458dChris Lattner// SRoA, then Mem2Reg until we run out of things to promote works well. 19ed7b41ea90a17c826f195acbc456c4bb733113d6Chris Lattner// 20ed7b41ea90a17c826f195acbc456c4bb733113d6Chris Lattner//===----------------------------------------------------------------------===// 21ed7b41ea90a17c826f195acbc456c4bb733113d6Chris Lattner 220e5f499638c8d277b9dc4a4385712177c53b5681Chris Lattner#define DEBUG_TYPE "scalarrepl" 23ed7b41ea90a17c826f195acbc456c4bb733113d6Chris Lattner#include "llvm/Transforms/Scalar.h" 2438aec325604635380421a27e39ab06d55ed2458dChris Lattner#include "llvm/Constants.h" 2538aec325604635380421a27e39ab06d55ed2458dChris Lattner#include "llvm/DerivedTypes.h" 26ed7b41ea90a17c826f195acbc456c4bb733113d6Chris Lattner#include "llvm/Function.h" 2779b3bd395dc3303cde65e18e0524ed2f70268c99Chris Lattner#include "llvm/GlobalVariable.h" 28d8e1eea678833cc2b15e4ea69a5a403ba9c3b013Misha Brukman#include "llvm/Instructions.h" 29372dda8881c7a32a6f5ce0f76a713e3a9ef46ea1Chris Lattner#include "llvm/IntrinsicInst.h" 30fa5cbd6d0fbda23fd669c8718e07b19001b2d21aOwen Anderson#include "llvm/LLVMContext.h" 3172eaa0e5eb345a8483608675b86dfcfa465c784cChris Lattner#include "llvm/Module.h" 32372dda8881c7a32a6f5ce0f76a713e3a9ef46ea1Chris Lattner#include "llvm/Pass.h" 334fd3c5957e6a272b60d6446e745136187d07f812Devang Patel#include "llvm/Analysis/DebugInfo.h" 34c827939046670a9800659b83e2048f1d3a79a531Cameron Zwarich#include "llvm/Analysis/DIBuilder.h" 35b1686c32fc694636cbf15a59b23b2a741b65ecf4Cameron Zwarich#include "llvm/Analysis/Dominators.h" 36c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner#include "llvm/Analysis/Loads.h" 375034dd318a9dfa0dc45a3ac01e58e60f2aa2498dDan Gohman#include "llvm/Analysis/ValueTracking.h" 3838aec325604635380421a27e39ab06d55ed2458dChris Lattner#include "llvm/Target/TargetData.h" 3938aec325604635380421a27e39ab06d55ed2458dChris Lattner#include "llvm/Transforms/Utils/PromoteMemToReg.h" 404afc90dacf309999d8b7f6c2b4b0c56af346bab5Devang Patel#include "llvm/Transforms/Utils/Local.h" 41e0a1a5ba91df6817f9ffae7af65ed0bda66f7620Chris Lattner#include "llvm/Transforms/Utils/SSAUpdater.h" 42a9be1df6d7a9b5a07253d83a634ae5876e7e5550Chris Lattner#include "llvm/Support/CallSite.h" 439525528a7dc5462b6374d38c81ba5c07b11741feChris Lattner#include "llvm/Support/Debug.h" 447d696d80409aad20bb5da0fc4eccab941dd371d4Torok Edwin#include "llvm/Support/ErrorHandling.h" 45a188894d67a3cc2516b25aae9b3cbdbff4b0babeChris Lattner#include "llvm/Support/GetElementPtrTypeIterator.h" 4665a650291d01638853aaf1e80fcc2fc86a785957Chris Lattner#include "llvm/Support/IRBuilder.h" 47a188894d67a3cc2516b25aae9b3cbdbff4b0babeChris Lattner#include "llvm/Support/MathExtras.h" 48bdff548e4dd577a72094d57b282de4e765643b96Chris Lattner#include "llvm/Support/raw_ostream.h" 49c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner#include "llvm/ADT/SetVector.h" 501ccd185cb49d81465a2901622e58ceae046d1d83Chris Lattner#include "llvm/ADT/SmallVector.h" 51551ccae044b0ff658fe629dd67edd5ffe75d10e8Reid Spencer#include "llvm/ADT/Statistic.h" 52d8664730942beb911327336d1f9db8e7efcd6813Chris Lattnerusing namespace llvm; 53d0fde30ce850b78371fd1386338350591f9ff494Brian Gaeke 540e5f499638c8d277b9dc4a4385712177c53b5681Chris LattnerSTATISTIC(NumReplaced, "Number of allocas broken up"); 550e5f499638c8d277b9dc4a4385712177c53b5681Chris LattnerSTATISTIC(NumPromoted, "Number of allocas promoted"); 56c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris LattnerSTATISTIC(NumAdjusted, "Number of scalar allocas adjusted to allow promotion"); 570e5f499638c8d277b9dc4a4385712177c53b5681Chris LattnerSTATISTIC(NumConverted, "Number of aggregates converted to scalar"); 5879b3bd395dc3303cde65e18e0524ed2f70268c99Chris LattnerSTATISTIC(NumGlobals, "Number of allocas copied from constant global"); 59ed7b41ea90a17c826f195acbc456c4bb733113d6Chris Lattner 600e5f499638c8d277b9dc4a4385712177c53b5681Chris Lattnernamespace { 613e8b6631e67e01e4960a7ba4668a50c596607473Chris Lattner struct SROA : public FunctionPass { 62b1686c32fc694636cbf15a59b23b2a741b65ecf4Cameron Zwarich SROA(int T, bool hasDT, char &ID) 63b1686c32fc694636cbf15a59b23b2a741b65ecf4Cameron Zwarich : FunctionPass(ID), HasDomTree(hasDT) { 64ff366850aa9956e167e78d4f5b57aae10d8c5779Devang Patel if (T == -1) 65b0e71edb6b33f822e001500dac90acf95faacea8Chris Lattner SRThreshold = 128; 66ff366850aa9956e167e78d4f5b57aae10d8c5779Devang Patel else 67ff366850aa9956e167e78d4f5b57aae10d8c5779Devang Patel SRThreshold = T; 68ff366850aa9956e167e78d4f5b57aae10d8c5779Devang Patel } 69794fd75c67a2cdc128d67342c6d88a504d186896Devang Patel 70ed7b41ea90a17c826f195acbc456c4bb733113d6Chris Lattner bool runOnFunction(Function &F); 71ed7b41ea90a17c826f195acbc456c4bb733113d6Chris Lattner 7238aec325604635380421a27e39ab06d55ed2458dChris Lattner bool performScalarRepl(Function &F); 7338aec325604635380421a27e39ab06d55ed2458dChris Lattner bool performPromotion(Function &F); 7438aec325604635380421a27e39ab06d55ed2458dChris Lattner 75ed7b41ea90a17c826f195acbc456c4bb733113d6Chris Lattner private: 76b1686c32fc694636cbf15a59b23b2a741b65ecf4Cameron Zwarich bool HasDomTree; 7756c3852fb46b7754ad89b998b5968cff0c3937eeChris Lattner TargetData *TD; 786974302e3ff20746268721959efed807c7711bfcBob Wilson 79b742defa0a8f3e477c3ed641da49aab276937556Bob Wilson /// DeadInsts - Keep track of instructions we have made dead, so that 80b742defa0a8f3e477c3ed641da49aab276937556Bob Wilson /// we can remove them after we are done working. 81b742defa0a8f3e477c3ed641da49aab276937556Bob Wilson SmallVector<Value*, 32> DeadInsts; 82b742defa0a8f3e477c3ed641da49aab276937556Bob Wilson 8339a1c04323a5993d6b2993e615ec44c16e19aeeaChris Lattner /// AllocaInfo - When analyzing uses of an alloca instruction, this captures 8439a1c04323a5993d6b2993e615ec44c16e19aeeaChris Lattner /// information about the uses. All these fields are initialized to false 8539a1c04323a5993d6b2993e615ec44c16e19aeeaChris Lattner /// and set to true when something is learned. 8639a1c04323a5993d6b2993e615ec44c16e19aeeaChris Lattner struct AllocaInfo { 876c95d24927b11fb76bc3e76ebe6a8198d74fc178Chris Lattner /// The alloca to promote. 886c95d24927b11fb76bc3e76ebe6a8198d74fc178Chris Lattner AllocaInst *AI; 896c95d24927b11fb76bc3e76ebe6a8198d74fc178Chris Lattner 90145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner /// CheckedPHIs - This is a set of verified PHI nodes, to prevent infinite 91145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner /// looping and avoid redundant work. 92145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner SmallPtrSet<PHINode*, 8> CheckedPHIs; 93145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner 9439a1c04323a5993d6b2993e615ec44c16e19aeeaChris Lattner /// isUnsafe - This is set to true if the alloca cannot be SROA'd. 9539a1c04323a5993d6b2993e615ec44c16e19aeeaChris Lattner bool isUnsafe : 1; 966974302e3ff20746268721959efed807c7711bfcBob Wilson 9739a1c04323a5993d6b2993e615ec44c16e19aeeaChris Lattner /// isMemCpySrc - This is true if this aggregate is memcpy'd from. 9839a1c04323a5993d6b2993e615ec44c16e19aeeaChris Lattner bool isMemCpySrc : 1; 9939a1c04323a5993d6b2993e615ec44c16e19aeeaChris Lattner 10033b0b8d242de8d428f11e77ea734a08b47797216Zhou Sheng /// isMemCpyDst - This is true if this aggregate is memcpy'd into. 10139a1c04323a5993d6b2993e615ec44c16e19aeeaChris Lattner bool isMemCpyDst : 1; 10239a1c04323a5993d6b2993e615ec44c16e19aeeaChris Lattner 1037e9b427c879ae32b72fd24aeaf011e87e5692fd7Chris Lattner /// hasSubelementAccess - This is true if a subelement of the alloca is 1047e9b427c879ae32b72fd24aeaf011e87e5692fd7Chris Lattner /// ever accessed, or false if the alloca is only accessed with mem 1057e9b427c879ae32b72fd24aeaf011e87e5692fd7Chris Lattner /// intrinsics or load/store that only access the entire alloca at once. 1067e9b427c879ae32b72fd24aeaf011e87e5692fd7Chris Lattner bool hasSubelementAccess : 1; 1077e9b427c879ae32b72fd24aeaf011e87e5692fd7Chris Lattner 1087e9b427c879ae32b72fd24aeaf011e87e5692fd7Chris Lattner /// hasALoadOrStore - This is true if there are any loads or stores to it. 1097e9b427c879ae32b72fd24aeaf011e87e5692fd7Chris Lattner /// The alloca may just be accessed with memcpy, for example, which would 1107e9b427c879ae32b72fd24aeaf011e87e5692fd7Chris Lattner /// not set this. 1117e9b427c879ae32b72fd24aeaf011e87e5692fd7Chris Lattner bool hasALoadOrStore : 1; 1127e9b427c879ae32b72fd24aeaf011e87e5692fd7Chris Lattner 1136c95d24927b11fb76bc3e76ebe6a8198d74fc178Chris Lattner explicit AllocaInfo(AllocaInst *ai) 1146c95d24927b11fb76bc3e76ebe6a8198d74fc178Chris Lattner : AI(ai), isUnsafe(false), isMemCpySrc(false), isMemCpyDst(false), 1157e9b427c879ae32b72fd24aeaf011e87e5692fd7Chris Lattner hasSubelementAccess(false), hasALoadOrStore(false) {} 11639a1c04323a5993d6b2993e615ec44c16e19aeeaChris Lattner }; 1176974302e3ff20746268721959efed807c7711bfcBob Wilson 118ff366850aa9956e167e78d4f5b57aae10d8c5779Devang Patel unsigned SRThreshold; 119ff366850aa9956e167e78d4f5b57aae10d8c5779Devang Patel 120d01a0da090407762fe3b770d84f049d72d06467eChris Lattner void MarkUnsafe(AllocaInfo &I, Instruction *User) { 121d01a0da090407762fe3b770d84f049d72d06467eChris Lattner I.isUnsafe = true; 122d01a0da090407762fe3b770d84f049d72d06467eChris Lattner DEBUG(dbgs() << " Transformation preventing inst: " << *User << '\n'); 123d01a0da090407762fe3b770d84f049d72d06467eChris Lattner } 12439a1c04323a5993d6b2993e615ec44c16e19aeeaChris Lattner 1256c146eefbf75875250af37a0f1ea70fc6b4716eeVictor Hernandez bool isSafeAllocaToScalarRepl(AllocaInst *AI); 12639a1c04323a5993d6b2993e615ec44c16e19aeeaChris Lattner 1276c95d24927b11fb76bc3e76ebe6a8198d74fc178Chris Lattner void isSafeForScalarRepl(Instruction *I, uint64_t Offset, AllocaInfo &Info); 128145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner void isSafePHISelectUseForScalarRepl(Instruction *User, uint64_t Offset, 129145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner AllocaInfo &Info); 1306c95d24927b11fb76bc3e76ebe6a8198d74fc178Chris Lattner void isSafeGEP(GetElementPtrInst *GEPI, uint64_t &Offset, AllocaInfo &Info); 1316c95d24927b11fb76bc3e76ebe6a8198d74fc178Chris Lattner void isSafeMemAccess(uint64_t Offset, uint64_t MemSize, 132db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *MemOpType, bool isStore, AllocaInfo &Info, 133145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner Instruction *TheAccess, bool AllowWholeAccess); 134db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner bool TypeHasComponent(Type *T, uint64_t Offset, uint64_t Size); 135db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner uint64_t FindElementAndOffset(Type *&T, uint64_t &Offset, 136db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *&IdxTy); 1376974302e3ff20746268721959efed807c7711bfcBob Wilson 1386974302e3ff20746268721959efed807c7711bfcBob Wilson void DoScalarReplacement(AllocaInst *AI, 1397b929dad59785f62a66f7c58615082f98441e95eVictor Hernandez std::vector<AllocaInst*> &WorkList); 140b742defa0a8f3e477c3ed641da49aab276937556Bob Wilson void DeleteDeadInstructions(); 1416974302e3ff20746268721959efed807c7711bfcBob Wilson 142b742defa0a8f3e477c3ed641da49aab276937556Bob Wilson void RewriteForScalarRepl(Instruction *I, AllocaInst *AI, uint64_t Offset, 143b742defa0a8f3e477c3ed641da49aab276937556Bob Wilson SmallVector<AllocaInst*, 32> &NewElts); 144b742defa0a8f3e477c3ed641da49aab276937556Bob Wilson void RewriteBitCast(BitCastInst *BC, AllocaInst *AI, uint64_t Offset, 145b742defa0a8f3e477c3ed641da49aab276937556Bob Wilson SmallVector<AllocaInst*, 32> &NewElts); 146b742defa0a8f3e477c3ed641da49aab276937556Bob Wilson void RewriteGEP(GetElementPtrInst *GEPI, AllocaInst *AI, uint64_t Offset, 147b742defa0a8f3e477c3ed641da49aab276937556Bob Wilson SmallVector<AllocaInst*, 32> &NewElts); 148b742defa0a8f3e477c3ed641da49aab276937556Bob Wilson void RewriteMemIntrinUserOfAlloca(MemIntrinsic *MI, Instruction *Inst, 1497b929dad59785f62a66f7c58615082f98441e95eVictor Hernandez AllocaInst *AI, 150d93afec1dbbb1abb3df55e2e007b5f256d09f84aChris Lattner SmallVector<AllocaInst*, 32> &NewElts); 1517b929dad59785f62a66f7c58615082f98441e95eVictor Hernandez void RewriteStoreUserOfWholeAlloca(StoreInst *SI, AllocaInst *AI, 152d2fa781169175b827e50953a1d0b7edc6b0c4801Chris Lattner SmallVector<AllocaInst*, 32> &NewElts); 1537b929dad59785f62a66f7c58615082f98441e95eVictor Hernandez void RewriteLoadUserOfWholeAlloca(LoadInst *LI, AllocaInst *AI, 1546e733d34ca487ab7ff8a6def018a933620393869Chris Lattner SmallVector<AllocaInst*, 32> &NewElts); 1556974302e3ff20746268721959efed807c7711bfcBob Wilson 1569174d5c7383490d79b6a483d73cded54e32275d6Nick Lewycky static MemTransferInst *isOnlyCopiedFromConstantGlobal( 1579174d5c7383490d79b6a483d73cded54e32275d6Nick Lewycky AllocaInst *AI, SmallVector<Instruction*, 4> &ToDelete); 158ed7b41ea90a17c826f195acbc456c4bb733113d6Chris Lattner }; 159b352d6eb49927a7c707cbd9046cfc525b0c3f2d7Chris Lattner 160b1686c32fc694636cbf15a59b23b2a741b65ecf4Cameron Zwarich // SROA_DT - SROA that uses DominatorTree. 161b1686c32fc694636cbf15a59b23b2a741b65ecf4Cameron Zwarich struct SROA_DT : public SROA { 162b352d6eb49927a7c707cbd9046cfc525b0c3f2d7Chris Lattner static char ID; 163b352d6eb49927a7c707cbd9046cfc525b0c3f2d7Chris Lattner public: 164b1686c32fc694636cbf15a59b23b2a741b65ecf4Cameron Zwarich SROA_DT(int T = -1) : SROA(T, true, ID) { 165b1686c32fc694636cbf15a59b23b2a741b65ecf4Cameron Zwarich initializeSROA_DTPass(*PassRegistry::getPassRegistry()); 166b352d6eb49927a7c707cbd9046cfc525b0c3f2d7Chris Lattner } 167b352d6eb49927a7c707cbd9046cfc525b0c3f2d7Chris Lattner 168b352d6eb49927a7c707cbd9046cfc525b0c3f2d7Chris Lattner // getAnalysisUsage - This pass does not require any passes, but we know it 169b352d6eb49927a7c707cbd9046cfc525b0c3f2d7Chris Lattner // will not alter the CFG, so say so. 170b352d6eb49927a7c707cbd9046cfc525b0c3f2d7Chris Lattner virtual void getAnalysisUsage(AnalysisUsage &AU) const { 171b352d6eb49927a7c707cbd9046cfc525b0c3f2d7Chris Lattner AU.addRequired<DominatorTree>(); 172b352d6eb49927a7c707cbd9046cfc525b0c3f2d7Chris Lattner AU.setPreservesCFG(); 173b352d6eb49927a7c707cbd9046cfc525b0c3f2d7Chris Lattner } 174b352d6eb49927a7c707cbd9046cfc525b0c3f2d7Chris Lattner }; 175b352d6eb49927a7c707cbd9046cfc525b0c3f2d7Chris Lattner 176b352d6eb49927a7c707cbd9046cfc525b0c3f2d7Chris Lattner // SROA_SSAUp - SROA that uses SSAUpdater. 177b352d6eb49927a7c707cbd9046cfc525b0c3f2d7Chris Lattner struct SROA_SSAUp : public SROA { 178b352d6eb49927a7c707cbd9046cfc525b0c3f2d7Chris Lattner static char ID; 179b352d6eb49927a7c707cbd9046cfc525b0c3f2d7Chris Lattner public: 180b352d6eb49927a7c707cbd9046cfc525b0c3f2d7Chris Lattner SROA_SSAUp(int T = -1) : SROA(T, false, ID) { 181b352d6eb49927a7c707cbd9046cfc525b0c3f2d7Chris Lattner initializeSROA_SSAUpPass(*PassRegistry::getPassRegistry()); 182b352d6eb49927a7c707cbd9046cfc525b0c3f2d7Chris Lattner } 183b352d6eb49927a7c707cbd9046cfc525b0c3f2d7Chris Lattner 184b352d6eb49927a7c707cbd9046cfc525b0c3f2d7Chris Lattner // getAnalysisUsage - This pass does not require any passes, but we know it 185b352d6eb49927a7c707cbd9046cfc525b0c3f2d7Chris Lattner // will not alter the CFG, so say so. 186b352d6eb49927a7c707cbd9046cfc525b0c3f2d7Chris Lattner virtual void getAnalysisUsage(AnalysisUsage &AU) const { 187b352d6eb49927a7c707cbd9046cfc525b0c3f2d7Chris Lattner AU.setPreservesCFG(); 188b352d6eb49927a7c707cbd9046cfc525b0c3f2d7Chris Lattner } 189b352d6eb49927a7c707cbd9046cfc525b0c3f2d7Chris Lattner }; 190b352d6eb49927a7c707cbd9046cfc525b0c3f2d7Chris Lattner 191ed7b41ea90a17c826f195acbc456c4bb733113d6Chris Lattner} 192ed7b41ea90a17c826f195acbc456c4bb733113d6Chris Lattner 193b1686c32fc694636cbf15a59b23b2a741b65ecf4Cameron Zwarichchar SROA_DT::ID = 0; 194b352d6eb49927a7c707cbd9046cfc525b0c3f2d7Chris Lattnerchar SROA_SSAUp::ID = 0; 195b352d6eb49927a7c707cbd9046cfc525b0c3f2d7Chris Lattner 196b1686c32fc694636cbf15a59b23b2a741b65ecf4Cameron ZwarichINITIALIZE_PASS_BEGIN(SROA_DT, "scalarrepl", 197b1686c32fc694636cbf15a59b23b2a741b65ecf4Cameron Zwarich "Scalar Replacement of Aggregates (DT)", false, false) 1982ab36d350293c77fc8941ce1023e4899df7e3a82Owen AndersonINITIALIZE_PASS_DEPENDENCY(DominatorTree) 199b1686c32fc694636cbf15a59b23b2a741b65ecf4Cameron ZwarichINITIALIZE_PASS_END(SROA_DT, "scalarrepl", 200b1686c32fc694636cbf15a59b23b2a741b65ecf4Cameron Zwarich "Scalar Replacement of Aggregates (DT)", false, false) 201b352d6eb49927a7c707cbd9046cfc525b0c3f2d7Chris Lattner 202b352d6eb49927a7c707cbd9046cfc525b0c3f2d7Chris LattnerINITIALIZE_PASS_BEGIN(SROA_SSAUp, "scalarrepl-ssa", 203b352d6eb49927a7c707cbd9046cfc525b0c3f2d7Chris Lattner "Scalar Replacement of Aggregates (SSAUp)", false, false) 204b352d6eb49927a7c707cbd9046cfc525b0c3f2d7Chris LattnerINITIALIZE_PASS_END(SROA_SSAUp, "scalarrepl-ssa", 205b352d6eb49927a7c707cbd9046cfc525b0c3f2d7Chris Lattner "Scalar Replacement of Aggregates (SSAUp)", false, false) 206844731a7f1909f55935e3514c9e713a62d67662eDan Gohman 207d0fde30ce850b78371fd1386338350591f9ff494Brian Gaeke// Public interface to the ScalarReplAggregates pass 208b352d6eb49927a7c707cbd9046cfc525b0c3f2d7Chris LattnerFunctionPass *llvm::createScalarReplAggregatesPass(int Threshold, 209b1686c32fc694636cbf15a59b23b2a741b65ecf4Cameron Zwarich bool UseDomTree) { 210b1686c32fc694636cbf15a59b23b2a741b65ecf4Cameron Zwarich if (UseDomTree) 211b1686c32fc694636cbf15a59b23b2a741b65ecf4Cameron Zwarich return new SROA_DT(Threshold); 212b352d6eb49927a7c707cbd9046cfc525b0c3f2d7Chris Lattner return new SROA_SSAUp(Threshold); 213ff366850aa9956e167e78d4f5b57aae10d8c5779Devang Patel} 214ed7b41ea90a17c826f195acbc456c4bb733113d6Chris Lattner 215ed7b41ea90a17c826f195acbc456c4bb733113d6Chris Lattner 2164cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner//===----------------------------------------------------------------------===// 2174cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner// Convert To Scalar Optimization. 2184cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner//===----------------------------------------------------------------------===// 219963a97f1a365c8d09ca681e922371f9ec3473ee8Chris Lattner 220c4472072641f702dbd99ae12b7da089e75c44a99Chris Lattnernamespace { 221a001b664988f759d194f3d5d880c61449219fc2eChris Lattner/// ConvertToScalarInfo - This class implements the "Convert To Scalar" 222a001b664988f759d194f3d5d880c61449219fc2eChris Lattner/// optimization, which scans the uses of an alloca and determines if it can 223a001b664988f759d194f3d5d880c61449219fc2eChris Lattner/// rewrite it in terms of a single new alloca that can be mem2reg'd. 2244cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattnerclass ConvertToScalarInfo { 225d4c9c3e6b97e095c24d989c0f5ce763f90100ef1Cameron Zwarich /// AllocaSize - The size of the alloca being considered in bytes. 226c4472072641f702dbd99ae12b7da089e75c44a99Chris Lattner unsigned AllocaSize; 227593375d04ab32be0161607a741d310172f142b93Chris Lattner const TargetData &TD; 2286974302e3ff20746268721959efed807c7711bfcBob Wilson 229a0bada729ffaa1bfc80ef25935bdc5a67432708fChris Lattner /// IsNotTrivial - This is set to true if there is some access to the object 230a001b664988f759d194f3d5d880c61449219fc2eChris Lattner /// which means that mem2reg can't promote it. 231c4472072641f702dbd99ae12b7da089e75c44a99Chris Lattner bool IsNotTrivial; 2326974302e3ff20746268721959efed807c7711bfcBob Wilson 233deb74f21f205aa245568ea965132eb076a3bf88cCameron Zwarich /// ScalarKind - Tracks the kind of alloca being considered for promotion, 234deb74f21f205aa245568ea965132eb076a3bf88cCameron Zwarich /// computed based on the uses of the alloca rather than the LLVM type system. 235deb74f21f205aa245568ea965132eb076a3bf88cCameron Zwarich enum { 236deb74f21f205aa245568ea965132eb076a3bf88cCameron Zwarich Unknown, 2375179782cf03cfabfe89df71677e0ffc772b5fdd5Cameron Zwarich 23815cd80c16b4e63b99dcbe45d2baa9456d414aacaCameron Zwarich // Accesses via GEPs that are consistent with element access of a vector 2395179782cf03cfabfe89df71677e0ffc772b5fdd5Cameron Zwarich // type. This will not be converted into a vector unless there is a later 2405179782cf03cfabfe89df71677e0ffc772b5fdd5Cameron Zwarich // access using an actual vector type. 2415179782cf03cfabfe89df71677e0ffc772b5fdd5Cameron Zwarich ImplicitVector, 2425179782cf03cfabfe89df71677e0ffc772b5fdd5Cameron Zwarich 24315cd80c16b4e63b99dcbe45d2baa9456d414aacaCameron Zwarich // Accesses via vector operations and GEPs that are consistent with the 24415cd80c16b4e63b99dcbe45d2baa9456d414aacaCameron Zwarich // layout of a vector type. 245deb74f21f205aa245568ea965132eb076a3bf88cCameron Zwarich Vector, 2465179782cf03cfabfe89df71677e0ffc772b5fdd5Cameron Zwarich 2475179782cf03cfabfe89df71677e0ffc772b5fdd5Cameron Zwarich // An integer bag-of-bits with bitwise operations for insertion and 2485179782cf03cfabfe89df71677e0ffc772b5fdd5Cameron Zwarich // extraction. Any combination of types can be converted into this kind 2495179782cf03cfabfe89df71677e0ffc772b5fdd5Cameron Zwarich // of scalar. 250deb74f21f205aa245568ea965132eb076a3bf88cCameron Zwarich Integer 251deb74f21f205aa245568ea965132eb076a3bf88cCameron Zwarich } ScalarKind; 252deb74f21f205aa245568ea965132eb076a3bf88cCameron Zwarich 253a001b664988f759d194f3d5d880c61449219fc2eChris Lattner /// VectorTy - This tracks the type that we should promote the vector to if 254a001b664988f759d194f3d5d880c61449219fc2eChris Lattner /// it is possible to turn it into a vector. This starts out null, and if it 255a001b664988f759d194f3d5d880c61449219fc2eChris Lattner /// isn't possible to turn into a vector type, it gets set to VoidTy. 256db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner VectorType *VectorTy; 2576974302e3ff20746268721959efed807c7711bfcBob Wilson 2581bcdb6ffad79936a96b46080bf0fed867243b32aCameron Zwarich /// HadNonMemTransferAccess - True if there is at least one access to the 2591bcdb6ffad79936a96b46080bf0fed867243b32aCameron Zwarich /// alloca that is not a MemTransferInst. We don't want to turn structs into 2601bcdb6ffad79936a96b46080bf0fed867243b32aCameron Zwarich /// large integers unless there is some potential for optimization. 26185b0f468cf8390fca3ec356cd498ce0039dbad4fCameron Zwarich bool HadNonMemTransferAccess; 26285b0f468cf8390fca3ec356cd498ce0039dbad4fCameron Zwarich 2634cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattnerpublic: 264593375d04ab32be0161607a741d310172f142b93Chris Lattner explicit ConvertToScalarInfo(unsigned Size, const TargetData &td) 265deb74f21f205aa245568ea965132eb076a3bf88cCameron Zwarich : AllocaSize(Size), TD(td), IsNotTrivial(false), ScalarKind(Unknown), 2665179782cf03cfabfe89df71677e0ffc772b5fdd5Cameron Zwarich VectorTy(0), HadNonMemTransferAccess(false) { } 2676974302e3ff20746268721959efed807c7711bfcBob Wilson 268a001b664988f759d194f3d5d880c61449219fc2eChris Lattner AllocaInst *TryConvert(AllocaInst *AI); 2696974302e3ff20746268721959efed807c7711bfcBob Wilson 2704cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattnerprivate: 271593375d04ab32be0161607a741d310172f142b93Chris Lattner bool CanConvertToScalar(Value *V, uint64_t Offset); 272db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner void MergeInTypeForLoadOrStore(Type *In, uint64_t Offset); 273db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner bool MergeInVectorType(VectorType *VInTy, uint64_t Offset); 274593375d04ab32be0161607a741d310172f142b93Chris Lattner void ConvertUsesToScalar(Value *Ptr, AllocaInst *NewAI, uint64_t Offset); 2756974302e3ff20746268721959efed807c7711bfcBob Wilson 276db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Value *ConvertScalar_ExtractValue(Value *NV, Type *ToType, 277593375d04ab32be0161607a741d310172f142b93Chris Lattner uint64_t Offset, IRBuilder<> &Builder); 278593375d04ab32be0161607a741d310172f142b93Chris Lattner Value *ConvertScalar_InsertValue(Value *StoredVal, Value *ExistingVal, 279593375d04ab32be0161607a741d310172f142b93Chris Lattner uint64_t Offset, IRBuilder<> &Builder); 280c4472072641f702dbd99ae12b7da089e75c44a99Chris Lattner}; 281c4472072641f702dbd99ae12b7da089e75c44a99Chris Lattner} // end anonymous namespace. 282c4472072641f702dbd99ae12b7da089e75c44a99Chris Lattner 28391abace4ef6fdfe01bcebfb8e90938e71f8a5c4fChris Lattner 284a001b664988f759d194f3d5d880c61449219fc2eChris Lattner/// TryConvert - Analyze the specified alloca, and if it is safe to do so, 285a001b664988f759d194f3d5d880c61449219fc2eChris Lattner/// rewrite it to be a new alloca which is mem2reg'able. This returns the new 286a001b664988f759d194f3d5d880c61449219fc2eChris Lattner/// alloca if possible or null if not. 287a001b664988f759d194f3d5d880c61449219fc2eChris LattnerAllocaInst *ConvertToScalarInfo::TryConvert(AllocaInst *AI) { 288a001b664988f759d194f3d5d880c61449219fc2eChris Lattner // If we can't convert this scalar, or if mem2reg can trivially do it, bail 289a001b664988f759d194f3d5d880c61449219fc2eChris Lattner // out. 290a001b664988f759d194f3d5d880c61449219fc2eChris Lattner if (!CanConvertToScalar(AI, 0) || !IsNotTrivial) 291a001b664988f759d194f3d5d880c61449219fc2eChris Lattner return 0; 2926974302e3ff20746268721959efed807c7711bfcBob Wilson 2935179782cf03cfabfe89df71677e0ffc772b5fdd5Cameron Zwarich // If an alloca has only memset / memcpy uses, it may still have an Unknown 2945179782cf03cfabfe89df71677e0ffc772b5fdd5Cameron Zwarich // ScalarKind. Treat it as an Integer below. 2955179782cf03cfabfe89df71677e0ffc772b5fdd5Cameron Zwarich if (ScalarKind == Unknown) 2965179782cf03cfabfe89df71677e0ffc772b5fdd5Cameron Zwarich ScalarKind = Integer; 2975179782cf03cfabfe89df71677e0ffc772b5fdd5Cameron Zwarich 2983ebb05d9a6bf6604a4b25770cfda1872983b03b2Cameron Zwarich // FIXME: It should be possible to promote the vector type up to the alloca's 2993ebb05d9a6bf6604a4b25770cfda1872983b03b2Cameron Zwarich // size. 3003ebb05d9a6bf6604a4b25770cfda1872983b03b2Cameron Zwarich if (ScalarKind == Vector && VectorTy->getBitWidth() != AllocaSize * 8) 3013ebb05d9a6bf6604a4b25770cfda1872983b03b2Cameron Zwarich ScalarKind = Integer; 3023ebb05d9a6bf6604a4b25770cfda1872983b03b2Cameron Zwarich 303a001b664988f759d194f3d5d880c61449219fc2eChris Lattner // If we were able to find a vector type that can handle this with 304a001b664988f759d194f3d5d880c61449219fc2eChris Lattner // insert/extract elements, and if there was at least one use that had 305a001b664988f759d194f3d5d880c61449219fc2eChris Lattner // a vector type, promote this to a vector. We don't want to promote 306a001b664988f759d194f3d5d880c61449219fc2eChris Lattner // random stuff that doesn't use vectors (e.g. <9 x double>) because then 307a001b664988f759d194f3d5d880c61449219fc2eChris Lattner // we just get a lot of insert/extracts. If at least one vector is 308a001b664988f759d194f3d5d880c61449219fc2eChris Lattner // involved, then we probably really do have a union of vector/array. 309db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *NewTy; 3105b93d3ca6f9c6e81924063abb1487598906dcdabCameron Zwarich if (ScalarKind == Vector) { 3115b93d3ca6f9c6e81924063abb1487598906dcdabCameron Zwarich assert(VectorTy && "Missing type for vector scalar."); 312a001b664988f759d194f3d5d880c61449219fc2eChris Lattner DEBUG(dbgs() << "CONVERT TO VECTOR: " << *AI << "\n TYPE = " 313a001b664988f759d194f3d5d880c61449219fc2eChris Lattner << *VectorTy << '\n'); 314a001b664988f759d194f3d5d880c61449219fc2eChris Lattner NewTy = VectorTy; // Use the vector type. 315a001b664988f759d194f3d5d880c61449219fc2eChris Lattner } else { 31685b0f468cf8390fca3ec356cd498ce0039dbad4fCameron Zwarich unsigned BitWidth = AllocaSize * 8; 3175179782cf03cfabfe89df71677e0ffc772b5fdd5Cameron Zwarich if ((ScalarKind == ImplicitVector || ScalarKind == Integer) && 3185179782cf03cfabfe89df71677e0ffc772b5fdd5Cameron Zwarich !HadNonMemTransferAccess && !TD.fitsInLegalInteger(BitWidth)) 31985b0f468cf8390fca3ec356cd498ce0039dbad4fCameron Zwarich return 0; 32085b0f468cf8390fca3ec356cd498ce0039dbad4fCameron Zwarich 321a001b664988f759d194f3d5d880c61449219fc2eChris Lattner DEBUG(dbgs() << "CONVERT TO SCALAR INTEGER: " << *AI << "\n"); 322a001b664988f759d194f3d5d880c61449219fc2eChris Lattner // Create and insert the integer alloca. 32385b0f468cf8390fca3ec356cd498ce0039dbad4fCameron Zwarich NewTy = IntegerType::get(AI->getContext(), BitWidth); 324a001b664988f759d194f3d5d880c61449219fc2eChris Lattner } 325a001b664988f759d194f3d5d880c61449219fc2eChris Lattner AllocaInst *NewAI = new AllocaInst(NewTy, 0, "", AI->getParent()->begin()); 326a001b664988f759d194f3d5d880c61449219fc2eChris Lattner ConvertUsesToScalar(AI, NewAI, 0); 327a001b664988f759d194f3d5d880c61449219fc2eChris Lattner return NewAI; 328a001b664988f759d194f3d5d880c61449219fc2eChris Lattner} 329a001b664988f759d194f3d5d880c61449219fc2eChris Lattner 330c0e2607564c1259f2d2c56cbff8f78dc0853860dCameron Zwarich/// MergeInTypeForLoadOrStore - Add the 'In' type to the accumulated vector type 331c0e2607564c1259f2d2c56cbff8f78dc0853860dCameron Zwarich/// (VectorTy) so far at the offset specified by Offset (which is specified in 332c0e2607564c1259f2d2c56cbff8f78dc0853860dCameron Zwarich/// bytes). 3334cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// 334b2fd770136b92637c5f084b743eab29f910288d5Cameron Zwarich/// There are three cases we handle here: 3354cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// 1) A union of vector types of the same size and potentially its elements. 3364cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// Here we turn element accesses into insert/extract element operations. 3374cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// This promotes a <4 x float> with a store of float to the third element 3384cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// into a <4 x float> that uses insert element. 339b2fd770136b92637c5f084b743eab29f910288d5Cameron Zwarich/// 2) A union of vector types with power-of-2 size differences, e.g. a float, 340b2fd770136b92637c5f084b743eab29f910288d5Cameron Zwarich/// <2 x float> and <4 x float>. Here we turn element accesses into insert 341b2fd770136b92637c5f084b743eab29f910288d5Cameron Zwarich/// and extract element operations, and <2 x float> accesses into a cast to 342b2fd770136b92637c5f084b743eab29f910288d5Cameron Zwarich/// <2 x double>, an extract, and a cast back to <2 x float>. 343b2fd770136b92637c5f084b743eab29f910288d5Cameron Zwarich/// 3) A fully general blob of memory, which we turn into some (potentially 3444cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// large) integer type with extract and insert operations where the loads 345a001b664988f759d194f3d5d880c61449219fc2eChris Lattner/// and stores would mutate the memory. We mark this by setting VectorTy 346a001b664988f759d194f3d5d880c61449219fc2eChris Lattner/// to VoidTy. 347db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattnervoid ConvertToScalarInfo::MergeInTypeForLoadOrStore(Type *In, 348c0e2607564c1259f2d2c56cbff8f78dc0853860dCameron Zwarich uint64_t Offset) { 349a001b664988f759d194f3d5d880c61449219fc2eChris Lattner // If we already decided to turn this into a blob of integer memory, there is 350a001b664988f759d194f3d5d880c61449219fc2eChris Lattner // nothing to be done. 351deb74f21f205aa245568ea965132eb076a3bf88cCameron Zwarich if (ScalarKind == Integer) 3524cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner return; 3536974302e3ff20746268721959efed807c7711bfcBob Wilson 3544cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // If this could be contributing to a vector, analyze it. 355c4472072641f702dbd99ae12b7da089e75c44a99Chris Lattner 3564cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // If the In type is a vector that is the same size as the alloca, see if it 3574cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // matches the existing VecTy. 358db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner if (VectorType *VInTy = dyn_cast<VectorType>(In)) { 359c9ecd14cee020f884313b60f8696384d3e7848f7Cameron Zwarich if (MergeInVectorType(VInTy, Offset)) 3604cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner return; 3614cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } else if (In->isFloatTy() || In->isDoubleTy() || 3624cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner (In->isIntegerTy() && In->getPrimitiveSizeInBits() >= 8 && 3634cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner isPowerOf2_32(In->getPrimitiveSizeInBits()))) { 3649827b78b51f285e90c2b1e5add9b28d10c88595cCameron Zwarich // Full width accesses can be ignored, because they can always be turned 3659827b78b51f285e90c2b1e5add9b28d10c88595cCameron Zwarich // into bitcasts. 3669827b78b51f285e90c2b1e5add9b28d10c88595cCameron Zwarich unsigned EltSize = In->getPrimitiveSizeInBits()/8; 367dd68912801861273dc3dca33cfc18357213049a4Cameron Zwarich if (EltSize == AllocaSize) 3689827b78b51f285e90c2b1e5add9b28d10c88595cCameron Zwarich return; 3695fc1282c1822d692ed1681cdc4c315950c6eb1d8Cameron Zwarich 3704cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // If we're accessing something that could be an element of a vector, see 3714cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // if the implied vector agrees with what we already have and if Offset is 3724cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // compatible with it. 37396cc1d0dfbcf9c7ffffc65f0aa008ff532d444f4Cameron Zwarich if (Offset % EltSize == 0 && AllocaSize % EltSize == 0 && 374c4f78208b399111cc4f5d97ed1875566819f34b4Cameron Zwarich (!VectorTy || Offset * 8 < VectorTy->getPrimitiveSizeInBits())) { 3755fc1282c1822d692ed1681cdc4c315950c6eb1d8Cameron Zwarich if (!VectorTy) { 3765179782cf03cfabfe89df71677e0ffc772b5fdd5Cameron Zwarich ScalarKind = ImplicitVector; 3774cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner VectorTy = VectorType::get(In, AllocaSize/EltSize); 3785fc1282c1822d692ed1681cdc4c315950c6eb1d8Cameron Zwarich return; 3795fc1282c1822d692ed1681cdc4c315950c6eb1d8Cameron Zwarich } 3805fc1282c1822d692ed1681cdc4c315950c6eb1d8Cameron Zwarich 381deb74f21f205aa245568ea965132eb076a3bf88cCameron Zwarich unsigned CurrentEltSize = VectorTy->getElementType() 3825fc1282c1822d692ed1681cdc4c315950c6eb1d8Cameron Zwarich ->getPrimitiveSizeInBits()/8; 3835fc1282c1822d692ed1681cdc4c315950c6eb1d8Cameron Zwarich if (EltSize == CurrentEltSize) 3845fc1282c1822d692ed1681cdc4c315950c6eb1d8Cameron Zwarich return; 385344731c01805aeda49c747bac6148501fa85557cCameron Zwarich 386344731c01805aeda49c747bac6148501fa85557cCameron Zwarich if (In->isIntegerTy() && isPowerOf2_32(AllocaSize / EltSize)) 387344731c01805aeda49c747bac6148501fa85557cCameron Zwarich return; 3884cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 3894cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 3906974302e3ff20746268721959efed807c7711bfcBob Wilson 3914cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Otherwise, we have a case that we can't handle with an optimized vector 3924cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // form. We can still turn this into a large integer. 393deb74f21f205aa245568ea965132eb076a3bf88cCameron Zwarich ScalarKind = Integer; 3944cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner} 395c4472072641f702dbd99ae12b7da089e75c44a99Chris Lattner 396c0e2607564c1259f2d2c56cbff8f78dc0853860dCameron Zwarich/// MergeInVectorType - Handles the vector case of MergeInTypeForLoadOrStore, 397c0e2607564c1259f2d2c56cbff8f78dc0853860dCameron Zwarich/// returning true if the type was successfully merged and false otherwise. 398db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattnerbool ConvertToScalarInfo::MergeInVectorType(VectorType *VInTy, 399c9ecd14cee020f884313b60f8696384d3e7848f7Cameron Zwarich uint64_t Offset) { 400b2fd770136b92637c5f084b743eab29f910288d5Cameron Zwarich // TODO: Support nonzero offsets? 401b2fd770136b92637c5f084b743eab29f910288d5Cameron Zwarich if (Offset != 0) 402b2fd770136b92637c5f084b743eab29f910288d5Cameron Zwarich return false; 403b2fd770136b92637c5f084b743eab29f910288d5Cameron Zwarich 404b2fd770136b92637c5f084b743eab29f910288d5Cameron Zwarich // Only allow vectors that are a power-of-2 away from the size of the alloca. 405b2fd770136b92637c5f084b743eab29f910288d5Cameron Zwarich if (!isPowerOf2_64(AllocaSize / (VInTy->getBitWidth() / 8))) 406b2fd770136b92637c5f084b743eab29f910288d5Cameron Zwarich return false; 407b2fd770136b92637c5f084b743eab29f910288d5Cameron Zwarich 408b2fd770136b92637c5f084b743eab29f910288d5Cameron Zwarich // If this the first vector we see, remember the type so that we know the 409b2fd770136b92637c5f084b743eab29f910288d5Cameron Zwarich // element size. 410b2fd770136b92637c5f084b743eab29f910288d5Cameron Zwarich if (!VectorTy) { 411deb74f21f205aa245568ea965132eb076a3bf88cCameron Zwarich ScalarKind = Vector; 412b2fd770136b92637c5f084b743eab29f910288d5Cameron Zwarich VectorTy = VInTy; 413c9ecd14cee020f884313b60f8696384d3e7848f7Cameron Zwarich return true; 414c9ecd14cee020f884313b60f8696384d3e7848f7Cameron Zwarich } 415c9ecd14cee020f884313b60f8696384d3e7848f7Cameron Zwarich 416deb74f21f205aa245568ea965132eb076a3bf88cCameron Zwarich unsigned BitWidth = VectorTy->getBitWidth(); 417b2fd770136b92637c5f084b743eab29f910288d5Cameron Zwarich unsigned InBitWidth = VInTy->getBitWidth(); 418b2fd770136b92637c5f084b743eab29f910288d5Cameron Zwarich 419b2fd770136b92637c5f084b743eab29f910288d5Cameron Zwarich // Vectors of the same size can be converted using a simple bitcast. 4205179782cf03cfabfe89df71677e0ffc772b5fdd5Cameron Zwarich if (InBitWidth == BitWidth && AllocaSize == (InBitWidth / 8)) { 4215179782cf03cfabfe89df71677e0ffc772b5fdd5Cameron Zwarich ScalarKind = Vector; 422b2fd770136b92637c5f084b743eab29f910288d5Cameron Zwarich return true; 4235179782cf03cfabfe89df71677e0ffc772b5fdd5Cameron Zwarich } 424b2fd770136b92637c5f084b743eab29f910288d5Cameron Zwarich 425db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *ElementTy = VectorTy->getElementType(); 426db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *InElementTy = VInTy->getElementType(); 427b2fd770136b92637c5f084b743eab29f910288d5Cameron Zwarich 428b2fd770136b92637c5f084b743eab29f910288d5Cameron Zwarich // Do not allow mixed integer and floating-point accesses from vectors of 429b2fd770136b92637c5f084b743eab29f910288d5Cameron Zwarich // different sizes. 430b2fd770136b92637c5f084b743eab29f910288d5Cameron Zwarich if (ElementTy->isFloatingPointTy() != InElementTy->isFloatingPointTy()) 431b2fd770136b92637c5f084b743eab29f910288d5Cameron Zwarich return false; 432b2fd770136b92637c5f084b743eab29f910288d5Cameron Zwarich 433b2fd770136b92637c5f084b743eab29f910288d5Cameron Zwarich if (ElementTy->isFloatingPointTy()) { 434b2fd770136b92637c5f084b743eab29f910288d5Cameron Zwarich // Only allow floating-point vectors of different sizes if they have the 435b2fd770136b92637c5f084b743eab29f910288d5Cameron Zwarich // same element type. 436b2fd770136b92637c5f084b743eab29f910288d5Cameron Zwarich // TODO: This could be loosened a bit, but would anything benefit? 437b2fd770136b92637c5f084b743eab29f910288d5Cameron Zwarich if (ElementTy != InElementTy) 438b2fd770136b92637c5f084b743eab29f910288d5Cameron Zwarich return false; 439b2fd770136b92637c5f084b743eab29f910288d5Cameron Zwarich 440b2fd770136b92637c5f084b743eab29f910288d5Cameron Zwarich // There are no arbitrary-precision floating-point types, which limits the 441b2fd770136b92637c5f084b743eab29f910288d5Cameron Zwarich // number of legal vector types with larger element types that we can form 442b2fd770136b92637c5f084b743eab29f910288d5Cameron Zwarich // to bitcast and extract a subvector. 443b2fd770136b92637c5f084b743eab29f910288d5Cameron Zwarich // TODO: We could support some more cases with mixed fp128 and double here. 444b2fd770136b92637c5f084b743eab29f910288d5Cameron Zwarich if (!(BitWidth == 64 || BitWidth == 128) || 445b2fd770136b92637c5f084b743eab29f910288d5Cameron Zwarich !(InBitWidth == 64 || InBitWidth == 128)) 446b2fd770136b92637c5f084b743eab29f910288d5Cameron Zwarich return false; 447b2fd770136b92637c5f084b743eab29f910288d5Cameron Zwarich } else { 448b2fd770136b92637c5f084b743eab29f910288d5Cameron Zwarich assert(ElementTy->isIntegerTy() && "Vector elements must be either integer " 449b2fd770136b92637c5f084b743eab29f910288d5Cameron Zwarich "or floating-point."); 450b2fd770136b92637c5f084b743eab29f910288d5Cameron Zwarich unsigned BitWidth = ElementTy->getPrimitiveSizeInBits(); 451b2fd770136b92637c5f084b743eab29f910288d5Cameron Zwarich unsigned InBitWidth = InElementTy->getPrimitiveSizeInBits(); 452b2fd770136b92637c5f084b743eab29f910288d5Cameron Zwarich 453b2fd770136b92637c5f084b743eab29f910288d5Cameron Zwarich // Do not allow integer types smaller than a byte or types whose widths are 454b2fd770136b92637c5f084b743eab29f910288d5Cameron Zwarich // not a multiple of a byte. 455b2fd770136b92637c5f084b743eab29f910288d5Cameron Zwarich if (BitWidth < 8 || InBitWidth < 8 || 456b2fd770136b92637c5f084b743eab29f910288d5Cameron Zwarich BitWidth % 8 != 0 || InBitWidth % 8 != 0) 457b2fd770136b92637c5f084b743eab29f910288d5Cameron Zwarich return false; 458b2fd770136b92637c5f084b743eab29f910288d5Cameron Zwarich } 459b2fd770136b92637c5f084b743eab29f910288d5Cameron Zwarich 460b2fd770136b92637c5f084b743eab29f910288d5Cameron Zwarich // Pick the largest of the two vector types. 4615179782cf03cfabfe89df71677e0ffc772b5fdd5Cameron Zwarich ScalarKind = Vector; 462b2fd770136b92637c5f084b743eab29f910288d5Cameron Zwarich if (InBitWidth > BitWidth) 463b2fd770136b92637c5f084b743eab29f910288d5Cameron Zwarich VectorTy = VInTy; 464b2fd770136b92637c5f084b743eab29f910288d5Cameron Zwarich 465b2fd770136b92637c5f084b743eab29f910288d5Cameron Zwarich return true; 466c9ecd14cee020f884313b60f8696384d3e7848f7Cameron Zwarich} 467c9ecd14cee020f884313b60f8696384d3e7848f7Cameron Zwarich 4684cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// CanConvertToScalar - V is a pointer. If we can convert the pointee and all 4694cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// its accesses to a single vector type, return true and set VecTy to 4704cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// the new type. If we could convert the alloca into a single promotable 4714cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// integer, return true but set VecTy to VoidTy. Further, if the use is not a 4724cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// completely trivial use that mem2reg could promote, set IsNotTrivial. Offset 4734cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// is the current offset from the base of the alloca being analyzed. 4744cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// 4754cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// If we see at least one access to the value that is as a vector type, set the 4764cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// SawVec flag. 4774cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattnerbool ConvertToScalarInfo::CanConvertToScalar(Value *V, uint64_t Offset) { 4784cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner for (Value::use_iterator UI = V->use_begin(), E = V->use_end(); UI!=E; ++UI) { 4794cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Instruction *User = cast<Instruction>(*UI); 4806974302e3ff20746268721959efed807c7711bfcBob Wilson 4814cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (LoadInst *LI = dyn_cast<LoadInst>(User)) { 4824cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Don't break volatile loads. 4834cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (LI->isVolatile()) 4844cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner return false; 4850488fb649a56b7fc89a5814df5308813f9e5a85dDale Johannesen // Don't touch MMX operations. 4860488fb649a56b7fc89a5814df5308813f9e5a85dDale Johannesen if (LI->getType()->isX86_MMXTy()) 4870488fb649a56b7fc89a5814df5308813f9e5a85dDale Johannesen return false; 48885b0f468cf8390fca3ec356cd498ce0039dbad4fCameron Zwarich HadNonMemTransferAccess = true; 489c0e2607564c1259f2d2c56cbff8f78dc0853860dCameron Zwarich MergeInTypeForLoadOrStore(LI->getType(), Offset); 490add2bd7f5941537a97a41e037ae2277fbeed0b4fChris Lattner continue; 491add2bd7f5941537a97a41e037ae2277fbeed0b4fChris Lattner } 4926974302e3ff20746268721959efed807c7711bfcBob Wilson 4934cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (StoreInst *SI = dyn_cast<StoreInst>(User)) { 4944cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Storing the pointer, not into the value? 4954cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (SI->getOperand(0) == V || SI->isVolatile()) return false; 4960488fb649a56b7fc89a5814df5308813f9e5a85dDale Johannesen // Don't touch MMX operations. 4970488fb649a56b7fc89a5814df5308813f9e5a85dDale Johannesen if (SI->getOperand(0)->getType()->isX86_MMXTy()) 4980488fb649a56b7fc89a5814df5308813f9e5a85dDale Johannesen return false; 49985b0f468cf8390fca3ec356cd498ce0039dbad4fCameron Zwarich HadNonMemTransferAccess = true; 500c0e2607564c1259f2d2c56cbff8f78dc0853860dCameron Zwarich MergeInTypeForLoadOrStore(SI->getOperand(0)->getType(), Offset); 5017809ecd5b019d26498499121f4d9c0b7de2f0a14Chris Lattner continue; 5027809ecd5b019d26498499121f4d9c0b7de2f0a14Chris Lattner } 5036974302e3ff20746268721959efed807c7711bfcBob Wilson 5044cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (BitCastInst *BCI = dyn_cast<BitCastInst>(User)) { 505a001b664988f759d194f3d5d880c61449219fc2eChris Lattner IsNotTrivial = true; // Can't be mem2reg'd. 5064cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (!CanConvertToScalar(BCI, Offset)) 5074cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner return false; 5083992feb075b27ff37b63017078a977206f97d10dBob Wilson continue; 5093992feb075b27ff37b63017078a977206f97d10dBob Wilson } 5103992feb075b27ff37b63017078a977206f97d10dBob Wilson 5114cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(User)) { 5124cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // If this is a GEP with a variable indices, we can't handle it. 5134cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (!GEP->hasAllConstantIndices()) 5144cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner return false; 5156974302e3ff20746268721959efed807c7711bfcBob Wilson 5164cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Compute the offset that this GEP adds to the pointer. 5174cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner SmallVector<Value*, 8> Indices(GEP->op_begin()+1, GEP->op_end()); 5184cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner uint64_t GEPOffset = TD.getIndexedOffset(GEP->getPointerOperandType(), 5198fbbb3980755d74539a0aed02bc18842ed2bd18dJay Foad Indices); 5204cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // See if all uses can be converted. 5214cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (!CanConvertToScalar(GEP, Offset+GEPOffset)) 5224cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner return false; 523a001b664988f759d194f3d5d880c61449219fc2eChris Lattner IsNotTrivial = true; // Can't be mem2reg'd. 52485b0f468cf8390fca3ec356cd498ce0039dbad4fCameron Zwarich HadNonMemTransferAccess = true; 5257809ecd5b019d26498499121f4d9c0b7de2f0a14Chris Lattner continue; 5264cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 527ed7b41ea90a17c826f195acbc456c4bb733113d6Chris Lattner 5284cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // If this is a constant sized memset of a constant value (e.g. 0) we can 5294cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // handle it. 5304cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (MemSetInst *MSI = dyn_cast<MemSetInst>(User)) { 5316be41eb7f00319f5ffa1a5435dcd1e81b3ce932dCameron Zwarich // Store of constant value. 5326be41eb7f00319f5ffa1a5435dcd1e81b3ce932dCameron Zwarich if (!isa<ConstantInt>(MSI->getValue())) 533a001b664988f759d194f3d5d880c61449219fc2eChris Lattner return false; 5346be41eb7f00319f5ffa1a5435dcd1e81b3ce932dCameron Zwarich 5356be41eb7f00319f5ffa1a5435dcd1e81b3ce932dCameron Zwarich // Store of constant size. 5366be41eb7f00319f5ffa1a5435dcd1e81b3ce932dCameron Zwarich ConstantInt *Len = dyn_cast<ConstantInt>(MSI->getLength()); 5376be41eb7f00319f5ffa1a5435dcd1e81b3ce932dCameron Zwarich if (!Len) 5386be41eb7f00319f5ffa1a5435dcd1e81b3ce932dCameron Zwarich return false; 5396be41eb7f00319f5ffa1a5435dcd1e81b3ce932dCameron Zwarich 5406be41eb7f00319f5ffa1a5435dcd1e81b3ce932dCameron Zwarich // If the size differs from the alloca, we can only convert the alloca to 5416be41eb7f00319f5ffa1a5435dcd1e81b3ce932dCameron Zwarich // an integer bag-of-bits. 5426be41eb7f00319f5ffa1a5435dcd1e81b3ce932dCameron Zwarich // FIXME: This should handle all of the cases that are currently accepted 5436be41eb7f00319f5ffa1a5435dcd1e81b3ce932dCameron Zwarich // as vector element insertions. 5446be41eb7f00319f5ffa1a5435dcd1e81b3ce932dCameron Zwarich if (Len->getZExtValue() != AllocaSize || Offset != 0) 5456be41eb7f00319f5ffa1a5435dcd1e81b3ce932dCameron Zwarich ScalarKind = Integer; 5466be41eb7f00319f5ffa1a5435dcd1e81b3ce932dCameron Zwarich 547a001b664988f759d194f3d5d880c61449219fc2eChris Lattner IsNotTrivial = true; // Can't be mem2reg'd. 54885b0f468cf8390fca3ec356cd498ce0039dbad4fCameron Zwarich HadNonMemTransferAccess = true; 549a001b664988f759d194f3d5d880c61449219fc2eChris Lattner continue; 5504cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 551fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman 5524cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // If this is a memcpy or memmove into or out of the whole allocation, we 5534cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // can handle it like a load or store of the scalar type. 5544cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (MemTransferInst *MTI = dyn_cast<MemTransferInst>(User)) { 555a001b664988f759d194f3d5d880c61449219fc2eChris Lattner ConstantInt *Len = dyn_cast<ConstantInt>(MTI->getLength()); 556a001b664988f759d194f3d5d880c61449219fc2eChris Lattner if (Len == 0 || Len->getZExtValue() != AllocaSize || Offset != 0) 557a001b664988f759d194f3d5d880c61449219fc2eChris Lattner return false; 5586974302e3ff20746268721959efed807c7711bfcBob Wilson 559a001b664988f759d194f3d5d880c61449219fc2eChris Lattner IsNotTrivial = true; // Can't be mem2reg'd. 560a001b664988f759d194f3d5d880c61449219fc2eChris Lattner continue; 561ed7b41ea90a17c826f195acbc456c4bb733113d6Chris Lattner } 5626974302e3ff20746268721959efed807c7711bfcBob Wilson 5634cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Otherwise, we cannot handle this! 5644cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner return false; 565a10b29b84b63c448b7cb423598d3a38b0f55cddbChris Lattner } 5666974302e3ff20746268721959efed807c7711bfcBob Wilson 5674cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner return true; 568ed7b41ea90a17c826f195acbc456c4bb733113d6Chris Lattner} 569a59adc40153f3e0f9843952c127d179b5ebe6c4cChris Lattner 5704cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// ConvertUsesToScalar - Convert all of the users of Ptr to use the new alloca 5714cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// directly. This happens when we are converting an "integer union" to a 5724cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// single integer scalar, or when we are converting a "vector union" to a 5734cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// vector with insert/extractelement instructions. 5744cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// 5754cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// Offset is an offset from the original alloca, in bits that need to be 5764cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// shifted to the right. By the end of this, there should be no uses of Ptr. 5774cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattnervoid ConvertToScalarInfo::ConvertUsesToScalar(Value *Ptr, AllocaInst *NewAI, 5784cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner uint64_t Offset) { 5794cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner while (!Ptr->use_empty()) { 5804cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Instruction *User = cast<Instruction>(Ptr->use_back()); 581b742defa0a8f3e477c3ed641da49aab276937556Bob Wilson 5824cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (BitCastInst *CI = dyn_cast<BitCastInst>(User)) { 5834cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner ConvertUsesToScalar(CI, NewAI, Offset); 5844cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner CI->eraseFromParent(); 5854cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner continue; 5864cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 587b742defa0a8f3e477c3ed641da49aab276937556Bob Wilson 5884cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(User)) { 5894cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Compute the offset that this GEP adds to the pointer. 5904cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner SmallVector<Value*, 8> Indices(GEP->op_begin()+1, GEP->op_end()); 5914cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner uint64_t GEPOffset = TD.getIndexedOffset(GEP->getPointerOperandType(), 5928fbbb3980755d74539a0aed02bc18842ed2bd18dJay Foad Indices); 5934cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner ConvertUsesToScalar(GEP, NewAI, Offset+GEPOffset*8); 5944cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner GEP->eraseFromParent(); 5954cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner continue; 5964cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 5976974302e3ff20746268721959efed807c7711bfcBob Wilson 59861db1f56d0b717d67557bbb2a9d83af1449458cbChris Lattner IRBuilder<> Builder(User); 5996974302e3ff20746268721959efed807c7711bfcBob Wilson 6004cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (LoadInst *LI = dyn_cast<LoadInst>(User)) { 6014cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // The load is a bit extract from NewAI shifted right by Offset bits. 6024cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Value *LoadedVal = Builder.CreateLoad(NewAI, "tmp"); 6034cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Value *NewLoadVal 6044cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner = ConvertScalar_ExtractValue(LoadedVal, LI->getType(), Offset, Builder); 6054cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner LI->replaceAllUsesWith(NewLoadVal); 6064cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner LI->eraseFromParent(); 6074cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner continue; 6084cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 6096974302e3ff20746268721959efed807c7711bfcBob Wilson 6104cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (StoreInst *SI = dyn_cast<StoreInst>(User)) { 6114cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner assert(SI->getOperand(0) != Ptr && "Consistency error!"); 6124cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Instruction *Old = Builder.CreateLoad(NewAI, NewAI->getName()+".in"); 6134cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Value *New = ConvertScalar_InsertValue(SI->getOperand(0), Old, Offset, 6144cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Builder); 6154cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Builder.CreateStore(New, NewAI); 6164cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner SI->eraseFromParent(); 6176974302e3ff20746268721959efed807c7711bfcBob Wilson 6184cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // If the load we just inserted is now dead, then the inserted store 6194cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // overwrote the entire thing. 6204cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (Old->use_empty()) 6214cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Old->eraseFromParent(); 6224cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner continue; 6234cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 6246974302e3ff20746268721959efed807c7711bfcBob Wilson 6254cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // If this is a constant sized memset of a constant value (e.g. 0) we can 6264cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // transform it into a store of the expanded constant value. 6274cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (MemSetInst *MSI = dyn_cast<MemSetInst>(User)) { 6284cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner assert(MSI->getRawDest() == Ptr && "Consistency error!"); 6294cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner unsigned NumBytes = cast<ConstantInt>(MSI->getLength())->getZExtValue(); 6304cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (NumBytes != 0) { 6314cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner unsigned Val = cast<ConstantInt>(MSI->getValue())->getZExtValue(); 6326974302e3ff20746268721959efed807c7711bfcBob Wilson 6334cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Compute the value replicated the right number of times. 6344cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner APInt APVal(NumBytes*8, Val); 6352674089cefe519195e00bdf879647438cfb1cb0fDaniel Dunbar 6364cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Splat the value if non-zero. 6374cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (Val) 6384cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner for (unsigned i = 1; i != NumBytes; ++i) 6394cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner APVal |= APVal << 8; 6406974302e3ff20746268721959efed807c7711bfcBob Wilson 6414cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Instruction *Old = Builder.CreateLoad(NewAI, NewAI->getName()+".in"); 6424cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Value *New = ConvertScalar_InsertValue( 6434cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner ConstantInt::get(User->getContext(), APVal), 6444cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Old, Offset, Builder); 6454cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Builder.CreateStore(New, NewAI); 6466974302e3ff20746268721959efed807c7711bfcBob Wilson 6474cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // If the load we just inserted is now dead, then the memset overwrote 6484cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // the entire thing. 6494cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (Old->use_empty()) 6506974302e3ff20746268721959efed807c7711bfcBob Wilson Old->eraseFromParent(); 6514cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 6524cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner MSI->eraseFromParent(); 6534cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner continue; 654b742defa0a8f3e477c3ed641da49aab276937556Bob Wilson } 655fca55c8ac7d12e4139ad0ab7d74b76c47935aef6Daniel Dunbar 6564cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // If this is a memcpy or memmove into or out of the whole allocation, we 6574cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // can handle it like a load or store of the scalar type. 6584cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (MemTransferInst *MTI = dyn_cast<MemTransferInst>(User)) { 6594cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner assert(Offset == 0 && "must be store to start of alloca"); 6606974302e3ff20746268721959efed807c7711bfcBob Wilson 6614cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // If the source and destination are both to the same alloca, then this is 6624cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // a noop copy-to-self, just delete it. Otherwise, emit a load and store 6634cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // as appropriate. 664bd1801b5553c8be3960255a92738464e0010b6f6Dan Gohman AllocaInst *OrigAI = cast<AllocaInst>(GetUnderlyingObject(Ptr, &TD, 0)); 6656974302e3ff20746268721959efed807c7711bfcBob Wilson 666bd1801b5553c8be3960255a92738464e0010b6f6Dan Gohman if (GetUnderlyingObject(MTI->getSource(), &TD, 0) != OrigAI) { 6674cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Dest must be OrigAI, change this to be a load from the original 6684cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // pointer (bitcasted), then a store to our new alloca. 6694cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner assert(MTI->getRawDest() == Ptr && "Neither use is of pointer?"); 6704cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Value *SrcPtr = MTI->getSource(); 671db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner PointerType* SPTy = cast<PointerType>(SrcPtr->getType()); 672db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner PointerType* AIPTy = cast<PointerType>(NewAI->getType()); 673e90a6333c3a4514f88c8a3dddd10d9bcddcd6d85Mon P Wang if (SPTy->getAddressSpace() != AIPTy->getAddressSpace()) { 674e90a6333c3a4514f88c8a3dddd10d9bcddcd6d85Mon P Wang AIPTy = PointerType::get(AIPTy->getElementType(), 675e90a6333c3a4514f88c8a3dddd10d9bcddcd6d85Mon P Wang SPTy->getAddressSpace()); 676e90a6333c3a4514f88c8a3dddd10d9bcddcd6d85Mon P Wang } 677e90a6333c3a4514f88c8a3dddd10d9bcddcd6d85Mon P Wang SrcPtr = Builder.CreateBitCast(SrcPtr, AIPTy); 678e90a6333c3a4514f88c8a3dddd10d9bcddcd6d85Mon P Wang 6794cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner LoadInst *SrcVal = Builder.CreateLoad(SrcPtr, "srcval"); 6804cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner SrcVal->setAlignment(MTI->getAlignment()); 6814cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Builder.CreateStore(SrcVal, NewAI); 682bd1801b5553c8be3960255a92738464e0010b6f6Dan Gohman } else if (GetUnderlyingObject(MTI->getDest(), &TD, 0) != OrigAI) { 6834cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Src must be OrigAI, change this to be a load from NewAI then a store 6844cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // through the original dest pointer (bitcasted). 6854cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner assert(MTI->getRawSource() == Ptr && "Neither use is of pointer?"); 6864cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner LoadInst *SrcVal = Builder.CreateLoad(NewAI, "srcval"); 687b742defa0a8f3e477c3ed641da49aab276937556Bob Wilson 688db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner PointerType* DPTy = cast<PointerType>(MTI->getDest()->getType()); 689db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner PointerType* AIPTy = cast<PointerType>(NewAI->getType()); 690e90a6333c3a4514f88c8a3dddd10d9bcddcd6d85Mon P Wang if (DPTy->getAddressSpace() != AIPTy->getAddressSpace()) { 691e90a6333c3a4514f88c8a3dddd10d9bcddcd6d85Mon P Wang AIPTy = PointerType::get(AIPTy->getElementType(), 692e90a6333c3a4514f88c8a3dddd10d9bcddcd6d85Mon P Wang DPTy->getAddressSpace()); 693e90a6333c3a4514f88c8a3dddd10d9bcddcd6d85Mon P Wang } 694e90a6333c3a4514f88c8a3dddd10d9bcddcd6d85Mon P Wang Value *DstPtr = Builder.CreateBitCast(MTI->getDest(), AIPTy); 695e90a6333c3a4514f88c8a3dddd10d9bcddcd6d85Mon P Wang 6964cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner StoreInst *NewStore = Builder.CreateStore(SrcVal, DstPtr); 6974cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner NewStore->setAlignment(MTI->getAlignment()); 6984cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } else { 6994cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Noop transfer. Src == Dst 7004cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 7015fac55fafb53fde5c548bcd08e07418e9d8e549fMatthijs Kooijman 7024cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner MTI->eraseFromParent(); 7034cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner continue; 7044cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 7056974302e3ff20746268721959efed807c7711bfcBob Wilson 7064cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner llvm_unreachable("Unsupported operation!"); 70788e6dc8bf14e8a98888f62173a6581386b8d29a0Chris Lattner } 7082674089cefe519195e00bdf879647438cfb1cb0fDaniel Dunbar} 7092674089cefe519195e00bdf879647438cfb1cb0fDaniel Dunbar 710b2fd770136b92637c5f084b743eab29f910288d5Cameron Zwarich/// getScaledElementType - Gets a scaled element type for a partial vector 711344731c01805aeda49c747bac6148501fa85557cCameron Zwarich/// access of an alloca. The input types must be integer or floating-point 712344731c01805aeda49c747bac6148501fa85557cCameron Zwarich/// scalar or vector types, and the resulting type is an integer, float or 713344731c01805aeda49c747bac6148501fa85557cCameron Zwarich/// double. 714db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattnerstatic Type *getScaledElementType(Type *Ty1, Type *Ty2, 7151537ce75ed25bbca58096383bb1fb9dd427bf1aaCameron Zwarich unsigned NewBitWidth) { 716344731c01805aeda49c747bac6148501fa85557cCameron Zwarich bool IsFP1 = Ty1->isFloatingPointTy() || 717344731c01805aeda49c747bac6148501fa85557cCameron Zwarich (Ty1->isVectorTy() && 718344731c01805aeda49c747bac6148501fa85557cCameron Zwarich cast<VectorType>(Ty1)->getElementType()->isFloatingPointTy()); 719344731c01805aeda49c747bac6148501fa85557cCameron Zwarich bool IsFP2 = Ty2->isFloatingPointTy() || 720344731c01805aeda49c747bac6148501fa85557cCameron Zwarich (Ty2->isVectorTy() && 721344731c01805aeda49c747bac6148501fa85557cCameron Zwarich cast<VectorType>(Ty2)->getElementType()->isFloatingPointTy()); 722344731c01805aeda49c747bac6148501fa85557cCameron Zwarich 723344731c01805aeda49c747bac6148501fa85557cCameron Zwarich LLVMContext &Context = Ty1->getContext(); 724344731c01805aeda49c747bac6148501fa85557cCameron Zwarich 725344731c01805aeda49c747bac6148501fa85557cCameron Zwarich // Prefer floating-point types over integer types, as integer types may have 726344731c01805aeda49c747bac6148501fa85557cCameron Zwarich // been created by earlier scalar replacement. 727344731c01805aeda49c747bac6148501fa85557cCameron Zwarich if (IsFP1 || IsFP2) { 728344731c01805aeda49c747bac6148501fa85557cCameron Zwarich if (NewBitWidth == 32) 729344731c01805aeda49c747bac6148501fa85557cCameron Zwarich return Type::getFloatTy(Context); 730344731c01805aeda49c747bac6148501fa85557cCameron Zwarich if (NewBitWidth == 64) 731344731c01805aeda49c747bac6148501fa85557cCameron Zwarich return Type::getDoubleTy(Context); 732344731c01805aeda49c747bac6148501fa85557cCameron Zwarich } 733b2fd770136b92637c5f084b743eab29f910288d5Cameron Zwarich 734344731c01805aeda49c747bac6148501fa85557cCameron Zwarich return Type::getIntNTy(Context, NewBitWidth); 735b2fd770136b92637c5f084b743eab29f910288d5Cameron Zwarich} 736b2fd770136b92637c5f084b743eab29f910288d5Cameron Zwarich 737ddf9abf2b6ee3a1104057df20ec3be61b410441eMon P Wang/// CreateShuffleVectorCast - Creates a shuffle vector to convert one vector 738ddf9abf2b6ee3a1104057df20ec3be61b410441eMon P Wang/// to another vector of the same element type which has the same allocation 739ddf9abf2b6ee3a1104057df20ec3be61b410441eMon P Wang/// size but different primitive sizes (e.g. <3 x i32> and <4 x i32>). 740db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattnerstatic Value *CreateShuffleVectorCast(Value *FromVal, Type *ToType, 741ddf9abf2b6ee3a1104057df20ec3be61b410441eMon P Wang IRBuilder<> &Builder) { 742db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *FromType = FromVal->getType(); 743db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner VectorType *FromVTy = cast<VectorType>(FromType); 744db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner VectorType *ToVTy = cast<VectorType>(ToType); 745481823aa819ea1dd25567ae616dca93056ef770aMon P Wang assert((ToVTy->getElementType() == FromVTy->getElementType()) && 746ddf9abf2b6ee3a1104057df20ec3be61b410441eMon P Wang "Vectors must have the same element type"); 747ddf9abf2b6ee3a1104057df20ec3be61b410441eMon P Wang Value *UnV = UndefValue::get(FromType); 748ddf9abf2b6ee3a1104057df20ec3be61b410441eMon P Wang unsigned numEltsFrom = FromVTy->getNumElements(); 749ddf9abf2b6ee3a1104057df20ec3be61b410441eMon P Wang unsigned numEltsTo = ToVTy->getNumElements(); 750ddf9abf2b6ee3a1104057df20ec3be61b410441eMon P Wang 751ddf9abf2b6ee3a1104057df20ec3be61b410441eMon P Wang SmallVector<Constant*, 3> Args; 752db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type* Int32Ty = Builder.getInt32Ty(); 753ddf9abf2b6ee3a1104057df20ec3be61b410441eMon P Wang unsigned minNumElts = std::min(numEltsFrom, numEltsTo); 754ddf9abf2b6ee3a1104057df20ec3be61b410441eMon P Wang unsigned i; 755ddf9abf2b6ee3a1104057df20ec3be61b410441eMon P Wang for (i=0; i != minNumElts; ++i) 756481823aa819ea1dd25567ae616dca93056ef770aMon P Wang Args.push_back(ConstantInt::get(Int32Ty, i)); 757ddf9abf2b6ee3a1104057df20ec3be61b410441eMon P Wang 758ddf9abf2b6ee3a1104057df20ec3be61b410441eMon P Wang if (i < numEltsTo) { 759481823aa819ea1dd25567ae616dca93056ef770aMon P Wang Constant* UnC = UndefValue::get(Int32Ty); 760ddf9abf2b6ee3a1104057df20ec3be61b410441eMon P Wang for (; i != numEltsTo; ++i) 761ddf9abf2b6ee3a1104057df20ec3be61b410441eMon P Wang Args.push_back(UnC); 762ddf9abf2b6ee3a1104057df20ec3be61b410441eMon P Wang } 763ddf9abf2b6ee3a1104057df20ec3be61b410441eMon P Wang Constant *Mask = ConstantVector::get(Args); 764ddf9abf2b6ee3a1104057df20ec3be61b410441eMon P Wang return Builder.CreateShuffleVector(FromVal, UnV, Mask, "tmpV"); 765ddf9abf2b6ee3a1104057df20ec3be61b410441eMon P Wang} 766ddf9abf2b6ee3a1104057df20ec3be61b410441eMon P Wang 7674cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// ConvertScalar_ExtractValue - Extract a value of type ToType from an integer 7684cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// or vector value FromVal, extracting the bits from the offset specified by 7694cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// Offset. This returns the value, which is of type ToType. 7704cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// 7714cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// This happens when we are converting an "integer union" to a single 7724cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// integer scalar, or when we are converting a "vector union" to a vector with 7734cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// insert/extractelement instructions. 7744cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// 7754cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// Offset is an offset from the original alloca, in bits that need to be 7764cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// shifted to the right. 7774cc576bc5ea27951f3bb15ccefbe483293bf8eafChris LattnerValue *ConvertToScalarInfo:: 778db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris LattnerConvertScalar_ExtractValue(Value *FromVal, Type *ToType, 7794cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner uint64_t Offset, IRBuilder<> &Builder) { 7804cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // If the load is of the whole new alloca, no conversion is needed. 781db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *FromType = FromVal->getType(); 782be0761c8202405cdd33f1103d262c0aa97895a8eMon P Wang if (FromType == ToType && Offset == 0) 7834cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner return FromVal; 7844cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner 7854cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // If the result alloca is a vector type, this is either an element 7864cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // access or a bitcast to another vector type of the same size. 787db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner if (VectorType *VTy = dyn_cast<VectorType>(FromType)) { 7880398d6135daef709f80837e457a75dc2e1c2aab7Cameron Zwarich unsigned FromTypeSize = TD.getTypeAllocSize(FromType); 7899827b78b51f285e90c2b1e5add9b28d10c88595cCameron Zwarich unsigned ToTypeSize = TD.getTypeAllocSize(ToType); 7900398d6135daef709f80837e457a75dc2e1c2aab7Cameron Zwarich if (FromTypeSize == ToTypeSize) { 791ddf9abf2b6ee3a1104057df20ec3be61b410441eMon P Wang // If the two types have the same primitive size, use a bit cast. 792ddf9abf2b6ee3a1104057df20ec3be61b410441eMon P Wang // Otherwise, it is two vectors with the same element type that has 793ddf9abf2b6ee3a1104057df20ec3be61b410441eMon P Wang // the same allocation size but different number of elements so use 794ddf9abf2b6ee3a1104057df20ec3be61b410441eMon P Wang // a shuffle vector. 795be0761c8202405cdd33f1103d262c0aa97895a8eMon P Wang if (FromType->getPrimitiveSizeInBits() == 796be0761c8202405cdd33f1103d262c0aa97895a8eMon P Wang ToType->getPrimitiveSizeInBits()) 797be0761c8202405cdd33f1103d262c0aa97895a8eMon P Wang return Builder.CreateBitCast(FromVal, ToType, "tmp"); 798ddf9abf2b6ee3a1104057df20ec3be61b410441eMon P Wang else 799ddf9abf2b6ee3a1104057df20ec3be61b410441eMon P Wang return CreateShuffleVectorCast(FromVal, ToType, Builder); 800be0761c8202405cdd33f1103d262c0aa97895a8eMon P Wang } 801032c10fee2a4bb731488ce75844878009d3bd409Cameron Zwarich 8020398d6135daef709f80837e457a75dc2e1c2aab7Cameron Zwarich if (isPowerOf2_64(FromTypeSize / ToTypeSize)) { 803344731c01805aeda49c747bac6148501fa85557cCameron Zwarich assert(!(ToType->isVectorTy() && Offset != 0) && "Can't extract a value " 804344731c01805aeda49c747bac6148501fa85557cCameron Zwarich "of a smaller vector type at a nonzero offset."); 805032c10fee2a4bb731488ce75844878009d3bd409Cameron Zwarich 806db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *CastElementTy = getScaledElementType(FromType, ToType, 8071537ce75ed25bbca58096383bb1fb9dd427bf1aaCameron Zwarich ToTypeSize * 8); 8080398d6135daef709f80837e457a75dc2e1c2aab7Cameron Zwarich unsigned NumCastVectorElements = FromTypeSize / ToTypeSize; 809032c10fee2a4bb731488ce75844878009d3bd409Cameron Zwarich 810032c10fee2a4bb731488ce75844878009d3bd409Cameron Zwarich LLVMContext &Context = FromVal->getContext(); 811db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *CastTy = VectorType::get(CastElementTy, 812032c10fee2a4bb731488ce75844878009d3bd409Cameron Zwarich NumCastVectorElements); 813032c10fee2a4bb731488ce75844878009d3bd409Cameron Zwarich Value *Cast = Builder.CreateBitCast(FromVal, CastTy, "tmp"); 814344731c01805aeda49c747bac6148501fa85557cCameron Zwarich 815344731c01805aeda49c747bac6148501fa85557cCameron Zwarich unsigned EltSize = TD.getTypeAllocSizeInBits(CastElementTy); 816344731c01805aeda49c747bac6148501fa85557cCameron Zwarich unsigned Elt = Offset/EltSize; 817344731c01805aeda49c747bac6148501fa85557cCameron Zwarich assert(EltSize*Elt == Offset && "Invalid modulus in validity checking"); 818032c10fee2a4bb731488ce75844878009d3bd409Cameron Zwarich Value *Extract = Builder.CreateExtractElement(Cast, ConstantInt::get( 819344731c01805aeda49c747bac6148501fa85557cCameron Zwarich Type::getInt32Ty(Context), Elt), "tmp"); 820032c10fee2a4bb731488ce75844878009d3bd409Cameron Zwarich return Builder.CreateBitCast(Extract, ToType, "tmp"); 821b2fd770136b92637c5f084b743eab29f910288d5Cameron Zwarich } 8224cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner 8234cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Otherwise it must be an element access. 8244cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner unsigned Elt = 0; 8254cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (Offset) { 8264cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner unsigned EltSize = TD.getTypeAllocSizeInBits(VTy->getElementType()); 8274cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Elt = Offset/EltSize; 8284cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner assert(EltSize*Elt == Offset && "Invalid modulus in validity checking"); 829b742defa0a8f3e477c3ed641da49aab276937556Bob Wilson } 8304cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Return the element extracted out of it. 8314cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Value *V = Builder.CreateExtractElement(FromVal, ConstantInt::get( 8324cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Type::getInt32Ty(FromVal->getContext()), Elt), "tmp"); 8334cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (V->getType() != ToType) 8344cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner V = Builder.CreateBitCast(V, ToType, "tmp"); 8354cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner return V; 8364cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 8376974302e3ff20746268721959efed807c7711bfcBob Wilson 8384cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // If ToType is a first class aggregate, extract out each of the pieces and 8394cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // use insertvalue's to form the FCA. 840db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner if (StructType *ST = dyn_cast<StructType>(ToType)) { 8414cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner const StructLayout &Layout = *TD.getStructLayout(ST); 8424cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Value *Res = UndefValue::get(ST); 8434cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner for (unsigned i = 0, e = ST->getNumElements(); i != e; ++i) { 8444cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Value *Elt = ConvertScalar_ExtractValue(FromVal, ST->getElementType(i), 8454cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Offset+Layout.getElementOffsetInBits(i), 8464cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Builder); 8474cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Res = Builder.CreateInsertValue(Res, Elt, i, "tmp"); 8484cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 8494cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner return Res; 8504cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 8516974302e3ff20746268721959efed807c7711bfcBob Wilson 852db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner if (ArrayType *AT = dyn_cast<ArrayType>(ToType)) { 8534cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner uint64_t EltSize = TD.getTypeAllocSizeInBits(AT->getElementType()); 8544cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Value *Res = UndefValue::get(AT); 8554cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner for (unsigned i = 0, e = AT->getNumElements(); i != e; ++i) { 8564cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Value *Elt = ConvertScalar_ExtractValue(FromVal, AT->getElementType(), 8574cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Offset+i*EltSize, Builder); 8584cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Res = Builder.CreateInsertValue(Res, Elt, i, "tmp"); 8594cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 8604cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner return Res; 861b742defa0a8f3e477c3ed641da49aab276937556Bob Wilson } 8622674089cefe519195e00bdf879647438cfb1cb0fDaniel Dunbar 8634cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Otherwise, this must be a union that was converted to an integer value. 864db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner IntegerType *NTy = cast<IntegerType>(FromVal->getType()); 865b742defa0a8f3e477c3ed641da49aab276937556Bob Wilson 8664cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // If this is a big-endian system and the load is narrower than the 8674cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // full alloca type, we need to do a shift to get the right bits. 8684cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner int ShAmt = 0; 8694cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (TD.isBigEndian()) { 8704cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // On big-endian machines, the lowest bit is stored at the bit offset 8714cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // from the pointer given by getTypeStoreSizeInBits. This matters for 8724cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // integers with a bitwidth that is not a multiple of 8. 8734cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner ShAmt = TD.getTypeStoreSizeInBits(NTy) - 8744cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner TD.getTypeStoreSizeInBits(ToType) - Offset; 875b742defa0a8f3e477c3ed641da49aab276937556Bob Wilson } else { 8764cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner ShAmt = Offset; 877b742defa0a8f3e477c3ed641da49aab276937556Bob Wilson } 878b742defa0a8f3e477c3ed641da49aab276937556Bob Wilson 8794cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Note: we support negative bitwidths (with shl) which are not defined. 8804cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // We do this to support (f.e.) loads off the end of a structure where 8814cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // only some bits are used. 8824cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (ShAmt > 0 && (unsigned)ShAmt < NTy->getBitWidth()) 8834cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner FromVal = Builder.CreateLShr(FromVal, 8844cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner ConstantInt::get(FromVal->getType(), 8854cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner ShAmt), "tmp"); 8864cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner else if (ShAmt < 0 && (unsigned)-ShAmt < NTy->getBitWidth()) 8876974302e3ff20746268721959efed807c7711bfcBob Wilson FromVal = Builder.CreateShl(FromVal, 8884cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner ConstantInt::get(FromVal->getType(), 8894cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner -ShAmt), "tmp"); 890b742defa0a8f3e477c3ed641da49aab276937556Bob Wilson 8914cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Finally, unconditionally truncate the integer to the right width. 8924cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner unsigned LIBitWidth = TD.getTypeSizeInBits(ToType); 8934cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (LIBitWidth < NTy->getBitWidth()) 8944cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner FromVal = 8956974302e3ff20746268721959efed807c7711bfcBob Wilson Builder.CreateTrunc(FromVal, IntegerType::get(FromVal->getContext(), 8964cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner LIBitWidth), "tmp"); 8974cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner else if (LIBitWidth > NTy->getBitWidth()) 8984cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner FromVal = 8996974302e3ff20746268721959efed807c7711bfcBob Wilson Builder.CreateZExt(FromVal, IntegerType::get(FromVal->getContext(), 9004cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner LIBitWidth), "tmp"); 9014cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner 9024cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // If the result is an integer, this is a trunc or bitcast. 9034cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (ToType->isIntegerTy()) { 9044cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Should be done. 9054cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } else if (ToType->isFloatingPointTy() || ToType->isVectorTy()) { 9064cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Just do a bitcast, we know the sizes match up. 9074cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner FromVal = Builder.CreateBitCast(FromVal, ToType, "tmp"); 9084cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } else { 9094cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Otherwise must be a pointer. 9104cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner FromVal = Builder.CreateIntToPtr(FromVal, ToType, "tmp"); 911372dda8881c7a32a6f5ce0f76a713e3a9ef46ea1Chris Lattner } 9124cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner assert(FromVal->getType() == ToType && "Didn't convert right?"); 9134cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner return FromVal; 914372dda8881c7a32a6f5ce0f76a713e3a9ef46ea1Chris Lattner} 915372dda8881c7a32a6f5ce0f76a713e3a9ef46ea1Chris Lattner 9164cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// ConvertScalar_InsertValue - Insert the value "SV" into the existing integer 9174cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// or vector value "Old" at the offset specified by Offset. 9184cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// 9194cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// This happens when we are converting an "integer union" to a 9204cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// single integer scalar, or when we are converting a "vector union" to a 9214cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// vector with insert/extractelement instructions. 9224cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// 9234cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// Offset is an offset from the original alloca, in bits that need to be 9244cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// shifted to the right. 9254cc576bc5ea27951f3bb15ccefbe483293bf8eafChris LattnerValue *ConvertToScalarInfo:: 9264cc576bc5ea27951f3bb15ccefbe483293bf8eafChris LattnerConvertScalar_InsertValue(Value *SV, Value *Old, 9274cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner uint64_t Offset, IRBuilder<> &Builder) { 9284cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Convert the stored type to the actual type, shift it left to insert 9294cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // then 'or' into place. 930db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *AllocaType = Old->getType(); 9314cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner LLVMContext &Context = Old->getContext(); 9322674089cefe519195e00bdf879647438cfb1cb0fDaniel Dunbar 933db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner if (VectorType *VTy = dyn_cast<VectorType>(AllocaType)) { 9344cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner uint64_t VecSize = TD.getTypeAllocSizeInBits(VTy); 9354cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner uint64_t ValSize = TD.getTypeAllocSizeInBits(SV->getType()); 9366974302e3ff20746268721959efed807c7711bfcBob Wilson 9374cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Changing the whole vector with memset or with an access of a different 9384cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // vector type? 939be0761c8202405cdd33f1103d262c0aa97895a8eMon P Wang if (ValSize == VecSize) { 940ddf9abf2b6ee3a1104057df20ec3be61b410441eMon P Wang // If the two types have the same primitive size, use a bit cast. 941ddf9abf2b6ee3a1104057df20ec3be61b410441eMon P Wang // Otherwise, it is two vectors with the same element type that has 942ddf9abf2b6ee3a1104057df20ec3be61b410441eMon P Wang // the same allocation size but different number of elements so use 943ddf9abf2b6ee3a1104057df20ec3be61b410441eMon P Wang // a shuffle vector. 944be0761c8202405cdd33f1103d262c0aa97895a8eMon P Wang if (VTy->getPrimitiveSizeInBits() == 945be0761c8202405cdd33f1103d262c0aa97895a8eMon P Wang SV->getType()->getPrimitiveSizeInBits()) 946be0761c8202405cdd33f1103d262c0aa97895a8eMon P Wang return Builder.CreateBitCast(SV, AllocaType, "tmp"); 947ddf9abf2b6ee3a1104057df20ec3be61b410441eMon P Wang else 948ddf9abf2b6ee3a1104057df20ec3be61b410441eMon P Wang return CreateShuffleVectorCast(SV, VTy, Builder); 949be0761c8202405cdd33f1103d262c0aa97895a8eMon P Wang } 9502674089cefe519195e00bdf879647438cfb1cb0fDaniel Dunbar 951344731c01805aeda49c747bac6148501fa85557cCameron Zwarich if (isPowerOf2_64(VecSize / ValSize)) { 952344731c01805aeda49c747bac6148501fa85557cCameron Zwarich assert(!(SV->getType()->isVectorTy() && Offset != 0) && "Can't insert a " 953344731c01805aeda49c747bac6148501fa85557cCameron Zwarich "value of a smaller vector type at a nonzero offset."); 954b2fd770136b92637c5f084b743eab29f910288d5Cameron Zwarich 955db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *CastElementTy = getScaledElementType(VTy, SV->getType(), 956344731c01805aeda49c747bac6148501fa85557cCameron Zwarich ValSize); 9571537ce75ed25bbca58096383bb1fb9dd427bf1aaCameron Zwarich unsigned NumCastVectorElements = VecSize / ValSize; 958b2fd770136b92637c5f084b743eab29f910288d5Cameron Zwarich 959b2fd770136b92637c5f084b743eab29f910288d5Cameron Zwarich LLVMContext &Context = SV->getContext(); 960db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *OldCastTy = VectorType::get(CastElementTy, 961b2fd770136b92637c5f084b743eab29f910288d5Cameron Zwarich NumCastVectorElements); 962b2fd770136b92637c5f084b743eab29f910288d5Cameron Zwarich Value *OldCast = Builder.CreateBitCast(Old, OldCastTy, "tmp"); 963b2fd770136b92637c5f084b743eab29f910288d5Cameron Zwarich 964b2fd770136b92637c5f084b743eab29f910288d5Cameron Zwarich Value *SVCast = Builder.CreateBitCast(SV, CastElementTy, "tmp"); 965344731c01805aeda49c747bac6148501fa85557cCameron Zwarich 966344731c01805aeda49c747bac6148501fa85557cCameron Zwarich unsigned EltSize = TD.getTypeAllocSizeInBits(CastElementTy); 967344731c01805aeda49c747bac6148501fa85557cCameron Zwarich unsigned Elt = Offset/EltSize; 968344731c01805aeda49c747bac6148501fa85557cCameron Zwarich assert(EltSize*Elt == Offset && "Invalid modulus in validity checking"); 969b2fd770136b92637c5f084b743eab29f910288d5Cameron Zwarich Value *Insert = 970b2fd770136b92637c5f084b743eab29f910288d5Cameron Zwarich Builder.CreateInsertElement(OldCast, SVCast, ConstantInt::get( 971344731c01805aeda49c747bac6148501fa85557cCameron Zwarich Type::getInt32Ty(Context), Elt), "tmp"); 972b2fd770136b92637c5f084b743eab29f910288d5Cameron Zwarich return Builder.CreateBitCast(Insert, AllocaType, "tmp"); 973b2fd770136b92637c5f084b743eab29f910288d5Cameron Zwarich } 974b2fd770136b92637c5f084b743eab29f910288d5Cameron Zwarich 9754cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Must be an element insertion. 976c5c43b958cf2f251c836f94d4499adb6296f0611Cameron Zwarich assert(SV->getType() == VTy->getElementType()); 977c5c43b958cf2f251c836f94d4499adb6296f0611Cameron Zwarich uint64_t EltSize = TD.getTypeAllocSizeInBits(VTy->getElementType()); 9784cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner unsigned Elt = Offset/EltSize; 979c5c43b958cf2f251c836f94d4499adb6296f0611Cameron Zwarich return Builder.CreateInsertElement(Old, SV, 9804cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner ConstantInt::get(Type::getInt32Ty(SV->getContext()), Elt), 9814cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner "tmp"); 982b742defa0a8f3e477c3ed641da49aab276937556Bob Wilson } 9836974302e3ff20746268721959efed807c7711bfcBob Wilson 9844cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // If SV is a first-class aggregate value, insert each value recursively. 985db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner if (StructType *ST = dyn_cast<StructType>(SV->getType())) { 9864cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner const StructLayout &Layout = *TD.getStructLayout(ST); 9874cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner for (unsigned i = 0, e = ST->getNumElements(); i != e; ++i) { 9884cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Value *Elt = Builder.CreateExtractValue(SV, i, "tmp"); 9896974302e3ff20746268721959efed807c7711bfcBob Wilson Old = ConvertScalar_InsertValue(Elt, Old, 9904cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Offset+Layout.getElementOffsetInBits(i), 9914cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Builder); 9924cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 9934cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner return Old; 9944cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 9956974302e3ff20746268721959efed807c7711bfcBob Wilson 996db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner if (ArrayType *AT = dyn_cast<ArrayType>(SV->getType())) { 9974cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner uint64_t EltSize = TD.getTypeAllocSizeInBits(AT->getElementType()); 9984cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner for (unsigned i = 0, e = AT->getNumElements(); i != e; ++i) { 9994cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Value *Elt = Builder.CreateExtractValue(SV, i, "tmp"); 10004cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Old = ConvertScalar_InsertValue(Elt, Old, Offset+i*EltSize, Builder); 10014cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 10024cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner return Old; 10034cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 10044cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner 10054cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // If SV is a float, convert it to the appropriate integer type. 10064cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // If it is a pointer, do the same. 10074cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner unsigned SrcWidth = TD.getTypeSizeInBits(SV->getType()); 10084cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner unsigned DestWidth = TD.getTypeSizeInBits(AllocaType); 10094cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner unsigned SrcStoreWidth = TD.getTypeStoreSizeInBits(SV->getType()); 10104cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner unsigned DestStoreWidth = TD.getTypeStoreSizeInBits(AllocaType); 10114cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (SV->getType()->isFloatingPointTy() || SV->getType()->isVectorTy()) 10124cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner SV = Builder.CreateBitCast(SV, 10134cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner IntegerType::get(SV->getContext(),SrcWidth), "tmp"); 10144cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner else if (SV->getType()->isPointerTy()) 10154cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner SV = Builder.CreatePtrToInt(SV, TD.getIntPtrType(SV->getContext()), "tmp"); 10164cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner 10174cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Zero extend or truncate the value if needed. 10184cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (SV->getType() != AllocaType) { 10194cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (SV->getType()->getPrimitiveSizeInBits() < 10204cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner AllocaType->getPrimitiveSizeInBits()) 10214cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner SV = Builder.CreateZExt(SV, AllocaType, "tmp"); 10224cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner else { 10234cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Truncation may be needed if storing more than the alloca can hold 10244cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // (undefined behavior). 10254cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner SV = Builder.CreateTrunc(SV, AllocaType, "tmp"); 10264cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner SrcWidth = DestWidth; 10274cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner SrcStoreWidth = DestStoreWidth; 10284cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 10294cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 10304cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner 10314cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // If this is a big-endian system and the store is narrower than the 10324cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // full alloca type, we need to do a shift to get the right bits. 10334cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner int ShAmt = 0; 10344cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (TD.isBigEndian()) { 10354cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // On big-endian machines, the lowest bit is stored at the bit offset 10364cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // from the pointer given by getTypeStoreSizeInBits. This matters for 10374cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // integers with a bitwidth that is not a multiple of 8. 10384cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner ShAmt = DestStoreWidth - SrcStoreWidth - Offset; 10394cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } else { 10404cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner ShAmt = Offset; 10414cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 10424cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner 10434cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Note: we support negative bitwidths (with shr) which are not defined. 10444cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // We do this to support (f.e.) stores off the end of a structure where 10454cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // only some bits in the structure are set. 10464cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner APInt Mask(APInt::getLowBitsSet(DestWidth, SrcWidth)); 10474cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (ShAmt > 0 && (unsigned)ShAmt < DestWidth) { 10484cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner SV = Builder.CreateShl(SV, ConstantInt::get(SV->getType(), 10494cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner ShAmt), "tmp"); 10504cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Mask <<= ShAmt; 10514cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } else if (ShAmt < 0 && (unsigned)-ShAmt < DestWidth) { 10524cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner SV = Builder.CreateLShr(SV, ConstantInt::get(SV->getType(), 10534cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner -ShAmt), "tmp"); 10544cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Mask = Mask.lshr(-ShAmt); 10554cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 10564cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner 10574cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Mask out the bits we are about to insert from the old value, and or 10584cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // in the new bits. 10594cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (SrcWidth != DestWidth) { 10604cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner assert(DestWidth > SrcWidth); 10614cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Old = Builder.CreateAnd(Old, ConstantInt::get(Context, ~Mask), "mask"); 10624cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner SV = Builder.CreateOr(Old, SV, "ins"); 10634cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 10644cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner return SV; 1065b742defa0a8f3e477c3ed641da49aab276937556Bob Wilson} 1066b742defa0a8f3e477c3ed641da49aab276937556Bob Wilson 1067b742defa0a8f3e477c3ed641da49aab276937556Bob Wilson 10684cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner//===----------------------------------------------------------------------===// 10694cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner// SRoA Driver 10704cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner//===----------------------------------------------------------------------===// 1071b742defa0a8f3e477c3ed641da49aab276937556Bob Wilson 1072b742defa0a8f3e477c3ed641da49aab276937556Bob Wilson 10734cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattnerbool SROA::runOnFunction(Function &F) { 10744cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner TD = getAnalysisIfAvailable<TargetData>(); 1075b742defa0a8f3e477c3ed641da49aab276937556Bob Wilson 10764cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner bool Changed = performPromotion(F); 1077b742defa0a8f3e477c3ed641da49aab276937556Bob Wilson 10784cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // FIXME: ScalarRepl currently depends on TargetData more than it 10794cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // theoretically needs to. It should be refactored in order to support 10804cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // target-independent IR. Until this is done, just skip the actual 10814cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // scalar-replacement portion of this pass. 10824cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (!TD) return Changed; 10834cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner 10844cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner while (1) { 10854cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner bool LocalChange = performScalarRepl(F); 10864cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (!LocalChange) break; // No need to repromote if no scalarrepl 10874cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Changed = true; 10884cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner LocalChange = performPromotion(F); 10894cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (!LocalChange) break; // No need to re-scalarrepl if no promotion 10902674089cefe519195e00bdf879647438cfb1cb0fDaniel Dunbar } 10914cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner 10924cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner return Changed; 1093d93afec1dbbb1abb3df55e2e007b5f256d09f84aChris Lattner} 1094d93afec1dbbb1abb3df55e2e007b5f256d09f84aChris Lattner 1095d0f56132cfa6e25fb9692e84ea12444c86b92ae4Chris Lattnernamespace { 1096d0f56132cfa6e25fb9692e84ea12444c86b92ae4Chris Lattnerclass AllocaPromoter : public LoadAndStorePromoter { 1097d0f56132cfa6e25fb9692e84ea12444c86b92ae4Chris Lattner AllocaInst *AI; 1098231a5ab746ca12000aa57208869a98f78781aa6bDevang Patel DIBuilder *DIB; 10994fd3c5957e6a272b60d6446e745136187d07f812Devang Patel SmallVector<DbgDeclareInst *, 4> DDIs; 11004fd3c5957e6a272b60d6446e745136187d07f812Devang Patel SmallVector<DbgValueInst *, 4> DVIs; 1101d0f56132cfa6e25fb9692e84ea12444c86b92ae4Chris Lattnerpublic: 1102c827939046670a9800659b83e2048f1d3a79a531Cameron Zwarich AllocaPromoter(const SmallVectorImpl<Instruction*> &Insts, SSAUpdater &S, 1103231a5ab746ca12000aa57208869a98f78781aa6bDevang Patel DIBuilder *DB) 11044fd3c5957e6a272b60d6446e745136187d07f812Devang Patel : LoadAndStorePromoter(Insts, S), AI(0), DIB(DB) {} 1105e0a1a5ba91df6817f9ffae7af65ed0bda66f7620Chris Lattner 1106deaf55f69865bbc997a569c2a689ec5b0fbdefefChris Lattner void run(AllocaInst *AI, const SmallVectorImpl<Instruction*> &Insts) { 1107d0f56132cfa6e25fb9692e84ea12444c86b92ae4Chris Lattner // Remember which alloca we're promoting (for isInstInList). 1108d0f56132cfa6e25fb9692e84ea12444c86b92ae4Chris Lattner this->AI = AI; 11094fd3c5957e6a272b60d6446e745136187d07f812Devang Patel if (MDNode *DebugNode = MDNode::getIfExists(AI->getContext(), AI)) 11104fd3c5957e6a272b60d6446e745136187d07f812Devang Patel for (Value::use_iterator UI = DebugNode->use_begin(), 11114fd3c5957e6a272b60d6446e745136187d07f812Devang Patel E = DebugNode->use_end(); UI != E; ++UI) 11124fd3c5957e6a272b60d6446e745136187d07f812Devang Patel if (DbgDeclareInst *DDI = dyn_cast<DbgDeclareInst>(*UI)) 11134fd3c5957e6a272b60d6446e745136187d07f812Devang Patel DDIs.push_back(DDI); 11144fd3c5957e6a272b60d6446e745136187d07f812Devang Patel else if (DbgValueInst *DVI = dyn_cast<DbgValueInst>(*UI)) 11154fd3c5957e6a272b60d6446e745136187d07f812Devang Patel DVIs.push_back(DVI); 11164fd3c5957e6a272b60d6446e745136187d07f812Devang Patel 1117deaf55f69865bbc997a569c2a689ec5b0fbdefefChris Lattner LoadAndStorePromoter::run(Insts); 1118d0f56132cfa6e25fb9692e84ea12444c86b92ae4Chris Lattner AI->eraseFromParent(); 11194fd3c5957e6a272b60d6446e745136187d07f812Devang Patel for (SmallVector<DbgDeclareInst *, 4>::iterator I = DDIs.begin(), 11204fd3c5957e6a272b60d6446e745136187d07f812Devang Patel E = DDIs.end(); I != E; ++I) { 11214fd3c5957e6a272b60d6446e745136187d07f812Devang Patel DbgDeclareInst *DDI = *I; 1122231a5ab746ca12000aa57208869a98f78781aa6bDevang Patel DDI->eraseFromParent(); 11234fd3c5957e6a272b60d6446e745136187d07f812Devang Patel } 11244fd3c5957e6a272b60d6446e745136187d07f812Devang Patel for (SmallVector<DbgValueInst *, 4>::iterator I = DVIs.begin(), 11254fd3c5957e6a272b60d6446e745136187d07f812Devang Patel E = DVIs.end(); I != E; ++I) { 11264fd3c5957e6a272b60d6446e745136187d07f812Devang Patel DbgValueInst *DVI = *I; 11274fd3c5957e6a272b60d6446e745136187d07f812Devang Patel DVI->eraseFromParent(); 11284fd3c5957e6a272b60d6446e745136187d07f812Devang Patel } 1129e0a1a5ba91df6817f9ffae7af65ed0bda66f7620Chris Lattner } 1130e0a1a5ba91df6817f9ffae7af65ed0bda66f7620Chris Lattner 1131d0f56132cfa6e25fb9692e84ea12444c86b92ae4Chris Lattner virtual bool isInstInList(Instruction *I, 1132d0f56132cfa6e25fb9692e84ea12444c86b92ae4Chris Lattner const SmallVectorImpl<Instruction*> &Insts) const { 1133d0f56132cfa6e25fb9692e84ea12444c86b92ae4Chris Lattner if (LoadInst *LI = dyn_cast<LoadInst>(I)) 1134d0f56132cfa6e25fb9692e84ea12444c86b92ae4Chris Lattner return LI->getOperand(0) == AI; 1135d0f56132cfa6e25fb9692e84ea12444c86b92ae4Chris Lattner return cast<StoreInst>(I)->getPointerOperand() == AI; 1136e0a1a5ba91df6817f9ffae7af65ed0bda66f7620Chris Lattner } 1137231a5ab746ca12000aa57208869a98f78781aa6bDevang Patel 11384fd3c5957e6a272b60d6446e745136187d07f812Devang Patel virtual void updateDebugInfo(Instruction *Inst) const { 11394fd3c5957e6a272b60d6446e745136187d07f812Devang Patel for (SmallVector<DbgDeclareInst *, 4>::const_iterator I = DDIs.begin(), 11404fd3c5957e6a272b60d6446e745136187d07f812Devang Patel E = DDIs.end(); I != E; ++I) { 11414fd3c5957e6a272b60d6446e745136187d07f812Devang Patel DbgDeclareInst *DDI = *I; 11424fd3c5957e6a272b60d6446e745136187d07f812Devang Patel if (StoreInst *SI = dyn_cast<StoreInst>(Inst)) 11434fd3c5957e6a272b60d6446e745136187d07f812Devang Patel ConvertDebugDeclareToDebugValue(DDI, SI, *DIB); 11444fd3c5957e6a272b60d6446e745136187d07f812Devang Patel else if (LoadInst *LI = dyn_cast<LoadInst>(Inst)) 11454fd3c5957e6a272b60d6446e745136187d07f812Devang Patel ConvertDebugDeclareToDebugValue(DDI, LI, *DIB); 11464fd3c5957e6a272b60d6446e745136187d07f812Devang Patel } 11474fd3c5957e6a272b60d6446e745136187d07f812Devang Patel for (SmallVector<DbgValueInst *, 4>::const_iterator I = DVIs.begin(), 11484fd3c5957e6a272b60d6446e745136187d07f812Devang Patel E = DVIs.end(); I != E; ++I) { 11494fd3c5957e6a272b60d6446e745136187d07f812Devang Patel DbgValueInst *DVI = *I; 11504fd3c5957e6a272b60d6446e745136187d07f812Devang Patel if (StoreInst *SI = dyn_cast<StoreInst>(Inst)) { 11514fd3c5957e6a272b60d6446e745136187d07f812Devang Patel Instruction *DbgVal = NULL; 11524fd3c5957e6a272b60d6446e745136187d07f812Devang Patel // If an argument is zero extended then use argument directly. The ZExt 11534fd3c5957e6a272b60d6446e745136187d07f812Devang Patel // may be zapped by an optimization pass in future. 11544fd3c5957e6a272b60d6446e745136187d07f812Devang Patel Argument *ExtendedArg = NULL; 11554fd3c5957e6a272b60d6446e745136187d07f812Devang Patel if (ZExtInst *ZExt = dyn_cast<ZExtInst>(SI->getOperand(0))) 11564fd3c5957e6a272b60d6446e745136187d07f812Devang Patel ExtendedArg = dyn_cast<Argument>(ZExt->getOperand(0)); 11574fd3c5957e6a272b60d6446e745136187d07f812Devang Patel if (SExtInst *SExt = dyn_cast<SExtInst>(SI->getOperand(0))) 11584fd3c5957e6a272b60d6446e745136187d07f812Devang Patel ExtendedArg = dyn_cast<Argument>(SExt->getOperand(0)); 11594fd3c5957e6a272b60d6446e745136187d07f812Devang Patel if (ExtendedArg) 11604fd3c5957e6a272b60d6446e745136187d07f812Devang Patel DbgVal = DIB->insertDbgValueIntrinsic(ExtendedArg, 0, 11614fd3c5957e6a272b60d6446e745136187d07f812Devang Patel DIVariable(DVI->getVariable()), 11624fd3c5957e6a272b60d6446e745136187d07f812Devang Patel SI); 11634fd3c5957e6a272b60d6446e745136187d07f812Devang Patel else 11644fd3c5957e6a272b60d6446e745136187d07f812Devang Patel DbgVal = DIB->insertDbgValueIntrinsic(SI->getOperand(0), 0, 11654fd3c5957e6a272b60d6446e745136187d07f812Devang Patel DIVariable(DVI->getVariable()), 11664fd3c5957e6a272b60d6446e745136187d07f812Devang Patel SI); 1167a4acb008cb2a9953d9cb4c90ecf6424bd32ebc0cDevang Patel DbgVal->setDebugLoc(DVI->getDebugLoc()); 11684fd3c5957e6a272b60d6446e745136187d07f812Devang Patel } else if (LoadInst *LI = dyn_cast<LoadInst>(Inst)) { 11694fd3c5957e6a272b60d6446e745136187d07f812Devang Patel Instruction *DbgVal = 11704fd3c5957e6a272b60d6446e745136187d07f812Devang Patel DIB->insertDbgValueIntrinsic(LI->getOperand(0), 0, 11714fd3c5957e6a272b60d6446e745136187d07f812Devang Patel DIVariable(DVI->getVariable()), LI); 1172a4acb008cb2a9953d9cb4c90ecf6424bd32ebc0cDevang Patel DbgVal->setDebugLoc(DVI->getDebugLoc()); 11734fd3c5957e6a272b60d6446e745136187d07f812Devang Patel } 11744fd3c5957e6a272b60d6446e745136187d07f812Devang Patel } 1175231a5ab746ca12000aa57208869a98f78781aa6bDevang Patel } 1176d0f56132cfa6e25fb9692e84ea12444c86b92ae4Chris Lattner}; 1177d0f56132cfa6e25fb9692e84ea12444c86b92ae4Chris Lattner} // end anon namespace 117878c50b8cd68d266d4ed6f8eca443cf8142a01204Bob Wilson 1179c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner/// isSafeSelectToSpeculate - Select instructions that use an alloca and are 1180c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner/// subsequently loaded can be rewritten to load both input pointers and then 1181c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner/// select between the result, allowing the load of the alloca to be promoted. 1182c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner/// From this: 1183c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner/// %P2 = select i1 %cond, i32* %Alloca, i32* %Other 1184c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner/// %V = load i32* %P2 1185c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner/// to: 1186c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner/// %V1 = load i32* %Alloca -> will be mem2reg'd 1187c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner/// %V2 = load i32* %Other 1188e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner/// %V = select i1 %cond, i32 %V1, i32 %V2 1189c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner/// 1190c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner/// We can do this to a select if its only uses are loads and if the operand to 1191c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner/// the select can be loaded unconditionally. 1192c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattnerstatic bool isSafeSelectToSpeculate(SelectInst *SI, const TargetData *TD) { 1193c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner bool TDerefable = SI->getTrueValue()->isDereferenceablePointer(); 1194c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner bool FDerefable = SI->getFalseValue()->isDereferenceablePointer(); 1195c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner 1196c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner for (Value::use_iterator UI = SI->use_begin(), UE = SI->use_end(); 1197c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner UI != UE; ++UI) { 1198c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner LoadInst *LI = dyn_cast<LoadInst>(*UI); 1199c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner if (LI == 0 || LI->isVolatile()) return false; 1200c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner 1201e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner // Both operands to the select need to be dereferencable, either absolutely 1202c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner // (e.g. allocas) or at this point because we can see other accesses to it. 1203c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner if (!TDerefable && !isSafeToLoadUnconditionally(SI->getTrueValue(), LI, 1204c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner LI->getAlignment(), TD)) 1205c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner return false; 1206c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner if (!FDerefable && !isSafeToLoadUnconditionally(SI->getFalseValue(), LI, 1207c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner LI->getAlignment(), TD)) 1208c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner return false; 1209c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner } 1210c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner 1211c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner return true; 1212c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner} 1213c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner 1214e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner/// isSafePHIToSpeculate - PHI instructions that use an alloca and are 1215e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner/// subsequently loaded can be rewritten to load both input pointers in the pred 1216e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner/// blocks and then PHI the results, allowing the load of the alloca to be 1217e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner/// promoted. 1218e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner/// From this: 1219e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner/// %P2 = phi [i32* %Alloca, i32* %Other] 1220e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner/// %V = load i32* %P2 1221e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner/// to: 1222e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner/// %V1 = load i32* %Alloca -> will be mem2reg'd 1223e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner/// ... 1224e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner/// %V2 = load i32* %Other 1225e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner/// ... 1226e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner/// %V = phi [i32 %V1, i32 %V2] 1227e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner/// 1228e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner/// We can do this to a select if its only uses are loads and if the operand to 1229e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner/// the select can be loaded unconditionally. 1230e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattnerstatic bool isSafePHIToSpeculate(PHINode *PN, const TargetData *TD) { 1231e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner // For now, we can only do this promotion if the load is in the same block as 1232e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner // the PHI, and if there are no stores between the phi and load. 1233e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner // TODO: Allow recursive phi users. 1234e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner // TODO: Allow stores. 1235e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner BasicBlock *BB = PN->getParent(); 1236e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner unsigned MaxAlign = 0; 1237e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner for (Value::use_iterator UI = PN->use_begin(), UE = PN->use_end(); 1238e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner UI != UE; ++UI) { 1239e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner LoadInst *LI = dyn_cast<LoadInst>(*UI); 1240e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner if (LI == 0 || LI->isVolatile()) return false; 1241e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner 1242e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner // For now we only allow loads in the same block as the PHI. This is a 1243e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner // common case that happens when instcombine merges two loads through a PHI. 1244e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner if (LI->getParent() != BB) return false; 1245e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner 1246e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner // Ensure that there are no instructions between the PHI and the load that 1247e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner // could store. 1248e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner for (BasicBlock::iterator BBI = PN; &*BBI != LI; ++BBI) 1249e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner if (BBI->mayWriteToMemory()) 1250e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner return false; 1251e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner 1252e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner MaxAlign = std::max(MaxAlign, LI->getAlignment()); 1253e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner } 1254e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner 1255e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner // Okay, we know that we have one or more loads in the same block as the PHI. 1256e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner // We can transform this if it is safe to push the loads into the predecessor 1257e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner // blocks. The only thing to watch out for is that we can't put a possibly 1258e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner // trapping load in the predecessor if it is a critical edge. 1259e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i) { 1260e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner BasicBlock *Pred = PN->getIncomingBlock(i); 1261e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner 1262e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner // If the predecessor has a single successor, then the edge isn't critical. 1263e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner if (Pred->getTerminator()->getNumSuccessors() == 1) 1264e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner continue; 1265e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner 1266e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner Value *InVal = PN->getIncomingValue(i); 1267e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner 1268e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner // If the InVal is an invoke in the pred, we can't put a load on the edge. 1269e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner if (InvokeInst *II = dyn_cast<InvokeInst>(InVal)) 1270e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner if (II->getParent() == Pred) 1271e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner return false; 1272e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner 1273e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner // If this pointer is always safe to load, or if we can prove that there is 1274e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner // already a load in the block, then we can move the load to the pred block. 1275e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner if (InVal->isDereferenceablePointer() || 1276e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner isSafeToLoadUnconditionally(InVal, Pred->getTerminator(), MaxAlign, TD)) 1277e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner continue; 1278e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner 1279e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner return false; 1280e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner } 1281e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner 1282e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner return true; 1283e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner} 1284e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner 1285c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner 1286c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner/// tryToMakeAllocaBePromotable - This returns true if the alloca only has 1287c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner/// direct (non-volatile) loads and stores to it. If the alloca is close but 1288c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner/// not quite there, this will transform the code to allow promotion. As such, 1289c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner/// it is a non-pure predicate. 1290c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattnerstatic bool tryToMakeAllocaBePromotable(AllocaInst *AI, const TargetData *TD) { 1291c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner SetVector<Instruction*, SmallVector<Instruction*, 4>, 1292c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner SmallPtrSet<Instruction*, 4> > InstsToRewrite; 1293c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner 1294c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner for (Value::use_iterator UI = AI->use_begin(), UE = AI->use_end(); 1295c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner UI != UE; ++UI) { 1296c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner User *U = *UI; 1297c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner if (LoadInst *LI = dyn_cast<LoadInst>(U)) { 1298c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner if (LI->isVolatile()) 1299c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner return false; 1300c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner continue; 1301c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner } 1302c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner 1303c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner if (StoreInst *SI = dyn_cast<StoreInst>(U)) { 1304c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner if (SI->getOperand(0) == AI || SI->isVolatile()) 1305c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner return false; // Don't allow a store OF the AI, only INTO the AI. 1306c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner continue; 1307c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner } 1308c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner 1309c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner if (SelectInst *SI = dyn_cast<SelectInst>(U)) { 1310c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner // If the condition being selected on is a constant, fold the select, yes 1311c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner // this does (rarely) happen early on. 1312c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner if (ConstantInt *CI = dyn_cast<ConstantInt>(SI->getCondition())) { 1313c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner Value *Result = SI->getOperand(1+CI->isZero()); 1314c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner SI->replaceAllUsesWith(Result); 1315c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner SI->eraseFromParent(); 1316c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner 1317c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner // This is very rare and we just scrambled the use list of AI, start 1318c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner // over completely. 1319c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner return tryToMakeAllocaBePromotable(AI, TD); 1320c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner } 1321c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner 1322c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner // If it is safe to turn "load (select c, AI, ptr)" into a select of two 1323c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner // loads, then we can transform this by rewriting the select. 1324c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner if (!isSafeSelectToSpeculate(SI, TD)) 1325c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner return false; 1326c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner 1327c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner InstsToRewrite.insert(SI); 1328c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner continue; 1329c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner } 1330c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner 1331e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner if (PHINode *PN = dyn_cast<PHINode>(U)) { 1332e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner if (PN->use_empty()) { // Dead PHIs can be stripped. 1333e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner InstsToRewrite.insert(PN); 1334e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner continue; 1335e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner } 1336e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner 1337e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner // If it is safe to turn "load (phi [AI, ptr, ...])" into a PHI of loads 1338e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner // in the pred blocks, then we can transform this by rewriting the PHI. 1339e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner if (!isSafePHIToSpeculate(PN, TD)) 1340e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner return false; 1341e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner 1342e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner InstsToRewrite.insert(PN); 1343e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner continue; 1344e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner } 1345e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner 1346c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner return false; 1347c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner } 1348c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner 1349c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner // If there are no instructions to rewrite, then all uses are load/stores and 1350c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner // we're done! 1351c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner if (InstsToRewrite.empty()) 1352c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner return true; 1353c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner 1354c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner // If we have instructions that need to be rewritten for this to be promotable 1355c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner // take care of it now. 1356c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner for (unsigned i = 0, e = InstsToRewrite.size(); i != e; ++i) { 1357e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner if (SelectInst *SI = dyn_cast<SelectInst>(InstsToRewrite[i])) { 1358e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner // Selects in InstsToRewrite only have load uses. Rewrite each as two 1359e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner // loads with a new select. 1360e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner while (!SI->use_empty()) { 1361e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner LoadInst *LI = cast<LoadInst>(SI->use_back()); 1362c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner 1363e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner IRBuilder<> Builder(LI); 1364e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner LoadInst *TrueLoad = 1365e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner Builder.CreateLoad(SI->getTrueValue(), LI->getName()+".t"); 1366e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner LoadInst *FalseLoad = 1367394d1f1948c1b5c9e902059104b08a4837dfbbeeNick Lewycky Builder.CreateLoad(SI->getFalseValue(), LI->getName()+".f"); 1368e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner 1369e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner // Transfer alignment and TBAA info if present. 1370e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner TrueLoad->setAlignment(LI->getAlignment()); 1371e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner FalseLoad->setAlignment(LI->getAlignment()); 1372e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner if (MDNode *Tag = LI->getMetadata(LLVMContext::MD_tbaa)) { 1373e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner TrueLoad->setMetadata(LLVMContext::MD_tbaa, Tag); 1374e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner FalseLoad->setMetadata(LLVMContext::MD_tbaa, Tag); 1375e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner } 1376e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner 1377e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner Value *V = Builder.CreateSelect(SI->getCondition(), TrueLoad, FalseLoad); 1378e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner V->takeName(LI); 1379e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner LI->replaceAllUsesWith(V); 1380e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner LI->eraseFromParent(); 1381c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner } 1382e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner 1383e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner // Now that all the loads are gone, the select is gone too. 1384e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner SI->eraseFromParent(); 1385e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner continue; 1386e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner } 1387e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner 1388e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner // Otherwise, we have a PHI node which allows us to push the loads into the 1389e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner // predecessors. 1390e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner PHINode *PN = cast<PHINode>(InstsToRewrite[i]); 1391e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner if (PN->use_empty()) { 1392e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner PN->eraseFromParent(); 1393e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner continue; 1394e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner } 1395e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner 1396db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *LoadTy = cast<PointerType>(PN->getType())->getElementType(); 13973ecfc861b4365f341c5c969b40e1afccde676e6fJay Foad PHINode *NewPN = PHINode::Create(LoadTy, PN->getNumIncomingValues(), 13983ecfc861b4365f341c5c969b40e1afccde676e6fJay Foad PN->getName()+".ld", PN); 1399e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner 1400e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner // Get the TBAA tag and alignment to use from one of the loads. It doesn't 1401e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner // matter which one we get and if any differ, it doesn't matter. 1402e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner LoadInst *SomeLoad = cast<LoadInst>(PN->use_back()); 1403e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner MDNode *TBAATag = SomeLoad->getMetadata(LLVMContext::MD_tbaa); 1404e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner unsigned Align = SomeLoad->getAlignment(); 1405e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner 1406e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner // Rewrite all loads of the PN to use the new PHI. 1407e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner while (!PN->use_empty()) { 1408e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner LoadInst *LI = cast<LoadInst>(PN->use_back()); 1409e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner LI->replaceAllUsesWith(NewPN); 1410c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner LI->eraseFromParent(); 1411c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner } 1412c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner 1413e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner // Inject loads into all of the pred blocks. Keep track of which blocks we 1414e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner // insert them into in case we have multiple edges from the same block. 1415e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner DenseMap<BasicBlock*, LoadInst*> InsertedLoads; 1416e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner 1417e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i) { 1418e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner BasicBlock *Pred = PN->getIncomingBlock(i); 1419e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner LoadInst *&Load = InsertedLoads[Pred]; 1420e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner if (Load == 0) { 1421e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner Load = new LoadInst(PN->getIncomingValue(i), 1422e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner PN->getName() + "." + Pred->getName(), 1423e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner Pred->getTerminator()); 1424e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner Load->setAlignment(Align); 1425e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner if (TBAATag) Load->setMetadata(LLVMContext::MD_tbaa, TBAATag); 1426e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner } 1427e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner 1428e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner NewPN->addIncoming(Load, Pred); 1429e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner } 1430e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner 1431e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner PN->eraseFromParent(); 1432c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner } 1433c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner 1434c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner ++NumAdjusted; 1435c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner return true; 1436c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner} 1437c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner 14384cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattnerbool SROA::performPromotion(Function &F) { 14394cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner std::vector<AllocaInst*> Allocas; 1440e0a1a5ba91df6817f9ffae7af65ed0bda66f7620Chris Lattner DominatorTree *DT = 0; 1441b1686c32fc694636cbf15a59b23b2a741b65ecf4Cameron Zwarich if (HasDomTree) 1442e0a1a5ba91df6817f9ffae7af65ed0bda66f7620Chris Lattner DT = &getAnalysis<DominatorTree>(); 1443b742defa0a8f3e477c3ed641da49aab276937556Bob Wilson 14444cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner BasicBlock &BB = F.getEntryBlock(); // Get the entry node for the function 1445231a5ab746ca12000aa57208869a98f78781aa6bDevang Patel DIBuilder DIB(*F.getParent()); 14464cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner bool Changed = false; 1447deaf55f69865bbc997a569c2a689ec5b0fbdefefChris Lattner SmallVector<Instruction*, 64> Insts; 14484cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner while (1) { 14494cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Allocas.clear(); 14504cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner 14514cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Find allocas that are safe to promote, by looking at all instructions in 14524cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // the entry node 14534cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner for (BasicBlock::iterator I = BB.begin(), E = --BB.end(); I != E; ++I) 14544cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (AllocaInst *AI = dyn_cast<AllocaInst>(I)) // Is it an alloca? 1455c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner if (tryToMakeAllocaBePromotable(AI, TD)) 14564cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Allocas.push_back(AI); 14574cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner 14584cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (Allocas.empty()) break; 14594cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner 1460b1686c32fc694636cbf15a59b23b2a741b65ecf4Cameron Zwarich if (HasDomTree) 1461419e8a62997987e0509efe721c1ea81ac29f09f3Cameron Zwarich PromoteMemToReg(Allocas, *DT); 1462e0a1a5ba91df6817f9ffae7af65ed0bda66f7620Chris Lattner else { 1463e0a1a5ba91df6817f9ffae7af65ed0bda66f7620Chris Lattner SSAUpdater SSA; 1464deaf55f69865bbc997a569c2a689ec5b0fbdefefChris Lattner for (unsigned i = 0, e = Allocas.size(); i != e; ++i) { 1465deaf55f69865bbc997a569c2a689ec5b0fbdefefChris Lattner AllocaInst *AI = Allocas[i]; 1466deaf55f69865bbc997a569c2a689ec5b0fbdefefChris Lattner 1467deaf55f69865bbc997a569c2a689ec5b0fbdefefChris Lattner // Build list of instructions to promote. 1468deaf55f69865bbc997a569c2a689ec5b0fbdefefChris Lattner for (Value::use_iterator UI = AI->use_begin(), E = AI->use_end(); 1469deaf55f69865bbc997a569c2a689ec5b0fbdefefChris Lattner UI != E; ++UI) 1470deaf55f69865bbc997a569c2a689ec5b0fbdefefChris Lattner Insts.push_back(cast<Instruction>(*UI)); 1471231a5ab746ca12000aa57208869a98f78781aa6bDevang Patel AllocaPromoter(Insts, SSA, &DIB).run(AI, Insts); 1472deaf55f69865bbc997a569c2a689ec5b0fbdefefChris Lattner Insts.clear(); 1473deaf55f69865bbc997a569c2a689ec5b0fbdefefChris Lattner } 1474e0a1a5ba91df6817f9ffae7af65ed0bda66f7620Chris Lattner } 14754cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner NumPromoted += Allocas.size(); 14764cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Changed = true; 14774cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 14784cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner 14794cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner return Changed; 14804cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner} 14814cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner 14824cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner 14834cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// ShouldAttemptScalarRepl - Decide if an alloca is a good candidate for 14844cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// SROA. It must be a struct or array type with a small number of elements. 14854cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattnerstatic bool ShouldAttemptScalarRepl(AllocaInst *AI) { 1486db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *T = AI->getAllocatedType(); 14874cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Do not promote any struct into more than 32 separate vars. 1488db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner if (StructType *ST = dyn_cast<StructType>(T)) 14894cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner return ST->getNumElements() <= 32; 14904cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Arrays are much less likely to be safe for SROA; only consider 14914cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // them if they are very small. 1492db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner if (ArrayType *AT = dyn_cast<ArrayType>(T)) 14934cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner return AT->getNumElements() <= 8; 14944cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner return false; 14954cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner} 14964cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner 14974cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner 14984cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner// performScalarRepl - This algorithm is a simple worklist driven algorithm, 14999174d5c7383490d79b6a483d73cded54e32275d6Nick Lewycky// which runs on all of the alloca instructions in the function, removing them 15009174d5c7383490d79b6a483d73cded54e32275d6Nick Lewycky// if they are only used by getelementptr instructions. 15014cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner// 15024cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattnerbool SROA::performScalarRepl(Function &F) { 15034cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner std::vector<AllocaInst*> WorkList; 15044cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner 15054cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Scan the entry basic block, adding allocas to the worklist. 15064cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner BasicBlock &BB = F.getEntryBlock(); 15074cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner for (BasicBlock::iterator I = BB.begin(), E = BB.end(); I != E; ++I) 15084cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (AllocaInst *A = dyn_cast<AllocaInst>(I)) 15094cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner WorkList.push_back(A); 15104cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner 15114cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Process the worklist 15124cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner bool Changed = false; 15134cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner while (!WorkList.empty()) { 15144cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner AllocaInst *AI = WorkList.back(); 15154cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner WorkList.pop_back(); 15166974302e3ff20746268721959efed807c7711bfcBob Wilson 15174cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Handle dead allocas trivially. These can be formed by SROA'ing arrays 15184cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // with unused elements. 15194cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (AI->use_empty()) { 15204cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner AI->eraseFromParent(); 15214cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Changed = true; 15224cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner continue; 1523d93afec1dbbb1abb3df55e2e007b5f256d09f84aChris Lattner } 15244cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner 15254cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // If this alloca is impossible for us to promote, reject it early. 15264cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (AI->isArrayAllocation() || !AI->getAllocatedType()->isSized()) 15274cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner continue; 15286974302e3ff20746268721959efed807c7711bfcBob Wilson 15294cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Check to see if this allocation is only modified by a memcpy/memmove from 15304cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // a constant global. If this is the case, we can change all users to use 15314cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // the constant global instead. This is commonly produced by the CFE by 15324cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // constructs like "void foo() { int A[] = {1,2,3,4,5,6,7,8,9...}; }" if 'A' 15334cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // is only subsequently read. 15349174d5c7383490d79b6a483d73cded54e32275d6Nick Lewycky SmallVector<Instruction *, 4> ToDelete; 15359174d5c7383490d79b6a483d73cded54e32275d6Nick Lewycky if (MemTransferInst *Copy = isOnlyCopiedFromConstantGlobal(AI, ToDelete)) { 15364cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner DEBUG(dbgs() << "Found alloca equal to global: " << *AI << '\n'); 15379174d5c7383490d79b6a483d73cded54e32275d6Nick Lewycky DEBUG(dbgs() << " memcpy = " << *Copy << '\n'); 15389174d5c7383490d79b6a483d73cded54e32275d6Nick Lewycky for (unsigned i = 0, e = ToDelete.size(); i != e; ++i) 15399174d5c7383490d79b6a483d73cded54e32275d6Nick Lewycky ToDelete[i]->eraseFromParent(); 15409174d5c7383490d79b6a483d73cded54e32275d6Nick Lewycky Constant *TheSrc = cast<Constant>(Copy->getSource()); 15414cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner AI->replaceAllUsesWith(ConstantExpr::getBitCast(TheSrc, AI->getType())); 15429174d5c7383490d79b6a483d73cded54e32275d6Nick Lewycky Copy->eraseFromParent(); // Don't mutate the global. 15434cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner AI->eraseFromParent(); 15444cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner ++NumGlobals; 15454cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Changed = true; 15464cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner continue; 15474cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 15486974302e3ff20746268721959efed807c7711bfcBob Wilson 15494cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Check to see if we can perform the core SROA transformation. We cannot 15504cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // transform the allocation instruction if it is an array allocation 15514cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // (allocations OF arrays are ok though), and an allocation of a scalar 15524cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // value cannot be decomposed at all. 15534cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner uint64_t AllocaSize = TD->getTypeAllocSize(AI->getAllocatedType()); 155444118f0e25c25fedda1ccdd6a72f072c0b5c96e7Dan Gohman 15554cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Do not promote [0 x %struct]. 15564cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (AllocaSize == 0) continue; 15576974302e3ff20746268721959efed807c7711bfcBob Wilson 15584cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Do not promote any struct whose size is too big. 15594cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (AllocaSize > SRThreshold) continue; 15606974302e3ff20746268721959efed807c7711bfcBob Wilson 15614cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // If the alloca looks like a good candidate for scalar replacement, and if 15624cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // all its users can be transformed, then split up the aggregate into its 15634cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // separate elements. 15644cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (ShouldAttemptScalarRepl(AI) && isSafeAllocaToScalarRepl(AI)) { 15654cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner DoScalarReplacement(AI, WorkList); 15664cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Changed = true; 15674cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner continue; 156820adc9dc4650313f017b27d9818eb2176238113dMon P Wang } 15694cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner 15704cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // If we can turn this aggregate value (potentially with casts) into a 15714cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // simple scalar value that can be mem2reg'd into a register value. 15724cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // IsNotTrivial tracks whether this is something that mem2reg could have 15734cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // promoted itself. If so, we don't want to transform it needlessly. Note 15744cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // that we can't just check based on the type: the alloca may be of an i32 15754cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // but that has pointer arithmetic to set byte 3 of it or something. 15764cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (AllocaInst *NewAI = 15774cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner ConvertToScalarInfo((unsigned)AllocaSize, *TD).TryConvert(AI)) { 15784cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner NewAI->takeName(AI); 15794cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner AI->eraseFromParent(); 15804cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner ++NumConverted; 15814cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Changed = true; 15824cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner continue; 15836974302e3ff20746268721959efed807c7711bfcBob Wilson } 15846974302e3ff20746268721959efed807c7711bfcBob Wilson 15854cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Otherwise, couldn't process this alloca. 1586372dda8881c7a32a6f5ce0f76a713e3a9ef46ea1Chris Lattner } 15874cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner 15884cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner return Changed; 1589372dda8881c7a32a6f5ce0f76a713e3a9ef46ea1Chris Lattner} 1590d2fa781169175b827e50953a1d0b7edc6b0c4801Chris Lattner 15914cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// DoScalarReplacement - This alloca satisfied the isSafeAllocaToScalarRepl 15924cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// predicate, do SROA now. 15936974302e3ff20746268721959efed807c7711bfcBob Wilsonvoid SROA::DoScalarReplacement(AllocaInst *AI, 15944cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner std::vector<AllocaInst*> &WorkList) { 15954cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner DEBUG(dbgs() << "Found inst to SROA: " << *AI << '\n'); 15964cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner SmallVector<AllocaInst*, 32> ElementAllocas; 1597db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner if (StructType *ST = dyn_cast<StructType>(AI->getAllocatedType())) { 15984cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner ElementAllocas.reserve(ST->getNumContainedTypes()); 15994cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner for (unsigned i = 0, e = ST->getNumContainedTypes(); i != e; ++i) { 16006974302e3ff20746268721959efed807c7711bfcBob Wilson AllocaInst *NA = new AllocaInst(ST->getContainedType(i), 0, 16014cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner AI->getAlignment(), 16024cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner AI->getName() + "." + Twine(i), AI); 16034cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner ElementAllocas.push_back(NA); 16044cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner WorkList.push_back(NA); // Add to worklist for recursive processing 16054cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 16064cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } else { 1607db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner ArrayType *AT = cast<ArrayType>(AI->getAllocatedType()); 16084cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner ElementAllocas.reserve(AT->getNumElements()); 1609db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *ElTy = AT->getElementType(); 16104cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner for (unsigned i = 0, e = AT->getNumElements(); i != e; ++i) { 16114cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner AllocaInst *NA = new AllocaInst(ElTy, 0, AI->getAlignment(), 16124cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner AI->getName() + "." + Twine(i), AI); 16134cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner ElementAllocas.push_back(NA); 16144cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner WorkList.push_back(NA); // Add to worklist for recursive processing 16154cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 16164cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 1617d2fa781169175b827e50953a1d0b7edc6b0c4801Chris Lattner 16184cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Now that we have created the new alloca instructions, rewrite all the 16194cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // uses of the old alloca. 16204cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner RewriteForScalarRepl(AI, AI, 0, ElementAllocas); 1621d2fa781169175b827e50953a1d0b7edc6b0c4801Chris Lattner 16224cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Now erase any instructions that were made dead while rewriting the alloca. 16234cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner DeleteDeadInstructions(); 16244cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner AI->eraseFromParent(); 16254cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner 1626fe60104ac97f3a8736dcfbfdf9547c7b7cc7b951Dan Gohman ++NumReplaced; 16274cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner} 16284cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner 16294cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// DeleteDeadInstructions - Erase instructions on the DeadInstrs list, 16304cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// recursively including all their operands that become trivially dead. 16314cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattnervoid SROA::DeleteDeadInstructions() { 16324cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner while (!DeadInsts.empty()) { 16334cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Instruction *I = cast<Instruction>(DeadInsts.pop_back_val()); 16344cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner 16354cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner for (User::op_iterator OI = I->op_begin(), E = I->op_end(); OI != E; ++OI) 16364cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (Instruction *U = dyn_cast<Instruction>(*OI)) { 16374cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Zero out the operand and see if it becomes trivially dead. 16384cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // (But, don't add allocas to the dead instruction list -- they are 16394cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // already on the worklist and will be deleted separately.) 16404cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner *OI = 0; 16414cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (isInstructionTriviallyDead(U) && !isa<AllocaInst>(U)) 16424cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner DeadInsts.push_back(U); 1643d2fa781169175b827e50953a1d0b7edc6b0c4801Chris Lattner } 1644d2fa781169175b827e50953a1d0b7edc6b0c4801Chris Lattner 16454cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner I->eraseFromParent(); 16464cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 16474cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner} 16486974302e3ff20746268721959efed807c7711bfcBob Wilson 16494cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// isSafeForScalarRepl - Check if instruction I is a safe use with regard to 16504cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// performing scalar replacement of alloca AI. The results are flagged in 16514cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// the Info parameter. Offset indicates the position within AI that is 16524cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// referenced by this instruction. 16536c95d24927b11fb76bc3e76ebe6a8198d74fc178Chris Lattnervoid SROA::isSafeForScalarRepl(Instruction *I, uint64_t Offset, 16544cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner AllocaInfo &Info) { 16554cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner for (Value::use_iterator UI = I->use_begin(), E = I->use_end(); UI!=E; ++UI) { 16564cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Instruction *User = cast<Instruction>(*UI); 16574cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner 16584cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (BitCastInst *BC = dyn_cast<BitCastInst>(User)) { 16596c95d24927b11fb76bc3e76ebe6a8198d74fc178Chris Lattner isSafeForScalarRepl(BC, Offset, Info); 16604cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } else if (GetElementPtrInst *GEPI = dyn_cast<GetElementPtrInst>(User)) { 16614cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner uint64_t GEPOffset = Offset; 16626c95d24927b11fb76bc3e76ebe6a8198d74fc178Chris Lattner isSafeGEP(GEPI, GEPOffset, Info); 16634cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (!Info.isUnsafe) 16646c95d24927b11fb76bc3e76ebe6a8198d74fc178Chris Lattner isSafeForScalarRepl(GEPI, GEPOffset, Info); 166519101c7585c191376d898e3e66e35acd9bd777c2Gabor Greif } else if (MemIntrinsic *MI = dyn_cast<MemIntrinsic>(User)) { 16664cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner ConstantInt *Length = dyn_cast<ConstantInt>(MI->getLength()); 1667d01a0da090407762fe3b770d84f049d72d06467eChris Lattner if (Length == 0) 1668d01a0da090407762fe3b770d84f049d72d06467eChris Lattner return MarkUnsafe(Info, User); 16696c95d24927b11fb76bc3e76ebe6a8198d74fc178Chris Lattner isSafeMemAccess(Offset, Length->getZExtValue(), 0, 1670145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner UI.getOperandNo() == 0, Info, MI, 1671145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner true /*AllowWholeAccess*/); 16724cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } else if (LoadInst *LI = dyn_cast<LoadInst>(User)) { 1673d01a0da090407762fe3b770d84f049d72d06467eChris Lattner if (LI->isVolatile()) 1674d01a0da090407762fe3b770d84f049d72d06467eChris Lattner return MarkUnsafe(Info, User); 1675db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *LIType = LI->getType(); 16766c95d24927b11fb76bc3e76ebe6a8198d74fc178Chris Lattner isSafeMemAccess(Offset, TD->getTypeAllocSize(LIType), 1677145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner LIType, false, Info, LI, true /*AllowWholeAccess*/); 1678d01a0da090407762fe3b770d84f049d72d06467eChris Lattner Info.hasALoadOrStore = true; 1679d01a0da090407762fe3b770d84f049d72d06467eChris Lattner 16804cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } else if (StoreInst *SI = dyn_cast<StoreInst>(User)) { 16814cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Store is ok if storing INTO the pointer, not storing the pointer 1682d01a0da090407762fe3b770d84f049d72d06467eChris Lattner if (SI->isVolatile() || SI->getOperand(0) == I) 1683d01a0da090407762fe3b770d84f049d72d06467eChris Lattner return MarkUnsafe(Info, User); 1684d01a0da090407762fe3b770d84f049d72d06467eChris Lattner 1685db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *SIType = SI->getOperand(0)->getType(); 16866c95d24927b11fb76bc3e76ebe6a8198d74fc178Chris Lattner isSafeMemAccess(Offset, TD->getTypeAllocSize(SIType), 1687145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner SIType, true, Info, SI, true /*AllowWholeAccess*/); 1688145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner Info.hasALoadOrStore = true; 1689145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner } else if (isa<PHINode>(User) || isa<SelectInst>(User)) { 1690145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner isSafePHISelectUseForScalarRepl(User, Offset, Info); 1691145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner } else { 1692145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner return MarkUnsafe(Info, User); 1693145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner } 1694145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner if (Info.isUnsafe) return; 1695145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner } 1696145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner} 1697145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner 1698145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner 1699145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner/// isSafePHIUseForScalarRepl - If we see a PHI node or select using a pointer 1700145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner/// derived from the alloca, we can often still split the alloca into elements. 1701145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner/// This is useful if we have a large alloca where one element is phi'd 1702145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner/// together somewhere: we can SRoA and promote all the other elements even if 1703145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner/// we end up not being able to promote this one. 1704145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner/// 1705145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner/// All we require is that the uses of the PHI do not index into other parts of 1706145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner/// the alloca. The most important use case for this is single load and stores 1707145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner/// that are PHI'd together, which can happen due to code sinking. 1708145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattnervoid SROA::isSafePHISelectUseForScalarRepl(Instruction *I, uint64_t Offset, 1709145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner AllocaInfo &Info) { 1710145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner // If we've already checked this PHI, don't do it again. 1711145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner if (PHINode *PN = dyn_cast<PHINode>(I)) 1712145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner if (!Info.CheckedPHIs.insert(PN)) 1713145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner return; 1714145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner 1715145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner for (Value::use_iterator UI = I->use_begin(), E = I->use_end(); UI!=E; ++UI) { 1716145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner Instruction *User = cast<Instruction>(*UI); 1717145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner 1718145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner if (BitCastInst *BC = dyn_cast<BitCastInst>(User)) { 1719145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner isSafePHISelectUseForScalarRepl(BC, Offset, Info); 1720145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner } else if (GetElementPtrInst *GEPI = dyn_cast<GetElementPtrInst>(User)) { 1721145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner // Only allow "bitcast" GEPs for simplicity. We could generalize this, 1722145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner // but would have to prove that we're staying inside of an element being 1723145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner // promoted. 1724145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner if (!GEPI->hasAllZeroIndices()) 1725145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner return MarkUnsafe(Info, User); 1726145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner isSafePHISelectUseForScalarRepl(GEPI, Offset, Info); 1727145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner } else if (LoadInst *LI = dyn_cast<LoadInst>(User)) { 1728145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner if (LI->isVolatile()) 1729145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner return MarkUnsafe(Info, User); 1730db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *LIType = LI->getType(); 1731145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner isSafeMemAccess(Offset, TD->getTypeAllocSize(LIType), 1732145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner LIType, false, Info, LI, false /*AllowWholeAccess*/); 1733145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner Info.hasALoadOrStore = true; 1734145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner 1735145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner } else if (StoreInst *SI = dyn_cast<StoreInst>(User)) { 1736145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner // Store is ok if storing INTO the pointer, not storing the pointer 1737145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner if (SI->isVolatile() || SI->getOperand(0) == I) 1738145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner return MarkUnsafe(Info, User); 1739145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner 1740db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *SIType = SI->getOperand(0)->getType(); 1741145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner isSafeMemAccess(Offset, TD->getTypeAllocSize(SIType), 1742145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner SIType, true, Info, SI, false /*AllowWholeAccess*/); 1743d01a0da090407762fe3b770d84f049d72d06467eChris Lattner Info.hasALoadOrStore = true; 1744145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner } else if (isa<PHINode>(User) || isa<SelectInst>(User)) { 1745145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner isSafePHISelectUseForScalarRepl(User, Offset, Info); 17464cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } else { 1747d01a0da090407762fe3b770d84f049d72d06467eChris Lattner return MarkUnsafe(Info, User); 1748d2fa781169175b827e50953a1d0b7edc6b0c4801Chris Lattner } 17494cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (Info.isUnsafe) return; 1750d2fa781169175b827e50953a1d0b7edc6b0c4801Chris Lattner } 1751d2fa781169175b827e50953a1d0b7edc6b0c4801Chris Lattner} 1752d2fa781169175b827e50953a1d0b7edc6b0c4801Chris Lattner 17534cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// isSafeGEP - Check if a GEP instruction can be handled for scalar 17544cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// replacement. It is safe when all the indices are constant, in-bounds 17554cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// references, and when the resulting offset corresponds to an element within 17564cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// the alloca type. The results are flagged in the Info parameter. Upon 17574cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// return, Offset is adjusted as specified by the GEP indices. 17586c95d24927b11fb76bc3e76ebe6a8198d74fc178Chris Lattnervoid SROA::isSafeGEP(GetElementPtrInst *GEPI, 17594cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner uint64_t &Offset, AllocaInfo &Info) { 17604cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner gep_type_iterator GEPIt = gep_type_begin(GEPI), E = gep_type_end(GEPI); 17614cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (GEPIt == E) 17624cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner return; 17635ffe6acd577696a41932c7b82db06a04687e07baChris Lattner 17644cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Walk through the GEP type indices, checking the types that this indexes 17654cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // into. 17664cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner for (; GEPIt != E; ++GEPIt) { 17674cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Ignore struct elements, no extra checking needed for these. 17684cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if ((*GEPIt)->isStructTy()) 17694cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner continue; 17705ffe6acd577696a41932c7b82db06a04687e07baChris Lattner 17714cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner ConstantInt *IdxVal = dyn_cast<ConstantInt>(GEPIt.getOperand()); 17724cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (!IdxVal) 1773d01a0da090407762fe3b770d84f049d72d06467eChris Lattner return MarkUnsafe(Info, GEPI); 17745ffe6acd577696a41932c7b82db06a04687e07baChris Lattner } 177541b33f437f70dcf63e35d08e5f4202258ef05c15Eli Friedman 17764cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Compute the offset due to this GEP and check if the alloca has a 17774cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // component element at that offset. 17784cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner SmallVector<Value*, 8> Indices(GEPI->op_begin() + 1, GEPI->op_end()); 17798fbbb3980755d74539a0aed02bc18842ed2bd18dJay Foad Offset += TD->getIndexedOffset(GEPI->getPointerOperandType(), Indices); 17806c95d24927b11fb76bc3e76ebe6a8198d74fc178Chris Lattner if (!TypeHasComponent(Info.AI->getAllocatedType(), Offset, 0)) 1781d01a0da090407762fe3b770d84f049d72d06467eChris Lattner MarkUnsafe(Info, GEPI); 17824cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner} 178341b33f437f70dcf63e35d08e5f4202258ef05c15Eli Friedman 1784704d1347c5009f674408fae6f78343b415891274Bob Wilson/// isHomogeneousAggregate - Check if type T is a struct or array containing 1785704d1347c5009f674408fae6f78343b415891274Bob Wilson/// elements of the same type (which is always true for arrays). If so, 1786704d1347c5009f674408fae6f78343b415891274Bob Wilson/// return true with NumElts and EltTy set to the number of elements and the 1787704d1347c5009f674408fae6f78343b415891274Bob Wilson/// element type, respectively. 1788db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattnerstatic bool isHomogeneousAggregate(Type *T, unsigned &NumElts, 1789db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *&EltTy) { 1790db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner if (ArrayType *AT = dyn_cast<ArrayType>(T)) { 1791704d1347c5009f674408fae6f78343b415891274Bob Wilson NumElts = AT->getNumElements(); 1792f0908aeade2f41d2fed82de8d85448358b379328Bob Wilson EltTy = (NumElts == 0 ? 0 : AT->getElementType()); 1793704d1347c5009f674408fae6f78343b415891274Bob Wilson return true; 1794704d1347c5009f674408fae6f78343b415891274Bob Wilson } 1795db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner if (StructType *ST = dyn_cast<StructType>(T)) { 1796704d1347c5009f674408fae6f78343b415891274Bob Wilson NumElts = ST->getNumContainedTypes(); 1797f0908aeade2f41d2fed82de8d85448358b379328Bob Wilson EltTy = (NumElts == 0 ? 0 : ST->getContainedType(0)); 1798704d1347c5009f674408fae6f78343b415891274Bob Wilson for (unsigned n = 1; n < NumElts; ++n) { 1799704d1347c5009f674408fae6f78343b415891274Bob Wilson if (ST->getContainedType(n) != EltTy) 1800704d1347c5009f674408fae6f78343b415891274Bob Wilson return false; 1801704d1347c5009f674408fae6f78343b415891274Bob Wilson } 1802704d1347c5009f674408fae6f78343b415891274Bob Wilson return true; 1803704d1347c5009f674408fae6f78343b415891274Bob Wilson } 1804704d1347c5009f674408fae6f78343b415891274Bob Wilson return false; 1805704d1347c5009f674408fae6f78343b415891274Bob Wilson} 1806704d1347c5009f674408fae6f78343b415891274Bob Wilson 1807704d1347c5009f674408fae6f78343b415891274Bob Wilson/// isCompatibleAggregate - Check if T1 and T2 are either the same type or are 1808704d1347c5009f674408fae6f78343b415891274Bob Wilson/// "homogeneous" aggregates with the same element type and number of elements. 1809db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattnerstatic bool isCompatibleAggregate(Type *T1, Type *T2) { 1810704d1347c5009f674408fae6f78343b415891274Bob Wilson if (T1 == T2) 1811704d1347c5009f674408fae6f78343b415891274Bob Wilson return true; 1812704d1347c5009f674408fae6f78343b415891274Bob Wilson 1813704d1347c5009f674408fae6f78343b415891274Bob Wilson unsigned NumElts1, NumElts2; 1814db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *EltTy1, *EltTy2; 1815704d1347c5009f674408fae6f78343b415891274Bob Wilson if (isHomogeneousAggregate(T1, NumElts1, EltTy1) && 1816704d1347c5009f674408fae6f78343b415891274Bob Wilson isHomogeneousAggregate(T2, NumElts2, EltTy2) && 1817704d1347c5009f674408fae6f78343b415891274Bob Wilson NumElts1 == NumElts2 && 1818704d1347c5009f674408fae6f78343b415891274Bob Wilson EltTy1 == EltTy2) 1819704d1347c5009f674408fae6f78343b415891274Bob Wilson return true; 1820704d1347c5009f674408fae6f78343b415891274Bob Wilson 1821704d1347c5009f674408fae6f78343b415891274Bob Wilson return false; 1822704d1347c5009f674408fae6f78343b415891274Bob Wilson} 1823704d1347c5009f674408fae6f78343b415891274Bob Wilson 18244cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// isSafeMemAccess - Check if a load/store/memcpy operates on the entire AI 18254cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// alloca or has an offset and size that corresponds to a component element 18264cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// within it. The offset checked here may have been formed from a GEP with a 18274cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// pointer bitcasted to a different type. 1828145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner/// 1829145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner/// If AllowWholeAccess is true, then this allows uses of the entire alloca as a 1830145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner/// unit. If false, it only allows accesses known to be in a single element. 18316c95d24927b11fb76bc3e76ebe6a8198d74fc178Chris Lattnervoid SROA::isSafeMemAccess(uint64_t Offset, uint64_t MemSize, 1832db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *MemOpType, bool isStore, 1833145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner AllocaInfo &Info, Instruction *TheAccess, 1834145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner bool AllowWholeAccess) { 18354cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Check if this is a load/store of the entire alloca. 1836145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner if (Offset == 0 && AllowWholeAccess && 18376c95d24927b11fb76bc3e76ebe6a8198d74fc178Chris Lattner MemSize == TD->getTypeAllocSize(Info.AI->getAllocatedType())) { 1838704d1347c5009f674408fae6f78343b415891274Bob Wilson // This can be safe for MemIntrinsics (where MemOpType is 0) and integer 1839704d1347c5009f674408fae6f78343b415891274Bob Wilson // loads/stores (which are essentially the same as the MemIntrinsics with 1840704d1347c5009f674408fae6f78343b415891274Bob Wilson // regard to copying padding between elements). But, if an alloca is 1841704d1347c5009f674408fae6f78343b415891274Bob Wilson // flagged as both a source and destination of such operations, we'll need 1842704d1347c5009f674408fae6f78343b415891274Bob Wilson // to check later for padding between elements. 1843704d1347c5009f674408fae6f78343b415891274Bob Wilson if (!MemOpType || MemOpType->isIntegerTy()) { 1844704d1347c5009f674408fae6f78343b415891274Bob Wilson if (isStore) 1845704d1347c5009f674408fae6f78343b415891274Bob Wilson Info.isMemCpyDst = true; 1846704d1347c5009f674408fae6f78343b415891274Bob Wilson else 1847704d1347c5009f674408fae6f78343b415891274Bob Wilson Info.isMemCpySrc = true; 18484cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner return; 18494cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 1850704d1347c5009f674408fae6f78343b415891274Bob Wilson // This is also safe for references using a type that is compatible with 1851704d1347c5009f674408fae6f78343b415891274Bob Wilson // the type of the alloca, so that loads/stores can be rewritten using 1852704d1347c5009f674408fae6f78343b415891274Bob Wilson // insertvalue/extractvalue. 18536c95d24927b11fb76bc3e76ebe6a8198d74fc178Chris Lattner if (isCompatibleAggregate(MemOpType, Info.AI->getAllocatedType())) { 18547e9b427c879ae32b72fd24aeaf011e87e5692fd7Chris Lattner Info.hasSubelementAccess = true; 1855704d1347c5009f674408fae6f78343b415891274Bob Wilson return; 18567e9b427c879ae32b72fd24aeaf011e87e5692fd7Chris Lattner } 18574cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 18584cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Check if the offset/size correspond to a component within the alloca type. 1859db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *T = Info.AI->getAllocatedType(); 18607e9b427c879ae32b72fd24aeaf011e87e5692fd7Chris Lattner if (TypeHasComponent(T, Offset, MemSize)) { 18617e9b427c879ae32b72fd24aeaf011e87e5692fd7Chris Lattner Info.hasSubelementAccess = true; 18624cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner return; 18637e9b427c879ae32b72fd24aeaf011e87e5692fd7Chris Lattner } 18644cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner 1865d01a0da090407762fe3b770d84f049d72d06467eChris Lattner return MarkUnsafe(Info, TheAccess); 18665ffe6acd577696a41932c7b82db06a04687e07baChris Lattner} 18675ffe6acd577696a41932c7b82db06a04687e07baChris Lattner 18684cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// TypeHasComponent - Return true if T has a component type with the 18694cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// specified offset and size. If Size is zero, do not check the size. 1870db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattnerbool SROA::TypeHasComponent(Type *T, uint64_t Offset, uint64_t Size) { 1871db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *EltTy; 18724cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner uint64_t EltSize; 1873db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner if (StructType *ST = dyn_cast<StructType>(T)) { 18744cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner const StructLayout *Layout = TD->getStructLayout(ST); 18754cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner unsigned EltIdx = Layout->getElementContainingOffset(Offset); 18764cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner EltTy = ST->getContainedType(EltIdx); 18774cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner EltSize = TD->getTypeAllocSize(EltTy); 18784cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Offset -= Layout->getElementOffset(EltIdx); 1879db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner } else if (ArrayType *AT = dyn_cast<ArrayType>(T)) { 18804cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner EltTy = AT->getElementType(); 18814cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner EltSize = TD->getTypeAllocSize(EltTy); 18824cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (Offset >= AT->getNumElements() * EltSize) 18834cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner return false; 18844cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Offset %= EltSize; 18854cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } else { 18864cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner return false; 18874cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 18884cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (Offset == 0 && (Size == 0 || EltSize == Size)) 18894cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner return true; 18904cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Check if the component spans multiple elements. 18914cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (Offset + Size > EltSize) 18924cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner return false; 18934cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner return TypeHasComponent(EltTy, Offset, Size); 18944cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner} 18953cb3650a278e37aa6378127c51e407d2823139b4Duncan Sands 18964cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// RewriteForScalarRepl - Alloca AI is being split into NewElts, so rewrite 18974cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// the instruction I, which references it, to use the separate elements. 18984cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// Offset indicates the position within AI that is referenced by this 18994cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// instruction. 19004cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattnervoid SROA::RewriteForScalarRepl(Instruction *I, AllocaInst *AI, uint64_t Offset, 19014cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner SmallVector<AllocaInst*, 32> &NewElts) { 1902145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner for (Value::use_iterator UI = I->use_begin(), E = I->use_end(); UI!=E;) { 1903145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner Use &TheUse = UI.getUse(); 1904145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner Instruction *User = cast<Instruction>(*UI++); 19053cb3650a278e37aa6378127c51e407d2823139b4Duncan Sands 19064cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (BitCastInst *BC = dyn_cast<BitCastInst>(User)) { 19074cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner RewriteBitCast(BC, AI, Offset, NewElts); 1908145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner continue; 1909145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner } 1910145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner 1911145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner if (GetElementPtrInst *GEPI = dyn_cast<GetElementPtrInst>(User)) { 19124cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner RewriteGEP(GEPI, AI, Offset, NewElts); 1913145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner continue; 1914145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner } 1915145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner 1916145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner if (MemIntrinsic *MI = dyn_cast<MemIntrinsic>(User)) { 19174cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner ConstantInt *Length = dyn_cast<ConstantInt>(MI->getLength()); 19184cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner uint64_t MemSize = Length->getZExtValue(); 19194cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (Offset == 0 && 19204cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner MemSize == TD->getTypeAllocSize(AI->getAllocatedType())) 19214cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner RewriteMemIntrinUserOfAlloca(MI, I, AI, NewElts); 19224cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Otherwise the intrinsic can only touch a single element and the 19234cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // address operand will be updated, so nothing else needs to be done. 1924145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner continue; 1925145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner } 1926145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner 1927145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner if (LoadInst *LI = dyn_cast<LoadInst>(User)) { 1928db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *LIType = LI->getType(); 1929192228edb1c08ca11da2df959072bcaa99eacd63Chris Lattner 1930704d1347c5009f674408fae6f78343b415891274Bob Wilson if (isCompatibleAggregate(LIType, AI->getAllocatedType())) { 19314cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Replace: 19324cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // %res = load { i32, i32 }* %alloc 19334cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // with: 19344cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // %load.0 = load i32* %alloc.0 19354cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // %insert.0 insertvalue { i32, i32 } zeroinitializer, i32 %load.0, 0 19364cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // %load.1 = load i32* %alloc.1 19374cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // %insert = insertvalue { i32, i32 } %insert.0, i32 %load.1, 1 19384cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // (Also works for arrays instead of structs) 19394cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Value *Insert = UndefValue::get(LIType); 1940abb25122050349ccf77f8afb198a985e7a4d95eeDevang Patel IRBuilder<> Builder(LI); 19414cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner for (unsigned i = 0, e = NewElts.size(); i != e; ++i) { 1942abb25122050349ccf77f8afb198a985e7a4d95eeDevang Patel Value *Load = Builder.CreateLoad(NewElts[i], "load"); 1943abb25122050349ccf77f8afb198a985e7a4d95eeDevang Patel Insert = Builder.CreateInsertValue(Insert, Load, i, "insert"); 19444cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 19454cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner LI->replaceAllUsesWith(Insert); 19464cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner DeadInsts.push_back(LI); 19474cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } else if (LIType->isIntegerTy() && 19484cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner TD->getTypeAllocSize(LIType) == 19494cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner TD->getTypeAllocSize(AI->getAllocatedType())) { 19504cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // If this is a load of the entire alloca to an integer, rewrite it. 19514cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner RewriteLoadUserOfWholeAlloca(LI, AI, NewElts); 19524cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 1953145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner continue; 1954145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner } 1955145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner 1956145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner if (StoreInst *SI = dyn_cast<StoreInst>(User)) { 19574cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Value *Val = SI->getOperand(0); 1958db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *SIType = Val->getType(); 1959704d1347c5009f674408fae6f78343b415891274Bob Wilson if (isCompatibleAggregate(SIType, AI->getAllocatedType())) { 19604cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Replace: 19614cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // store { i32, i32 } %val, { i32, i32 }* %alloc 19624cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // with: 19634cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // %val.0 = extractvalue { i32, i32 } %val, 0 19644cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // store i32 %val.0, i32* %alloc.0 19654cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // %val.1 = extractvalue { i32, i32 } %val, 1 19664cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // store i32 %val.1, i32* %alloc.1 19674cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // (Also works for arrays instead of structs) 1968abb25122050349ccf77f8afb198a985e7a4d95eeDevang Patel IRBuilder<> Builder(SI); 19694cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner for (unsigned i = 0, e = NewElts.size(); i != e; ++i) { 1970abb25122050349ccf77f8afb198a985e7a4d95eeDevang Patel Value *Extract = Builder.CreateExtractValue(Val, i, Val->getName()); 1971abb25122050349ccf77f8afb198a985e7a4d95eeDevang Patel Builder.CreateStore(Extract, NewElts[i]); 19724cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 19734cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner DeadInsts.push_back(SI); 19744cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } else if (SIType->isIntegerTy() && 19754cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner TD->getTypeAllocSize(SIType) == 19764cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner TD->getTypeAllocSize(AI->getAllocatedType())) { 19774cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // If this is a store of the entire alloca from an integer, rewrite it. 19784cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner RewriteStoreUserOfWholeAlloca(SI, AI, NewElts); 197939a1c04323a5993d6b2993e615ec44c16e19aeeaChris Lattner } 1980145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner continue; 1981145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner } 1982145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner 1983145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner if (isa<SelectInst>(User) || isa<PHINode>(User)) { 1984145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner // If we have a PHI user of the alloca itself (as opposed to a GEP or 1985145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner // bitcast) we have to rewrite it. GEP and bitcast uses will be RAUW'd to 1986145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner // the new pointer. 1987145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner if (!isa<AllocaInst>(I)) continue; 1988145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner 1989145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner assert(Offset == 0 && NewElts[0] && 1990145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner "Direct alloca use should have a zero offset"); 1991145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner 1992145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner // If we have a use of the alloca, we know the derived uses will be 1993145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner // utilizing just the first element of the scalarized result. Insert a 1994145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner // bitcast of the first alloca before the user as required. 1995145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner AllocaInst *NewAI = NewElts[0]; 1996145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner BitCastInst *BCI = new BitCastInst(NewAI, AI->getType(), "", NewAI); 1997145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner NewAI->moveBefore(BCI); 1998145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner TheUse = BCI; 1999145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner continue; 200039a1c04323a5993d6b2993e615ec44c16e19aeeaChris Lattner } 20014cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 20024cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner} 20033cb3650a278e37aa6378127c51e407d2823139b4Duncan Sands 20044cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// RewriteBitCast - Update a bitcast reference to the alloca being replaced 20054cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// and recursively continue updating all of its uses. 20064cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattnervoid SROA::RewriteBitCast(BitCastInst *BC, AllocaInst *AI, uint64_t Offset, 20074cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner SmallVector<AllocaInst*, 32> &NewElts) { 20084cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner RewriteForScalarRepl(BC, AI, Offset, NewElts); 20094cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (BC->getOperand(0) != AI) 20104cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner return; 201139a1c04323a5993d6b2993e615ec44c16e19aeeaChris Lattner 20124cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // The bitcast references the original alloca. Replace its uses with 20134cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // references to the first new element alloca. 20144cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Instruction *Val = NewElts[0]; 20154cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (Val->getType() != BC->getDestTy()) { 20164cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Val = new BitCastInst(Val, BC->getDestTy(), "", BC); 20174cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Val->takeName(BC); 201839a1c04323a5993d6b2993e615ec44c16e19aeeaChris Lattner } 20194cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner BC->replaceAllUsesWith(Val); 20204cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner DeadInsts.push_back(BC); 202139a1c04323a5993d6b2993e615ec44c16e19aeeaChris Lattner} 2022372dda8881c7a32a6f5ce0f76a713e3a9ef46ea1Chris Lattner 20234cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// FindElementAndOffset - Return the index of the element containing Offset 20244cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// within the specified type, which must be either a struct or an array. 20254cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// Sets T to the type of the element and Offset to the offset within that 20264cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// element. IdxTy is set to the type of the index result to be used in a 20274cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// GEP instruction. 2028db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattneruint64_t SROA::FindElementAndOffset(Type *&T, uint64_t &Offset, 2029db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *&IdxTy) { 20304cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner uint64_t Idx = 0; 2031db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner if (StructType *ST = dyn_cast<StructType>(T)) { 20324cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner const StructLayout *Layout = TD->getStructLayout(ST); 20334cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Idx = Layout->getElementContainingOffset(Offset); 20344cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner T = ST->getContainedType(Idx); 20354cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Offset -= Layout->getElementOffset(Idx); 20364cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner IdxTy = Type::getInt32Ty(T->getContext()); 20374cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner return Idx; 2038f5990edc877c4e63503c589928a00ec6ec751830Chris Lattner } 2039db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner ArrayType *AT = cast<ArrayType>(T); 20404cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner T = AT->getElementType(); 20414cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner uint64_t EltSize = TD->getTypeAllocSize(T); 20424cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Idx = Offset / EltSize; 20434cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Offset -= Idx * EltSize; 20444cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner IdxTy = Type::getInt64Ty(T->getContext()); 20454cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner return Idx; 20465e062a1eda2c4adffd428a35e737a431fc37f4e0Chris Lattner} 2047a188894d67a3cc2516b25aae9b3cbdbff4b0babeChris Lattner 20484cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// RewriteGEP - Check if this GEP instruction moves the pointer across 20494cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// elements of the alloca that are being split apart, and if so, rewrite 20504cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// the GEP to be relative to the new element. 20514cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattnervoid SROA::RewriteGEP(GetElementPtrInst *GEPI, AllocaInst *AI, uint64_t Offset, 20524cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner SmallVector<AllocaInst*, 32> &NewElts) { 20534cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner uint64_t OldOffset = Offset; 20544cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner SmallVector<Value*, 8> Indices(GEPI->op_begin() + 1, GEPI->op_end()); 20558fbbb3980755d74539a0aed02bc18842ed2bd18dJay Foad Offset += TD->getIndexedOffset(GEPI->getPointerOperandType(), Indices); 20564cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner 20574cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner RewriteForScalarRepl(GEPI, AI, Offset, NewElts); 20584cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner 2059db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *T = AI->getAllocatedType(); 2060db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *IdxTy; 20614cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner uint64_t OldIdx = FindElementAndOffset(T, OldOffset, IdxTy); 20624cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (GEPI->getOperand(0) == AI) 20634cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner OldIdx = ~0ULL; // Force the GEP to be rewritten. 20644cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner 20654cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner T = AI->getAllocatedType(); 20664cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner uint64_t EltOffset = Offset; 20674cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner uint64_t Idx = FindElementAndOffset(T, EltOffset, IdxTy); 20684cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner 20694cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // If this GEP does not move the pointer across elements of the alloca 20704cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // being split, then it does not needs to be rewritten. 20714cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (Idx == OldIdx) 2072c4472072641f702dbd99ae12b7da089e75c44a99Chris Lattner return; 2073c4472072641f702dbd99ae12b7da089e75c44a99Chris Lattner 2074db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *i32Ty = Type::getInt32Ty(AI->getContext()); 20754cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner SmallVector<Value*, 8> NewArgs; 20764cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner NewArgs.push_back(Constant::getNullValue(i32Ty)); 20774cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner while (EltOffset != 0) { 20784cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner uint64_t EltIdx = FindElementAndOffset(T, EltOffset, IdxTy); 20794cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner NewArgs.push_back(ConstantInt::get(IdxTy, EltIdx)); 20802e0d5f84325303fa95997cd66485811bd0a6ef70Chris Lattner } 20814cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Instruction *Val = NewElts[Idx]; 20824cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (NewArgs.size() > 1) { 20834cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Val = GetElementPtrInst::CreateInBounds(Val, NewArgs.begin(), 20844cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner NewArgs.end(), "", GEPI); 20854cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Val->takeName(GEPI); 20864cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 20874cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (Val->getType() != GEPI->getType()) 20884cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Val = new BitCastInst(Val, GEPI->getType(), Val->getName(), GEPI); 20894cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner GEPI->replaceAllUsesWith(Val); 20904cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner DeadInsts.push_back(GEPI); 2091a188894d67a3cc2516b25aae9b3cbdbff4b0babeChris Lattner} 2092a188894d67a3cc2516b25aae9b3cbdbff4b0babeChris Lattner 20934cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// RewriteMemIntrinUserOfAlloca - MI is a memcpy/memset/memmove from or to AI. 20944cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// Rewrite it to copy or set the elements of the scalarized memory. 20954cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattnervoid SROA::RewriteMemIntrinUserOfAlloca(MemIntrinsic *MI, Instruction *Inst, 20964cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner AllocaInst *AI, 20974cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner SmallVector<AllocaInst*, 32> &NewElts) { 20984cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // If this is a memcpy/memmove, construct the other pointer as the 20994cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // appropriate type. The "Other" pointer is the pointer that goes to memory 21004cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // that doesn't have anything to do with the alloca that we are promoting. For 21014cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // memset, this Value* stays null. 21024cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Value *OtherPtr = 0; 21034cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner unsigned MemAlignment = MI->getAlignment(); 21044cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (MemTransferInst *MTI = dyn_cast<MemTransferInst>(MI)) { // memmove/memcopy 21054cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (Inst == MTI->getRawDest()) 21064cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner OtherPtr = MTI->getRawSource(); 21074cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner else { 21084cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner assert(Inst == MTI->getRawSource()); 21094cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner OtherPtr = MTI->getRawDest(); 2110a188894d67a3cc2516b25aae9b3cbdbff4b0babeChris Lattner } 21114cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 21123ce5e887aef457701da95f1c6ccbd58ec3d32fe4Chris Lattner 21134cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // If there is an other pointer, we want to convert it to the same pointer 21144cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // type as AI has, so we can GEP through it safely. 21154cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (OtherPtr) { 21160238f8c430050d23ef861169bb4c4f930af0ef97Chris Lattner unsigned AddrSpace = 21170238f8c430050d23ef861169bb4c4f930af0ef97Chris Lattner cast<PointerType>(OtherPtr->getType())->getAddressSpace(); 21184cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner 21194cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Remove bitcasts and all-zero GEPs from OtherPtr. This is an 21204cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // optimization, but it's also required to detect the corner case where 21214cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // both pointer operands are referencing the same memory, and where 21224cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // OtherPtr may be a bitcast or GEP that currently being rewritten. (This 21234cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // function is only called for mem intrinsics that access the whole 21244cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // aggregate, so non-zero GEPs are not an issue here.) 21250238f8c430050d23ef861169bb4c4f930af0ef97Chris Lattner OtherPtr = OtherPtr->stripPointerCasts(); 21266974302e3ff20746268721959efed807c7711bfcBob Wilson 21274cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Copying the alloca to itself is a no-op: just delete it. 21284cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (OtherPtr == AI || OtherPtr == NewElts[0]) { 21294cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // This code will run twice for a no-op memcpy -- once for each operand. 21304cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Put only one reference to MI on the DeadInsts list. 21314cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner for (SmallVector<Value*, 32>::const_iterator I = DeadInsts.begin(), 21324cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner E = DeadInsts.end(); I != E; ++I) 21334cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (*I == MI) return; 21344cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner DeadInsts.push_back(MI); 21354cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner return; 2136c570487d45f7426dc5f75c0309122d6f9330ecf7Chris Lattner } 21376974302e3ff20746268721959efed807c7711bfcBob Wilson 21384cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // If the pointer is not the right type, insert a bitcast to the right 21394cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // type. 2140db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *NewTy = 21410238f8c430050d23ef861169bb4c4f930af0ef97Chris Lattner PointerType::get(AI->getType()->getElementType(), AddrSpace); 21426974302e3ff20746268721959efed807c7711bfcBob Wilson 21430238f8c430050d23ef861169bb4c4f930af0ef97Chris Lattner if (OtherPtr->getType() != NewTy) 21440238f8c430050d23ef861169bb4c4f930af0ef97Chris Lattner OtherPtr = new BitCastInst(OtherPtr, NewTy, OtherPtr->getName(), MI); 2145a188894d67a3cc2516b25aae9b3cbdbff4b0babeChris Lattner } 21466974302e3ff20746268721959efed807c7711bfcBob Wilson 21474cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Process each element of the aggregate. 21484cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner bool SROADest = MI->getRawDest() == Inst; 21496974302e3ff20746268721959efed807c7711bfcBob Wilson 21504cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Constant *Zero = Constant::getNullValue(Type::getInt32Ty(MI->getContext())); 21514b3dfbd220835cbba519162712c9cb6afaa44059Duncan Sands 21524cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner for (unsigned i = 0, e = NewElts.size(); i != e; ++i) { 21534cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // If this is a memcpy/memmove, emit a GEP of the other element address. 21544cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Value *OtherElt = 0; 21554cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner unsigned OtherEltAlign = MemAlignment; 21566974302e3ff20746268721959efed807c7711bfcBob Wilson 21574cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (OtherPtr) { 21584cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Value *Idx[2] = { Zero, 21594cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner ConstantInt::get(Type::getInt32Ty(MI->getContext()), i) }; 21604cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner OtherElt = GetElementPtrInst::CreateInBounds(OtherPtr, Idx, Idx + 2, 21614cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner OtherPtr->getName()+"."+Twine(i), 21624cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner MI); 21634cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner uint64_t EltOffset; 2164db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner PointerType *OtherPtrTy = cast<PointerType>(OtherPtr->getType()); 2165db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *OtherTy = OtherPtrTy->getElementType(); 2166db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner if (StructType *ST = dyn_cast<StructType>(OtherTy)) { 21674cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner EltOffset = TD->getStructLayout(ST)->getElementOffset(i); 21684cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } else { 2169db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *EltTy = cast<SequentialType>(OtherTy)->getElementType(); 21704cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner EltOffset = TD->getTypeAllocSize(EltTy)*i; 21714cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 21726974302e3ff20746268721959efed807c7711bfcBob Wilson 21734cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // The alignment of the other pointer is the guaranteed alignment of the 21744cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // element, which is affected by both the known alignment of the whole 21754cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // mem intrinsic and the alignment of the element. If the alignment of 21764cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // the memcpy (f.e.) is 32 but the element is at a 4-byte offset, then the 21774cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // known alignment is just 4 bytes. 21784cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner OtherEltAlign = (unsigned)MinAlign(OtherEltAlign, EltOffset); 21799bc67da0a9982f2f7597d1d46cf18f079e4f8f98Chris Lattner } 21806974302e3ff20746268721959efed807c7711bfcBob Wilson 21814cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Value *EltPtr = NewElts[i]; 2182db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *EltTy = cast<PointerType>(EltPtr->getType())->getElementType(); 21836974302e3ff20746268721959efed807c7711bfcBob Wilson 21844cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // If we got down to a scalar, insert a load or store as appropriate. 21854cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (EltTy->isSingleValueType()) { 21864cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (isa<MemTransferInst>(MI)) { 21874cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (SROADest) { 21884cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // From Other to Alloca. 21894cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Value *Elt = new LoadInst(OtherElt, "tmp", false, OtherEltAlign, MI); 21904cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner new StoreInst(Elt, EltPtr, MI); 21914cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } else { 21924cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // From Alloca to Other. 21934cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Value *Elt = new LoadInst(EltPtr, "tmp", MI); 21944cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner new StoreInst(Elt, OtherElt, false, OtherEltAlign, MI); 21954cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 21964cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner continue; 219733e24adc3bc3d046aa05cf903fb74da1610b57cbChris Lattner } 21984cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner assert(isa<MemSetInst>(MI)); 21996974302e3ff20746268721959efed807c7711bfcBob Wilson 22004cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // If the stored element is zero (common case), just store a null 22014cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // constant. 22024cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Constant *StoreVal; 22036f14c8c7c1ec97797a04631abad6885bfaabcc6dGabor Greif if (ConstantInt *CI = dyn_cast<ConstantInt>(MI->getArgOperand(1))) { 22044cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (CI->isZero()) { 22054cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner StoreVal = Constant::getNullValue(EltTy); // 0.0, null, 0, <0,0> 22064cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } else { 22074cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // If EltTy is a vector type, get the element type. 2208db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *ValTy = EltTy->getScalarType(); 2209c570487d45f7426dc5f75c0309122d6f9330ecf7Chris Lattner 22104cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Construct an integer with the right value. 22114cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner unsigned EltSize = TD->getTypeSizeInBits(ValTy); 22124cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner APInt OneVal(EltSize, CI->getZExtValue()); 22134cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner APInt TotalVal(OneVal); 22144cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Set each byte. 22154cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner for (unsigned i = 0; 8*i < EltSize; ++i) { 22164cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner TotalVal = TotalVal.shl(8); 22174cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner TotalVal |= OneVal; 22184cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 22196974302e3ff20746268721959efed807c7711bfcBob Wilson 22204cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Convert the integer value to the appropriate type. 2221d55c1c16598eba6111fb3a5b6e5dbc6469a562f7Chris Lattner StoreVal = ConstantInt::get(CI->getContext(), TotalVal); 22224cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (ValTy->isPointerTy()) 22234cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner StoreVal = ConstantExpr::getIntToPtr(StoreVal, ValTy); 22244cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner else if (ValTy->isFloatingPointTy()) 22254cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner StoreVal = ConstantExpr::getBitCast(StoreVal, ValTy); 22264cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner assert(StoreVal->getType() == ValTy && "Type mismatch!"); 22276974302e3ff20746268721959efed807c7711bfcBob Wilson 22284cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // If the requested value was a vector constant, create it. 22294cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (EltTy != ValTy) { 22304cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner unsigned NumElts = cast<VectorType>(ValTy)->getNumElements(); 22314cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner SmallVector<Constant*, 16> Elts(NumElts, StoreVal); 22322ca5c8644e6c35b3a7910a576ed89cddb7b82c3bChris Lattner StoreVal = ConstantVector::get(Elts); 22334cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 22344cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 22354cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner new StoreInst(StoreVal, EltPtr, MI); 22364cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner continue; 22374cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 22384cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Otherwise, if we're storing a byte variable, use a memset call for 22394cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // this element. 22404cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 22416974302e3ff20746268721959efed807c7711bfcBob Wilson 22424cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner unsigned EltSize = TD->getTypeAllocSize(EltTy); 22436974302e3ff20746268721959efed807c7711bfcBob Wilson 224461db1f56d0b717d67557bbb2a9d83af1449458cbChris Lattner IRBuilder<> Builder(MI); 22456974302e3ff20746268721959efed807c7711bfcBob Wilson 22464cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Finally, insert the meminst for this element. 224761db1f56d0b717d67557bbb2a9d83af1449458cbChris Lattner if (isa<MemSetInst>(MI)) { 224861db1f56d0b717d67557bbb2a9d83af1449458cbChris Lattner Builder.CreateMemSet(EltPtr, MI->getArgOperand(1), EltSize, 224961db1f56d0b717d67557bbb2a9d83af1449458cbChris Lattner MI->isVolatile()); 22504cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } else { 225161db1f56d0b717d67557bbb2a9d83af1449458cbChris Lattner assert(isa<MemTransferInst>(MI)); 225261db1f56d0b717d67557bbb2a9d83af1449458cbChris Lattner Value *Dst = SROADest ? EltPtr : OtherElt; // Dest ptr 225361db1f56d0b717d67557bbb2a9d83af1449458cbChris Lattner Value *Src = SROADest ? OtherElt : EltPtr; // Src ptr 22546974302e3ff20746268721959efed807c7711bfcBob Wilson 225561db1f56d0b717d67557bbb2a9d83af1449458cbChris Lattner if (isa<MemCpyInst>(MI)) 225661db1f56d0b717d67557bbb2a9d83af1449458cbChris Lattner Builder.CreateMemCpy(Dst, Src, EltSize, OtherEltAlign,MI->isVolatile()); 225761db1f56d0b717d67557bbb2a9d83af1449458cbChris Lattner else 225861db1f56d0b717d67557bbb2a9d83af1449458cbChris Lattner Builder.CreateMemMove(Dst, Src, EltSize,OtherEltAlign,MI->isVolatile()); 22594cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 2260a188894d67a3cc2516b25aae9b3cbdbff4b0babeChris Lattner } 22614cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner DeadInsts.push_back(MI); 2262a188894d67a3cc2516b25aae9b3cbdbff4b0babeChris Lattner} 226379b3bd395dc3303cde65e18e0524ed2f70268c99Chris Lattner 22644cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// RewriteStoreUserOfWholeAlloca - We found a store of an integer that 22654cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// overwrites the entire allocation. Extract out the pieces of the stored 22664cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// integer and store them individually. 22674cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattnervoid SROA::RewriteStoreUserOfWholeAlloca(StoreInst *SI, AllocaInst *AI, 22684cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner SmallVector<AllocaInst*, 32> &NewElts){ 22694cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Extract each element out of the integer according to its structure offset 22704cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // and store the element value to the individual alloca. 22714cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Value *SrcVal = SI->getOperand(0); 2272db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *AllocaEltTy = AI->getAllocatedType(); 22734cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner uint64_t AllocaSizeBits = TD->getTypeAllocSizeInBits(AllocaEltTy); 22746974302e3ff20746268721959efed807c7711bfcBob Wilson 227570728532799d751b8e0e97719dcb3344a2fc97deChris Lattner IRBuilder<> Builder(SI); 227670728532799d751b8e0e97719dcb3344a2fc97deChris Lattner 22774cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Handle tail padding by extending the operand 22784cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (TD->getTypeSizeInBits(SrcVal->getType()) != AllocaSizeBits) 227970728532799d751b8e0e97719dcb3344a2fc97deChris Lattner SrcVal = Builder.CreateZExt(SrcVal, 228070728532799d751b8e0e97719dcb3344a2fc97deChris Lattner IntegerType::get(SI->getContext(), AllocaSizeBits)); 22814b3dfbd220835cbba519162712c9cb6afaa44059Duncan Sands 22824cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner DEBUG(dbgs() << "PROMOTING STORE TO WHOLE ALLOCA: " << *AI << '\n' << *SI 22834cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner << '\n'); 22844b3dfbd220835cbba519162712c9cb6afaa44059Duncan Sands 22854cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // There are two forms here: AI could be an array or struct. Both cases 22864cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // have different ways to compute the element offset. 2287db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner if (StructType *EltSTy = dyn_cast<StructType>(AllocaEltTy)) { 22884cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner const StructLayout *Layout = TD->getStructLayout(EltSTy); 22896974302e3ff20746268721959efed807c7711bfcBob Wilson 22904cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner for (unsigned i = 0, e = NewElts.size(); i != e; ++i) { 22914cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Get the number of bits to shift SrcVal to get the value. 2292db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *FieldTy = EltSTy->getElementType(i); 22934cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner uint64_t Shift = Layout->getElementOffsetInBits(i); 22946974302e3ff20746268721959efed807c7711bfcBob Wilson 22954cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (TD->isBigEndian()) 22964cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Shift = AllocaSizeBits-Shift-TD->getTypeAllocSizeInBits(FieldTy); 22976974302e3ff20746268721959efed807c7711bfcBob Wilson 22984cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Value *EltVal = SrcVal; 22994cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (Shift) { 23004cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Value *ShiftVal = ConstantInt::get(EltVal->getType(), Shift); 230170728532799d751b8e0e97719dcb3344a2fc97deChris Lattner EltVal = Builder.CreateLShr(EltVal, ShiftVal, "sroa.store.elt"); 23024cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 23036974302e3ff20746268721959efed807c7711bfcBob Wilson 23044cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Truncate down to an integer of the right size. 23054cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner uint64_t FieldSizeBits = TD->getTypeSizeInBits(FieldTy); 23066974302e3ff20746268721959efed807c7711bfcBob Wilson 23074cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Ignore zero sized fields like {}, they obviously contain no data. 23084cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (FieldSizeBits == 0) continue; 23096974302e3ff20746268721959efed807c7711bfcBob Wilson 23104cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (FieldSizeBits != AllocaSizeBits) 231170728532799d751b8e0e97719dcb3344a2fc97deChris Lattner EltVal = Builder.CreateTrunc(EltVal, 231270728532799d751b8e0e97719dcb3344a2fc97deChris Lattner IntegerType::get(SI->getContext(), FieldSizeBits)); 23134cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Value *DestField = NewElts[i]; 23144cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (EltVal->getType() == FieldTy) { 23154cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Storing to an integer field of this size, just do it. 23164cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } else if (FieldTy->isFloatingPointTy() || FieldTy->isVectorTy()) { 23174cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Bitcast to the right element type (for fp/vector values). 231870728532799d751b8e0e97719dcb3344a2fc97deChris Lattner EltVal = Builder.CreateBitCast(EltVal, FieldTy); 23194cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } else { 23204cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Otherwise, bitcast the dest pointer (for aggregates). 232170728532799d751b8e0e97719dcb3344a2fc97deChris Lattner DestField = Builder.CreateBitCast(DestField, 232270728532799d751b8e0e97719dcb3344a2fc97deChris Lattner PointerType::getUnqual(EltVal->getType())); 23234cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 23244cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner new StoreInst(EltVal, DestField, SI); 23254cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 23266974302e3ff20746268721959efed807c7711bfcBob Wilson 23279d34c4d678cfc836a59a114b7b2cf91e9dd5eac4Chris Lattner } else { 2328db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner ArrayType *ATy = cast<ArrayType>(AllocaEltTy); 2329db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *ArrayEltTy = ATy->getElementType(); 23304cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner uint64_t ElementOffset = TD->getTypeAllocSizeInBits(ArrayEltTy); 23314cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner uint64_t ElementSizeBits = TD->getTypeSizeInBits(ArrayEltTy); 23324b3dfbd220835cbba519162712c9cb6afaa44059Duncan Sands 23334cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner uint64_t Shift; 23346974302e3ff20746268721959efed807c7711bfcBob Wilson 23354cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (TD->isBigEndian()) 23364cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Shift = AllocaSizeBits-ElementOffset; 23376974302e3ff20746268721959efed807c7711bfcBob Wilson else 23384cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Shift = 0; 23396974302e3ff20746268721959efed807c7711bfcBob Wilson 23404cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner for (unsigned i = 0, e = NewElts.size(); i != e; ++i) { 23414cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Ignore zero sized fields like {}, they obviously contain no data. 23424cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (ElementSizeBits == 0) continue; 23436974302e3ff20746268721959efed807c7711bfcBob Wilson 23444cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Value *EltVal = SrcVal; 23454cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (Shift) { 23464cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Value *ShiftVal = ConstantInt::get(EltVal->getType(), Shift); 234770728532799d751b8e0e97719dcb3344a2fc97deChris Lattner EltVal = Builder.CreateLShr(EltVal, ShiftVal, "sroa.store.elt"); 23484cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 23496974302e3ff20746268721959efed807c7711bfcBob Wilson 23504cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Truncate down to an integer of the right size. 23514cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (ElementSizeBits != AllocaSizeBits) 235270728532799d751b8e0e97719dcb3344a2fc97deChris Lattner EltVal = Builder.CreateTrunc(EltVal, 235370728532799d751b8e0e97719dcb3344a2fc97deChris Lattner IntegerType::get(SI->getContext(), 235470728532799d751b8e0e97719dcb3344a2fc97deChris Lattner ElementSizeBits)); 23554cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Value *DestField = NewElts[i]; 23564cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (EltVal->getType() == ArrayEltTy) { 23574cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Storing to an integer field of this size, just do it. 23584cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } else if (ArrayEltTy->isFloatingPointTy() || 23594cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner ArrayEltTy->isVectorTy()) { 23604cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Bitcast to the right element type (for fp/vector values). 236170728532799d751b8e0e97719dcb3344a2fc97deChris Lattner EltVal = Builder.CreateBitCast(EltVal, ArrayEltTy); 23624cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } else { 23634cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Otherwise, bitcast the dest pointer (for aggregates). 236470728532799d751b8e0e97719dcb3344a2fc97deChris Lattner DestField = Builder.CreateBitCast(DestField, 236570728532799d751b8e0e97719dcb3344a2fc97deChris Lattner PointerType::getUnqual(EltVal->getType())); 23664cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 23674cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner new StoreInst(EltVal, DestField, SI); 23686974302e3ff20746268721959efed807c7711bfcBob Wilson 23694cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (TD->isBigEndian()) 23704cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Shift -= ElementOffset; 23716974302e3ff20746268721959efed807c7711bfcBob Wilson else 23724cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Shift += ElementOffset; 23734cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 2374800de31776356910eb877e71df9f32b0a6215324Chris Lattner } 23756974302e3ff20746268721959efed807c7711bfcBob Wilson 23764cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner DeadInsts.push_back(SI); 2377800de31776356910eb877e71df9f32b0a6215324Chris Lattner} 2378800de31776356910eb877e71df9f32b0a6215324Chris Lattner 23794cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// RewriteLoadUserOfWholeAlloca - We found a load of the entire allocation to 23804cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// an integer. Load the individual pieces to form the aggregate value. 23814cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattnervoid SROA::RewriteLoadUserOfWholeAlloca(LoadInst *LI, AllocaInst *AI, 23824cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner SmallVector<AllocaInst*, 32> &NewElts) { 23834cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Extract each element out of the NewElts according to its structure offset 23844cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // and form the result value. 2385db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *AllocaEltTy = AI->getAllocatedType(); 23864cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner uint64_t AllocaSizeBits = TD->getTypeAllocSizeInBits(AllocaEltTy); 23876974302e3ff20746268721959efed807c7711bfcBob Wilson 23884cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner DEBUG(dbgs() << "PROMOTING LOAD OF WHOLE ALLOCA: " << *AI << '\n' << *LI 23894cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner << '\n'); 23906974302e3ff20746268721959efed807c7711bfcBob Wilson 23914cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // There are two forms here: AI could be an array or struct. Both cases 23924cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // have different ways to compute the element offset. 23934cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner const StructLayout *Layout = 0; 23944cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner uint64_t ArrayEltBitOffset = 0; 2395db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner if (StructType *EltSTy = dyn_cast<StructType>(AllocaEltTy)) { 23964cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Layout = TD->getStructLayout(EltSTy); 23974cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } else { 2398db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *ArrayEltTy = cast<ArrayType>(AllocaEltTy)->getElementType(); 23994cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner ArrayEltBitOffset = TD->getTypeAllocSizeInBits(ArrayEltTy); 24006974302e3ff20746268721959efed807c7711bfcBob Wilson } 24016974302e3ff20746268721959efed807c7711bfcBob Wilson 24026974302e3ff20746268721959efed807c7711bfcBob Wilson Value *ResultVal = 24034cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Constant::getNullValue(IntegerType::get(LI->getContext(), AllocaSizeBits)); 24046974302e3ff20746268721959efed807c7711bfcBob Wilson 24054cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner for (unsigned i = 0, e = NewElts.size(); i != e; ++i) { 24064cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Load the value from the alloca. If the NewElt is an aggregate, cast 24074cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // the pointer to an integer of the same size before doing the load. 24084cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Value *SrcField = NewElts[i]; 2409db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *FieldTy = 24104cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner cast<PointerType>(SrcField->getType())->getElementType(); 24114cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner uint64_t FieldSizeBits = TD->getTypeSizeInBits(FieldTy); 24126974302e3ff20746268721959efed807c7711bfcBob Wilson 24134cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Ignore zero sized fields like {}, they obviously contain no data. 24144cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (FieldSizeBits == 0) continue; 24156974302e3ff20746268721959efed807c7711bfcBob Wilson 2416db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner IntegerType *FieldIntTy = IntegerType::get(LI->getContext(), 24174cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner FieldSizeBits); 24184cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (!FieldTy->isIntegerTy() && !FieldTy->isFloatingPointTy() && 24194cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner !FieldTy->isVectorTy()) 24204cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner SrcField = new BitCastInst(SrcField, 24214cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner PointerType::getUnqual(FieldIntTy), 24224cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner "", LI); 24234cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner SrcField = new LoadInst(SrcField, "sroa.load.elt", LI); 242429e641761e81bd000bdc4ccfae479c6dda18e402Chris Lattner 24254cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // If SrcField is a fp or vector of the right size but that isn't an 24264cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // integer type, bitcast to an integer so we can shift it. 24274cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (SrcField->getType() != FieldIntTy) 24284cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner SrcField = new BitCastInst(SrcField, FieldIntTy, "", LI); 242929e641761e81bd000bdc4ccfae479c6dda18e402Chris Lattner 24304cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Zero extend the field to be the same size as the final alloca so that 24314cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // we can shift and insert it. 24324cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (SrcField->getType() != ResultVal->getType()) 24334cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner SrcField = new ZExtInst(SrcField, ResultVal->getType(), "", LI); 24346974302e3ff20746268721959efed807c7711bfcBob Wilson 24354cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Determine the number of bits to shift SrcField. 24364cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner uint64_t Shift; 24374cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (Layout) // Struct case. 24384cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Shift = Layout->getElementOffsetInBits(i); 24394cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner else // Array case. 24404cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Shift = i*ArrayEltBitOffset; 24416974302e3ff20746268721959efed807c7711bfcBob Wilson 24424cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (TD->isBigEndian()) 24434cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Shift = AllocaSizeBits-Shift-FieldIntTy->getBitWidth(); 24446974302e3ff20746268721959efed807c7711bfcBob Wilson 24454cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (Shift) { 24464cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Value *ShiftVal = ConstantInt::get(SrcField->getType(), Shift); 24474cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner SrcField = BinaryOperator::CreateShl(SrcField, ShiftVal, "", LI); 24489b872db775797dea4b391a9347cfbd2ca9c558e2Chris Lattner } 24494cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner 24501495247f517c0ac3aeeb9e6c7c0205dd7849d332Chris Lattner // Don't create an 'or x, 0' on the first iteration. 24511495247f517c0ac3aeeb9e6c7c0205dd7849d332Chris Lattner if (!isa<Constant>(ResultVal) || 24521495247f517c0ac3aeeb9e6c7c0205dd7849d332Chris Lattner !cast<Constant>(ResultVal)->isNullValue()) 24531495247f517c0ac3aeeb9e6c7c0205dd7849d332Chris Lattner ResultVal = BinaryOperator::CreateOr(SrcField, ResultVal, "", LI); 24541495247f517c0ac3aeeb9e6c7c0205dd7849d332Chris Lattner else 24551495247f517c0ac3aeeb9e6c7c0205dd7849d332Chris Lattner ResultVal = SrcField; 24569b872db775797dea4b391a9347cfbd2ca9c558e2Chris Lattner } 24574b3dfbd220835cbba519162712c9cb6afaa44059Duncan Sands 24584cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Handle tail padding by truncating the result 24594cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (TD->getTypeSizeInBits(LI->getType()) != AllocaSizeBits) 24604cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner ResultVal = new TruncInst(ResultVal, LI->getType(), "", LI); 24614b3dfbd220835cbba519162712c9cb6afaa44059Duncan Sands 24624cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner LI->replaceAllUsesWith(ResultVal); 24634cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner DeadInsts.push_back(LI); 24644cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner} 24654cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner 24664cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// HasPadding - Return true if the specified type has any structure or 2467694a10e7d8410f24639971224ce0e282c8cd04cbBob Wilson/// alignment padding in between the elements that would be split apart 2468694a10e7d8410f24639971224ce0e282c8cd04cbBob Wilson/// by SROA; return false otherwise. 2469db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattnerstatic bool HasPadding(Type *Ty, const TargetData &TD) { 2470db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner if (ArrayType *ATy = dyn_cast<ArrayType>(Ty)) { 2471694a10e7d8410f24639971224ce0e282c8cd04cbBob Wilson Ty = ATy->getElementType(); 2472694a10e7d8410f24639971224ce0e282c8cd04cbBob Wilson return TD.getTypeSizeInBits(Ty) != TD.getTypeAllocSizeInBits(Ty); 2473694a10e7d8410f24639971224ce0e282c8cd04cbBob Wilson } 24744cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner 2475694a10e7d8410f24639971224ce0e282c8cd04cbBob Wilson // SROA currently handles only Arrays and Structs. 2476db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner StructType *STy = cast<StructType>(Ty); 2477694a10e7d8410f24639971224ce0e282c8cd04cbBob Wilson const StructLayout *SL = TD.getStructLayout(STy); 2478694a10e7d8410f24639971224ce0e282c8cd04cbBob Wilson unsigned PrevFieldBitOffset = 0; 2479694a10e7d8410f24639971224ce0e282c8cd04cbBob Wilson for (unsigned i = 0, e = STy->getNumElements(); i != e; ++i) { 2480694a10e7d8410f24639971224ce0e282c8cd04cbBob Wilson unsigned FieldBitOffset = SL->getElementOffsetInBits(i); 2481694a10e7d8410f24639971224ce0e282c8cd04cbBob Wilson 2482694a10e7d8410f24639971224ce0e282c8cd04cbBob Wilson // Check to see if there is any padding between this element and the 2483694a10e7d8410f24639971224ce0e282c8cd04cbBob Wilson // previous one. 2484694a10e7d8410f24639971224ce0e282c8cd04cbBob Wilson if (i) { 2485694a10e7d8410f24639971224ce0e282c8cd04cbBob Wilson unsigned PrevFieldEnd = 24864cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner PrevFieldBitOffset+TD.getTypeSizeInBits(STy->getElementType(i-1)); 2487694a10e7d8410f24639971224ce0e282c8cd04cbBob Wilson if (PrevFieldEnd < FieldBitOffset) 24884cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner return true; 24894cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 2490694a10e7d8410f24639971224ce0e282c8cd04cbBob Wilson PrevFieldBitOffset = FieldBitOffset; 24912e0d5f84325303fa95997cd66485811bd0a6ef70Chris Lattner } 2492694a10e7d8410f24639971224ce0e282c8cd04cbBob Wilson // Check for tail padding. 2493694a10e7d8410f24639971224ce0e282c8cd04cbBob Wilson if (unsigned EltCount = STy->getNumElements()) { 2494694a10e7d8410f24639971224ce0e282c8cd04cbBob Wilson unsigned PrevFieldEnd = PrevFieldBitOffset + 2495694a10e7d8410f24639971224ce0e282c8cd04cbBob Wilson TD.getTypeSizeInBits(STy->getElementType(EltCount-1)); 2496694a10e7d8410f24639971224ce0e282c8cd04cbBob Wilson if (PrevFieldEnd < SL->getSizeInBits()) 2497694a10e7d8410f24639971224ce0e282c8cd04cbBob Wilson return true; 2498694a10e7d8410f24639971224ce0e282c8cd04cbBob Wilson } 2499694a10e7d8410f24639971224ce0e282c8cd04cbBob Wilson return false; 25004cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner} 25014b3dfbd220835cbba519162712c9cb6afaa44059Duncan Sands 25024cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// isSafeStructAllocaToScalarRepl - Check to see if the specified allocation of 25034cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// an aggregate can be broken down into elements. Return 0 if not, 3 if safe, 25044cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// or 1 if safe after canonicalization has been performed. 25054cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattnerbool SROA::isSafeAllocaToScalarRepl(AllocaInst *AI) { 25064cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Loop over the use list of the alloca. We can only transform it if all of 25074cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // the users are safe to transform. 25086c95d24927b11fb76bc3e76ebe6a8198d74fc178Chris Lattner AllocaInfo Info(AI); 25096974302e3ff20746268721959efed807c7711bfcBob Wilson 25106c95d24927b11fb76bc3e76ebe6a8198d74fc178Chris Lattner isSafeForScalarRepl(AI, 0, Info); 25114cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (Info.isUnsafe) { 25124cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner DEBUG(dbgs() << "Cannot transform: " << *AI << '\n'); 25134cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner return false; 2514800de31776356910eb877e71df9f32b0a6215324Chris Lattner } 25156974302e3ff20746268721959efed807c7711bfcBob Wilson 25164cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Okay, we know all the users are promotable. If the aggregate is a memcpy 25174cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // source and destination, we have to be careful. In particular, the memcpy 25184cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // could be moving around elements that live in structure padding of the LLVM 25194cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // types, but may actually be used. In these cases, we refuse to promote the 25204cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // struct. 25214cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (Info.isMemCpySrc && Info.isMemCpyDst && 25224cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner HasPadding(AI->getAllocatedType(), *TD)) 25234cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner return false; 25244cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner 2525396a0567cf959d86a8a1ad185e54d84f5dacbacfChris Lattner // If the alloca never has an access to just *part* of it, but is accessed 2526396a0567cf959d86a8a1ad185e54d84f5dacbacfChris Lattner // via loads and stores, then we should use ConvertToScalarInfo to promote 25277e9b427c879ae32b72fd24aeaf011e87e5692fd7Chris Lattner // the alloca instead of promoting each piece at a time and inserting fission 25287e9b427c879ae32b72fd24aeaf011e87e5692fd7Chris Lattner // and fusion code. 25297e9b427c879ae32b72fd24aeaf011e87e5692fd7Chris Lattner if (!Info.hasSubelementAccess && Info.hasALoadOrStore) { 25307e9b427c879ae32b72fd24aeaf011e87e5692fd7Chris Lattner // If the struct/array just has one element, use basic SRoA. 2531db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner if (StructType *ST = dyn_cast<StructType>(AI->getAllocatedType())) { 25327e9b427c879ae32b72fd24aeaf011e87e5692fd7Chris Lattner if (ST->getNumElements() > 1) return false; 25337e9b427c879ae32b72fd24aeaf011e87e5692fd7Chris Lattner } else { 25347e9b427c879ae32b72fd24aeaf011e87e5692fd7Chris Lattner if (cast<ArrayType>(AI->getAllocatedType())->getNumElements() > 1) 25357e9b427c879ae32b72fd24aeaf011e87e5692fd7Chris Lattner return false; 25367e9b427c879ae32b72fd24aeaf011e87e5692fd7Chris Lattner } 25377e9b427c879ae32b72fd24aeaf011e87e5692fd7Chris Lattner } 2538145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner 25394cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner return true; 2540800de31776356910eb877e71df9f32b0a6215324Chris Lattner} 2541800de31776356910eb877e71df9f32b0a6215324Chris Lattner 2542800de31776356910eb877e71df9f32b0a6215324Chris Lattner 254379b3bd395dc3303cde65e18e0524ed2f70268c99Chris Lattner 254479b3bd395dc3303cde65e18e0524ed2f70268c99Chris Lattner/// PointsToConstantGlobal - Return true if V (possibly indirectly) points to 254579b3bd395dc3303cde65e18e0524ed2f70268c99Chris Lattner/// some part of a constant global variable. This intentionally only accepts 254679b3bd395dc3303cde65e18e0524ed2f70268c99Chris Lattner/// constant expressions because we don't can't rewrite arbitrary instructions. 254779b3bd395dc3303cde65e18e0524ed2f70268c99Chris Lattnerstatic bool PointsToConstantGlobal(Value *V) { 254879b3bd395dc3303cde65e18e0524ed2f70268c99Chris Lattner if (GlobalVariable *GV = dyn_cast<GlobalVariable>(V)) 254979b3bd395dc3303cde65e18e0524ed2f70268c99Chris Lattner return GV->isConstant(); 255079b3bd395dc3303cde65e18e0524ed2f70268c99Chris Lattner if (ConstantExpr *CE = dyn_cast<ConstantExpr>(V)) 25516974302e3ff20746268721959efed807c7711bfcBob Wilson if (CE->getOpcode() == Instruction::BitCast || 255279b3bd395dc3303cde65e18e0524ed2f70268c99Chris Lattner CE->getOpcode() == Instruction::GetElementPtr) 255379b3bd395dc3303cde65e18e0524ed2f70268c99Chris Lattner return PointsToConstantGlobal(CE->getOperand(0)); 255479b3bd395dc3303cde65e18e0524ed2f70268c99Chris Lattner return false; 255579b3bd395dc3303cde65e18e0524ed2f70268c99Chris Lattner} 255679b3bd395dc3303cde65e18e0524ed2f70268c99Chris Lattner 255779b3bd395dc3303cde65e18e0524ed2f70268c99Chris Lattner/// isOnlyCopiedFromConstantGlobal - Recursively walk the uses of a (derived) 255879b3bd395dc3303cde65e18e0524ed2f70268c99Chris Lattner/// pointer to an alloca. Ignore any reads of the pointer, return false if we 255979b3bd395dc3303cde65e18e0524ed2f70268c99Chris Lattner/// see any stores or other unknown uses. If we see pointer arithmetic, keep 256079b3bd395dc3303cde65e18e0524ed2f70268c99Chris Lattner/// track of whether it moves the pointer (with isOffset) but otherwise traverse 256179b3bd395dc3303cde65e18e0524ed2f70268c99Chris Lattner/// the uses. If we see a memcpy/memmove that targets an unoffseted pointer to 2562081f80078dccf02c1f9c61378ff88bbf1b4afb5eNick Lewycky/// the alloca, and if the source pointer is a pointer to a constant global, we 256379b3bd395dc3303cde65e18e0524ed2f70268c99Chris Lattner/// can optimize this. 25649174d5c7383490d79b6a483d73cded54e32275d6Nick Lewyckystatic bool 25659174d5c7383490d79b6a483d73cded54e32275d6Nick LewyckyisOnlyCopiedFromConstantGlobal(Value *V, MemTransferInst *&TheCopy, 25669174d5c7383490d79b6a483d73cded54e32275d6Nick Lewycky bool isOffset, 25679174d5c7383490d79b6a483d73cded54e32275d6Nick Lewycky SmallVector<Instruction *, 4> &LifetimeMarkers) { 25689174d5c7383490d79b6a483d73cded54e32275d6Nick Lewycky // We track lifetime intrinsics as we encounter them. If we decide to go 25699174d5c7383490d79b6a483d73cded54e32275d6Nick Lewycky // ahead and replace the value with the global, this lets the caller quickly 25709174d5c7383490d79b6a483d73cded54e32275d6Nick Lewycky // eliminate the markers. 25719174d5c7383490d79b6a483d73cded54e32275d6Nick Lewycky 257279b3bd395dc3303cde65e18e0524ed2f70268c99Chris Lattner for (Value::use_iterator UI = V->use_begin(), E = V->use_end(); UI!=E; ++UI) { 25738a8a4350db3e66a517dc179ba38439c66bb726a8Gabor Greif User *U = cast<Instruction>(*UI); 25748a8a4350db3e66a517dc179ba38439c66bb726a8Gabor Greif 25752e61849f45144f2f05d57b00947df7e101610694Chris Lattner if (LoadInst *LI = dyn_cast<LoadInst>(U)) { 25766e733d34ca487ab7ff8a6def018a933620393869Chris Lattner // Ignore non-volatile loads, they are always ok. 25772e61849f45144f2f05d57b00947df7e101610694Chris Lattner if (LI->isVolatile()) return false; 25782e61849f45144f2f05d57b00947df7e101610694Chris Lattner continue; 25792e61849f45144f2f05d57b00947df7e101610694Chris Lattner } 25806974302e3ff20746268721959efed807c7711bfcBob Wilson 25818a8a4350db3e66a517dc179ba38439c66bb726a8Gabor Greif if (BitCastInst *BCI = dyn_cast<BitCastInst>(U)) { 258279b3bd395dc3303cde65e18e0524ed2f70268c99Chris Lattner // If uses of the bitcast are ok, we are ok. 25839174d5c7383490d79b6a483d73cded54e32275d6Nick Lewycky if (!isOnlyCopiedFromConstantGlobal(BCI, TheCopy, isOffset, 25849174d5c7383490d79b6a483d73cded54e32275d6Nick Lewycky LifetimeMarkers)) 258579b3bd395dc3303cde65e18e0524ed2f70268c99Chris Lattner return false; 258679b3bd395dc3303cde65e18e0524ed2f70268c99Chris Lattner continue; 258779b3bd395dc3303cde65e18e0524ed2f70268c99Chris Lattner } 25888a8a4350db3e66a517dc179ba38439c66bb726a8Gabor Greif if (GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(U)) { 258979b3bd395dc3303cde65e18e0524ed2f70268c99Chris Lattner // If the GEP has all zero indices, it doesn't offset the pointer. If it 259079b3bd395dc3303cde65e18e0524ed2f70268c99Chris Lattner // doesn't, it does. 259179b3bd395dc3303cde65e18e0524ed2f70268c99Chris Lattner if (!isOnlyCopiedFromConstantGlobal(GEP, TheCopy, 25929174d5c7383490d79b6a483d73cded54e32275d6Nick Lewycky isOffset || !GEP->hasAllZeroIndices(), 25939174d5c7383490d79b6a483d73cded54e32275d6Nick Lewycky LifetimeMarkers)) 259479b3bd395dc3303cde65e18e0524ed2f70268c99Chris Lattner return false; 259579b3bd395dc3303cde65e18e0524ed2f70268c99Chris Lattner continue; 259679b3bd395dc3303cde65e18e0524ed2f70268c99Chris Lattner } 25976974302e3ff20746268721959efed807c7711bfcBob Wilson 25986248065194778c866164b0c10f09f0f0d91b91acChris Lattner if (CallSite CS = U) { 2599081f80078dccf02c1f9c61378ff88bbf1b4afb5eNick Lewycky // If this is the function being called then we treat it like a load and 2600081f80078dccf02c1f9c61378ff88bbf1b4afb5eNick Lewycky // ignore it. 2601081f80078dccf02c1f9c61378ff88bbf1b4afb5eNick Lewycky if (CS.isCallee(UI)) 2602081f80078dccf02c1f9c61378ff88bbf1b4afb5eNick Lewycky continue; 26036974302e3ff20746268721959efed807c7711bfcBob Wilson 26045389210e638401b8982b6de7c4e4a16999007035Duncan Sands // If this is a readonly/readnone call site, then we know it is just a 26055389210e638401b8982b6de7c4e4a16999007035Duncan Sands // load (but one that potentially returns the value itself), so we can 26065389210e638401b8982b6de7c4e4a16999007035Duncan Sands // ignore it if we know that the value isn't captured. 26075389210e638401b8982b6de7c4e4a16999007035Duncan Sands unsigned ArgNo = CS.getArgumentNo(UI); 26085389210e638401b8982b6de7c4e4a16999007035Duncan Sands if (CS.onlyReadsMemory() && 26095389210e638401b8982b6de7c4e4a16999007035Duncan Sands (CS.getInstruction()->use_empty() || 26105389210e638401b8982b6de7c4e4a16999007035Duncan Sands CS.paramHasAttr(ArgNo+1, Attribute::NoCapture))) 26115389210e638401b8982b6de7c4e4a16999007035Duncan Sands continue; 26125389210e638401b8982b6de7c4e4a16999007035Duncan Sands 26136248065194778c866164b0c10f09f0f0d91b91acChris Lattner // If this is being passed as a byval argument, the caller is making a 26146248065194778c866164b0c10f09f0f0d91b91acChris Lattner // copy, so it is only a read of the alloca. 26156248065194778c866164b0c10f09f0f0d91b91acChris Lattner if (CS.paramHasAttr(ArgNo+1, Attribute::ByVal)) 26166248065194778c866164b0c10f09f0f0d91b91acChris Lattner continue; 26176248065194778c866164b0c10f09f0f0d91b91acChris Lattner } 26186974302e3ff20746268721959efed807c7711bfcBob Wilson 26199174d5c7383490d79b6a483d73cded54e32275d6Nick Lewycky // Lifetime intrinsics can be handled by the caller. 26209174d5c7383490d79b6a483d73cded54e32275d6Nick Lewycky if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(U)) { 26219174d5c7383490d79b6a483d73cded54e32275d6Nick Lewycky if (II->getIntrinsicID() == Intrinsic::lifetime_start || 26229174d5c7383490d79b6a483d73cded54e32275d6Nick Lewycky II->getIntrinsicID() == Intrinsic::lifetime_end) { 26239174d5c7383490d79b6a483d73cded54e32275d6Nick Lewycky assert(II->use_empty() && "Lifetime markers have no result to use!"); 26249174d5c7383490d79b6a483d73cded54e32275d6Nick Lewycky LifetimeMarkers.push_back(II); 26259174d5c7383490d79b6a483d73cded54e32275d6Nick Lewycky continue; 26269174d5c7383490d79b6a483d73cded54e32275d6Nick Lewycky } 26279174d5c7383490d79b6a483d73cded54e32275d6Nick Lewycky } 26289174d5c7383490d79b6a483d73cded54e32275d6Nick Lewycky 262979b3bd395dc3303cde65e18e0524ed2f70268c99Chris Lattner // If this is isn't our memcpy/memmove, reject it as something we can't 263079b3bd395dc3303cde65e18e0524ed2f70268c99Chris Lattner // handle. 263131d80103d56c026403d7fb6c50833664ff63ddcbChris Lattner MemTransferInst *MI = dyn_cast<MemTransferInst>(U); 263231d80103d56c026403d7fb6c50833664ff63ddcbChris Lattner if (MI == 0) 263379b3bd395dc3303cde65e18e0524ed2f70268c99Chris Lattner return false; 26346974302e3ff20746268721959efed807c7711bfcBob Wilson 26352e61849f45144f2f05d57b00947df7e101610694Chris Lattner // If the transfer is using the alloca as a source of the transfer, then 26362e29ebd9e8efefe3ff926aa99cf2e5323665998eChris Lattner // ignore it since it is a load (unless the transfer is volatile). 26372e61849f45144f2f05d57b00947df7e101610694Chris Lattner if (UI.getOperandNo() == 1) { 26382e61849f45144f2f05d57b00947df7e101610694Chris Lattner if (MI->isVolatile()) return false; 26392e61849f45144f2f05d57b00947df7e101610694Chris Lattner continue; 26402e61849f45144f2f05d57b00947df7e101610694Chris Lattner } 264179b3bd395dc3303cde65e18e0524ed2f70268c99Chris Lattner 264279b3bd395dc3303cde65e18e0524ed2f70268c99Chris Lattner // If we already have seen a copy, reject the second one. 264379b3bd395dc3303cde65e18e0524ed2f70268c99Chris Lattner if (TheCopy) return false; 26446974302e3ff20746268721959efed807c7711bfcBob Wilson 264579b3bd395dc3303cde65e18e0524ed2f70268c99Chris Lattner // If the pointer has been offset from the start of the alloca, we can't 264679b3bd395dc3303cde65e18e0524ed2f70268c99Chris Lattner // safely handle this. 264779b3bd395dc3303cde65e18e0524ed2f70268c99Chris Lattner if (isOffset) return false; 264879b3bd395dc3303cde65e18e0524ed2f70268c99Chris Lattner 264979b3bd395dc3303cde65e18e0524ed2f70268c99Chris Lattner // If the memintrinsic isn't using the alloca as the dest, reject it. 2650a6aac4c5bc22bb10c7adb11eee3f82c703af7002Gabor Greif if (UI.getOperandNo() != 0) return false; 26516974302e3ff20746268721959efed807c7711bfcBob Wilson 265279b3bd395dc3303cde65e18e0524ed2f70268c99Chris Lattner // If the source of the memcpy/move is not a constant global, reject it. 265331d80103d56c026403d7fb6c50833664ff63ddcbChris Lattner if (!PointsToConstantGlobal(MI->getSource())) 265479b3bd395dc3303cde65e18e0524ed2f70268c99Chris Lattner return false; 26556974302e3ff20746268721959efed807c7711bfcBob Wilson 265679b3bd395dc3303cde65e18e0524ed2f70268c99Chris Lattner // Otherwise, the transform is safe. Remember the copy instruction. 265779b3bd395dc3303cde65e18e0524ed2f70268c99Chris Lattner TheCopy = MI; 265879b3bd395dc3303cde65e18e0524ed2f70268c99Chris Lattner } 265979b3bd395dc3303cde65e18e0524ed2f70268c99Chris Lattner return true; 266079b3bd395dc3303cde65e18e0524ed2f70268c99Chris Lattner} 266179b3bd395dc3303cde65e18e0524ed2f70268c99Chris Lattner 266279b3bd395dc3303cde65e18e0524ed2f70268c99Chris Lattner/// isOnlyCopiedFromConstantGlobal - Return true if the specified alloca is only 266379b3bd395dc3303cde65e18e0524ed2f70268c99Chris Lattner/// modified by a copy from a constant global. If we can prove this, we can 266479b3bd395dc3303cde65e18e0524ed2f70268c99Chris Lattner/// replace any uses of the alloca with uses of the global directly. 26659174d5c7383490d79b6a483d73cded54e32275d6Nick LewyckyMemTransferInst * 26669174d5c7383490d79b6a483d73cded54e32275d6Nick LewyckySROA::isOnlyCopiedFromConstantGlobal(AllocaInst *AI, 26679174d5c7383490d79b6a483d73cded54e32275d6Nick Lewycky SmallVector<Instruction*, 4> &ToDelete) { 266831d80103d56c026403d7fb6c50833664ff63ddcbChris Lattner MemTransferInst *TheCopy = 0; 26699174d5c7383490d79b6a483d73cded54e32275d6Nick Lewycky if (::isOnlyCopiedFromConstantGlobal(AI, TheCopy, false, ToDelete)) 267079b3bd395dc3303cde65e18e0524ed2f70268c99Chris Lattner return TheCopy; 267179b3bd395dc3303cde65e18e0524ed2f70268c99Chris Lattner return 0; 267279b3bd395dc3303cde65e18e0524ed2f70268c99Chris Lattner} 2673