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// 16c9f27ee842b633662f381b6e2cbd6de96b5bf905Chad Rosier// This combines a simple SRoA algorithm with the Mem2Reg algorithm because they 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" 2506cb8ed00696eb14d1b831921452e50ec0568ea2Chandler Carruth#include "llvm/DIBuilder.h" 260bcbd1df7a204e1e512f1a27066d725309de1b13Bill Wendling#include "llvm/DebugInfo.h" 2738aec325604635380421a27e39ab06d55ed2458dChris Lattner#include "llvm/DerivedTypes.h" 28ed7b41ea90a17c826f195acbc456c4bb733113d6Chris Lattner#include "llvm/Function.h" 2979b3bd395dc3303cde65e18e0524ed2f70268c99Chris Lattner#include "llvm/GlobalVariable.h" 3006cb8ed00696eb14d1b831921452e50ec0568ea2Chandler Carruth#include "llvm/IRBuilder.h" 31d8e1eea678833cc2b15e4ea69a5a403ba9c3b013Misha Brukman#include "llvm/Instructions.h" 32372dda8881c7a32a6f5ce0f76a713e3a9ef46ea1Chris Lattner#include "llvm/IntrinsicInst.h" 33fa5cbd6d0fbda23fd669c8718e07b19001b2d21aOwen Anderson#include "llvm/LLVMContext.h" 3472eaa0e5eb345a8483608675b86dfcfa465c784cChris Lattner#include "llvm/Module.h" 359012c57e18d76d562b1f3e60bf19cccefa7b793ePeter Collingbourne#include "llvm/Operator.h" 36372dda8881c7a32a6f5ce0f76a713e3a9ef46ea1Chris Lattner#include "llvm/Pass.h" 3706cb8ed00696eb14d1b831921452e50ec0568ea2Chandler Carruth#include "llvm/ADT/SetVector.h" 3806cb8ed00696eb14d1b831921452e50ec0568ea2Chandler Carruth#include "llvm/ADT/SmallVector.h" 3906cb8ed00696eb14d1b831921452e50ec0568ea2Chandler Carruth#include "llvm/ADT/Statistic.h" 40b1686c32fc694636cbf15a59b23b2a741b65ecf4Cameron Zwarich#include "llvm/Analysis/Dominators.h" 41c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner#include "llvm/Analysis/Loads.h" 425034dd318a9dfa0dc45a3ac01e58e60f2aa2498dDan Gohman#include "llvm/Analysis/ValueTracking.h" 43a9be1df6d7a9b5a07253d83a634ae5876e7e5550Chris Lattner#include "llvm/Support/CallSite.h" 449525528a7dc5462b6374d38c81ba5c07b11741feChris Lattner#include "llvm/Support/Debug.h" 457d696d80409aad20bb5da0fc4eccab941dd371d4Torok Edwin#include "llvm/Support/ErrorHandling.h" 46a188894d67a3cc2516b25aae9b3cbdbff4b0babeChris Lattner#include "llvm/Support/GetElementPtrTypeIterator.h" 47a188894d67a3cc2516b25aae9b3cbdbff4b0babeChris Lattner#include "llvm/Support/MathExtras.h" 48bdff548e4dd577a72094d57b282de4e765643b96Chris Lattner#include "llvm/Support/raw_ostream.h" 4906cb8ed00696eb14d1b831921452e50ec0568ea2Chandler Carruth#include "llvm/Target/TargetData.h" 5006cb8ed00696eb14d1b831921452e50ec0568ea2Chandler Carruth#include "llvm/Transforms/Utils/Local.h" 5106cb8ed00696eb14d1b831921452e50ec0568ea2Chandler Carruth#include "llvm/Transforms/Utils/PromoteMemToReg.h" 5206cb8ed00696eb14d1b831921452e50ec0568ea2Chandler Carruth#include "llvm/Transforms/Utils/SSAUpdater.h" 53d8664730942beb911327336d1f9db8e7efcd6813Chris Lattnerusing namespace llvm; 54d0fde30ce850b78371fd1386338350591f9ff494Brian Gaeke 550e5f499638c8d277b9dc4a4385712177c53b5681Chris LattnerSTATISTIC(NumReplaced, "Number of allocas broken up"); 560e5f499638c8d277b9dc4a4385712177c53b5681Chris LattnerSTATISTIC(NumPromoted, "Number of allocas promoted"); 57c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris LattnerSTATISTIC(NumAdjusted, "Number of scalar allocas adjusted to allow promotion"); 580e5f499638c8d277b9dc4a4385712177c53b5681Chris LattnerSTATISTIC(NumConverted, "Number of aggregates converted to scalar"); 59ed7b41ea90a17c826f195acbc456c4bb733113d6Chris Lattner 600e5f499638c8d277b9dc4a4385712177c53b5681Chris Lattnernamespace { 613e8b6631e67e01e4960a7ba4668a50c596607473Chris Lattner struct SROA : public FunctionPass { 622114a8aaba99e901735e69818bb789757ed05cfdNadav Rotem SROA(int T, bool hasDT, char &ID, int ST, int AT, int SLT) 63b1686c32fc694636cbf15a59b23b2a741b65ecf4Cameron Zwarich : FunctionPass(ID), HasDomTree(hasDT) { 64ff366850aa9956e167e78d4f5b57aae10d8c5779Devang Patel if (T == -1) 65b0e71edb6b33f822e001500dac90acf95faacea8Chris Lattner SRThreshold = 128; 66ff366850aa9956e167e78d4f5b57aae10d8c5779Devang Patel else 67ff366850aa9956e167e78d4f5b57aae10d8c5779Devang Patel SRThreshold = T; 682114a8aaba99e901735e69818bb789757ed05cfdNadav Rotem if (ST == -1) 692114a8aaba99e901735e69818bb789757ed05cfdNadav Rotem StructMemberThreshold = 32; 702114a8aaba99e901735e69818bb789757ed05cfdNadav Rotem else 712114a8aaba99e901735e69818bb789757ed05cfdNadav Rotem StructMemberThreshold = ST; 722114a8aaba99e901735e69818bb789757ed05cfdNadav Rotem if (AT == -1) 732114a8aaba99e901735e69818bb789757ed05cfdNadav Rotem ArrayElementThreshold = 8; 742114a8aaba99e901735e69818bb789757ed05cfdNadav Rotem else 752114a8aaba99e901735e69818bb789757ed05cfdNadav Rotem ArrayElementThreshold = AT; 762114a8aaba99e901735e69818bb789757ed05cfdNadav Rotem if (SLT == -1) 772114a8aaba99e901735e69818bb789757ed05cfdNadav Rotem // Do not limit the scalar integer load size if no threshold is given. 782114a8aaba99e901735e69818bb789757ed05cfdNadav Rotem ScalarLoadThreshold = -1; 792114a8aaba99e901735e69818bb789757ed05cfdNadav Rotem else 802114a8aaba99e901735e69818bb789757ed05cfdNadav Rotem ScalarLoadThreshold = SLT; 81ff366850aa9956e167e78d4f5b57aae10d8c5779Devang Patel } 82794fd75c67a2cdc128d67342c6d88a504d186896Devang Patel 83ed7b41ea90a17c826f195acbc456c4bb733113d6Chris Lattner bool runOnFunction(Function &F); 84ed7b41ea90a17c826f195acbc456c4bb733113d6Chris Lattner 8538aec325604635380421a27e39ab06d55ed2458dChris Lattner bool performScalarRepl(Function &F); 8638aec325604635380421a27e39ab06d55ed2458dChris Lattner bool performPromotion(Function &F); 8738aec325604635380421a27e39ab06d55ed2458dChris Lattner 88ed7b41ea90a17c826f195acbc456c4bb733113d6Chris Lattner private: 89b1686c32fc694636cbf15a59b23b2a741b65ecf4Cameron Zwarich bool HasDomTree; 9056c3852fb46b7754ad89b998b5968cff0c3937eeChris Lattner TargetData *TD; 916974302e3ff20746268721959efed807c7711bfcBob Wilson 92b742defa0a8f3e477c3ed641da49aab276937556Bob Wilson /// DeadInsts - Keep track of instructions we have made dead, so that 93b742defa0a8f3e477c3ed641da49aab276937556Bob Wilson /// we can remove them after we are done working. 94b742defa0a8f3e477c3ed641da49aab276937556Bob Wilson SmallVector<Value*, 32> DeadInsts; 95b742defa0a8f3e477c3ed641da49aab276937556Bob Wilson 9639a1c04323a5993d6b2993e615ec44c16e19aeeaChris Lattner /// AllocaInfo - When analyzing uses of an alloca instruction, this captures 9739a1c04323a5993d6b2993e615ec44c16e19aeeaChris Lattner /// information about the uses. All these fields are initialized to false 9839a1c04323a5993d6b2993e615ec44c16e19aeeaChris Lattner /// and set to true when something is learned. 9939a1c04323a5993d6b2993e615ec44c16e19aeeaChris Lattner struct AllocaInfo { 1006c95d24927b11fb76bc3e76ebe6a8198d74fc178Chris Lattner /// The alloca to promote. 1016c95d24927b11fb76bc3e76ebe6a8198d74fc178Chris Lattner AllocaInst *AI; 1022114a8aaba99e901735e69818bb789757ed05cfdNadav Rotem 103145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner /// CheckedPHIs - This is a set of verified PHI nodes, to prevent infinite 104145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner /// looping and avoid redundant work. 105145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner SmallPtrSet<PHINode*, 8> CheckedPHIs; 106a94d6e87c4c49f2e81b01d66d8bfb591277f8f96Nadav Rotem 10739a1c04323a5993d6b2993e615ec44c16e19aeeaChris Lattner /// isUnsafe - This is set to true if the alloca cannot be SROA'd. 10839a1c04323a5993d6b2993e615ec44c16e19aeeaChris Lattner bool isUnsafe : 1; 1096974302e3ff20746268721959efed807c7711bfcBob Wilson 11039a1c04323a5993d6b2993e615ec44c16e19aeeaChris Lattner /// isMemCpySrc - This is true if this aggregate is memcpy'd from. 11139a1c04323a5993d6b2993e615ec44c16e19aeeaChris Lattner bool isMemCpySrc : 1; 11239a1c04323a5993d6b2993e615ec44c16e19aeeaChris Lattner 11333b0b8d242de8d428f11e77ea734a08b47797216Zhou Sheng /// isMemCpyDst - This is true if this aggregate is memcpy'd into. 11439a1c04323a5993d6b2993e615ec44c16e19aeeaChris Lattner bool isMemCpyDst : 1; 11539a1c04323a5993d6b2993e615ec44c16e19aeeaChris Lattner 1167e9b427c879ae32b72fd24aeaf011e87e5692fd7Chris Lattner /// hasSubelementAccess - This is true if a subelement of the alloca is 1177e9b427c879ae32b72fd24aeaf011e87e5692fd7Chris Lattner /// ever accessed, or false if the alloca is only accessed with mem 1187e9b427c879ae32b72fd24aeaf011e87e5692fd7Chris Lattner /// intrinsics or load/store that only access the entire alloca at once. 1197e9b427c879ae32b72fd24aeaf011e87e5692fd7Chris Lattner bool hasSubelementAccess : 1; 120a94d6e87c4c49f2e81b01d66d8bfb591277f8f96Nadav Rotem 1217e9b427c879ae32b72fd24aeaf011e87e5692fd7Chris Lattner /// hasALoadOrStore - This is true if there are any loads or stores to it. 1227e9b427c879ae32b72fd24aeaf011e87e5692fd7Chris Lattner /// The alloca may just be accessed with memcpy, for example, which would 1237e9b427c879ae32b72fd24aeaf011e87e5692fd7Chris Lattner /// not set this. 1247e9b427c879ae32b72fd24aeaf011e87e5692fd7Chris Lattner bool hasALoadOrStore : 1; 125a94d6e87c4c49f2e81b01d66d8bfb591277f8f96Nadav Rotem 1266c95d24927b11fb76bc3e76ebe6a8198d74fc178Chris Lattner explicit AllocaInfo(AllocaInst *ai) 1276c95d24927b11fb76bc3e76ebe6a8198d74fc178Chris Lattner : AI(ai), isUnsafe(false), isMemCpySrc(false), isMemCpyDst(false), 1287e9b427c879ae32b72fd24aeaf011e87e5692fd7Chris Lattner hasSubelementAccess(false), hasALoadOrStore(false) {} 12939a1c04323a5993d6b2993e615ec44c16e19aeeaChris Lattner }; 1306974302e3ff20746268721959efed807c7711bfcBob Wilson 1312114a8aaba99e901735e69818bb789757ed05cfdNadav Rotem /// SRThreshold - The maximum alloca size to considered for SROA. 132ff366850aa9956e167e78d4f5b57aae10d8c5779Devang Patel unsigned SRThreshold; 133ff366850aa9956e167e78d4f5b57aae10d8c5779Devang Patel 1342114a8aaba99e901735e69818bb789757ed05cfdNadav Rotem /// StructMemberThreshold - The maximum number of members a struct can 1352114a8aaba99e901735e69818bb789757ed05cfdNadav Rotem /// contain to be considered for SROA. 1362114a8aaba99e901735e69818bb789757ed05cfdNadav Rotem unsigned StructMemberThreshold; 1372114a8aaba99e901735e69818bb789757ed05cfdNadav Rotem 1382114a8aaba99e901735e69818bb789757ed05cfdNadav Rotem /// ArrayElementThreshold - The maximum number of elements an array can 1392114a8aaba99e901735e69818bb789757ed05cfdNadav Rotem /// have to be considered for SROA. 1402114a8aaba99e901735e69818bb789757ed05cfdNadav Rotem unsigned ArrayElementThreshold; 1412114a8aaba99e901735e69818bb789757ed05cfdNadav Rotem 1422114a8aaba99e901735e69818bb789757ed05cfdNadav Rotem /// ScalarLoadThreshold - The maximum size in bits of scalars to load when 1432114a8aaba99e901735e69818bb789757ed05cfdNadav Rotem /// converting to scalar 1442114a8aaba99e901735e69818bb789757ed05cfdNadav Rotem unsigned ScalarLoadThreshold; 1452114a8aaba99e901735e69818bb789757ed05cfdNadav Rotem 146d01a0da090407762fe3b770d84f049d72d06467eChris Lattner void MarkUnsafe(AllocaInfo &I, Instruction *User) { 147d01a0da090407762fe3b770d84f049d72d06467eChris Lattner I.isUnsafe = true; 148d01a0da090407762fe3b770d84f049d72d06467eChris Lattner DEBUG(dbgs() << " Transformation preventing inst: " << *User << '\n'); 149d01a0da090407762fe3b770d84f049d72d06467eChris Lattner } 15039a1c04323a5993d6b2993e615ec44c16e19aeeaChris Lattner 1516c146eefbf75875250af37a0f1ea70fc6b4716eeVictor Hernandez bool isSafeAllocaToScalarRepl(AllocaInst *AI); 15239a1c04323a5993d6b2993e615ec44c16e19aeeaChris Lattner 1536c95d24927b11fb76bc3e76ebe6a8198d74fc178Chris Lattner void isSafeForScalarRepl(Instruction *I, uint64_t Offset, AllocaInfo &Info); 154145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner void isSafePHISelectUseForScalarRepl(Instruction *User, uint64_t Offset, 155145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner AllocaInfo &Info); 1566c95d24927b11fb76bc3e76ebe6a8198d74fc178Chris Lattner void isSafeGEP(GetElementPtrInst *GEPI, uint64_t &Offset, AllocaInfo &Info); 1576c95d24927b11fb76bc3e76ebe6a8198d74fc178Chris Lattner void isSafeMemAccess(uint64_t Offset, uint64_t MemSize, 158db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *MemOpType, bool isStore, AllocaInfo &Info, 159145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner Instruction *TheAccess, bool AllowWholeAccess); 160db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner bool TypeHasComponent(Type *T, uint64_t Offset, uint64_t Size); 161db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner uint64_t FindElementAndOffset(Type *&T, uint64_t &Offset, 162db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *&IdxTy); 1636974302e3ff20746268721959efed807c7711bfcBob Wilson 1646974302e3ff20746268721959efed807c7711bfcBob Wilson void DoScalarReplacement(AllocaInst *AI, 1657b929dad59785f62a66f7c58615082f98441e95eVictor Hernandez std::vector<AllocaInst*> &WorkList); 166b742defa0a8f3e477c3ed641da49aab276937556Bob Wilson void DeleteDeadInstructions(); 1676974302e3ff20746268721959efed807c7711bfcBob Wilson 168b742defa0a8f3e477c3ed641da49aab276937556Bob Wilson void RewriteForScalarRepl(Instruction *I, AllocaInst *AI, uint64_t Offset, 169b742defa0a8f3e477c3ed641da49aab276937556Bob Wilson SmallVector<AllocaInst*, 32> &NewElts); 170b742defa0a8f3e477c3ed641da49aab276937556Bob Wilson void RewriteBitCast(BitCastInst *BC, AllocaInst *AI, uint64_t Offset, 171b742defa0a8f3e477c3ed641da49aab276937556Bob Wilson SmallVector<AllocaInst*, 32> &NewElts); 172b742defa0a8f3e477c3ed641da49aab276937556Bob Wilson void RewriteGEP(GetElementPtrInst *GEPI, AllocaInst *AI, uint64_t Offset, 173b742defa0a8f3e477c3ed641da49aab276937556Bob Wilson SmallVector<AllocaInst*, 32> &NewElts); 1745a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky void RewriteLifetimeIntrinsic(IntrinsicInst *II, AllocaInst *AI, 1755a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky uint64_t Offset, 1765a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky SmallVector<AllocaInst*, 32> &NewElts); 177b742defa0a8f3e477c3ed641da49aab276937556Bob Wilson void RewriteMemIntrinUserOfAlloca(MemIntrinsic *MI, Instruction *Inst, 1787b929dad59785f62a66f7c58615082f98441e95eVictor Hernandez AllocaInst *AI, 179d93afec1dbbb1abb3df55e2e007b5f256d09f84aChris Lattner SmallVector<AllocaInst*, 32> &NewElts); 1807b929dad59785f62a66f7c58615082f98441e95eVictor Hernandez void RewriteStoreUserOfWholeAlloca(StoreInst *SI, AllocaInst *AI, 181d2fa781169175b827e50953a1d0b7edc6b0c4801Chris Lattner SmallVector<AllocaInst*, 32> &NewElts); 1827b929dad59785f62a66f7c58615082f98441e95eVictor Hernandez void RewriteLoadUserOfWholeAlloca(LoadInst *LI, AllocaInst *AI, 1836e733d34ca487ab7ff8a6def018a933620393869Chris Lattner SmallVector<AllocaInst*, 32> &NewElts); 1842114a8aaba99e901735e69818bb789757ed05cfdNadav Rotem bool ShouldAttemptScalarRepl(AllocaInst *AI); 185ed7b41ea90a17c826f195acbc456c4bb733113d6Chris Lattner }; 186a94d6e87c4c49f2e81b01d66d8bfb591277f8f96Nadav Rotem 187b1686c32fc694636cbf15a59b23b2a741b65ecf4Cameron Zwarich // SROA_DT - SROA that uses DominatorTree. 188b1686c32fc694636cbf15a59b23b2a741b65ecf4Cameron Zwarich struct SROA_DT : public SROA { 189b352d6eb49927a7c707cbd9046cfc525b0c3f2d7Chris Lattner static char ID; 190b352d6eb49927a7c707cbd9046cfc525b0c3f2d7Chris Lattner public: 1912114a8aaba99e901735e69818bb789757ed05cfdNadav Rotem SROA_DT(int T = -1, int ST = -1, int AT = -1, int SLT = -1) : 1922114a8aaba99e901735e69818bb789757ed05cfdNadav Rotem SROA(T, true, ID, ST, AT, SLT) { 193b1686c32fc694636cbf15a59b23b2a741b65ecf4Cameron Zwarich initializeSROA_DTPass(*PassRegistry::getPassRegistry()); 194b352d6eb49927a7c707cbd9046cfc525b0c3f2d7Chris Lattner } 195a94d6e87c4c49f2e81b01d66d8bfb591277f8f96Nadav Rotem 196b352d6eb49927a7c707cbd9046cfc525b0c3f2d7Chris Lattner // getAnalysisUsage - This pass does not require any passes, but we know it 197b352d6eb49927a7c707cbd9046cfc525b0c3f2d7Chris Lattner // will not alter the CFG, so say so. 198b352d6eb49927a7c707cbd9046cfc525b0c3f2d7Chris Lattner virtual void getAnalysisUsage(AnalysisUsage &AU) const { 199b352d6eb49927a7c707cbd9046cfc525b0c3f2d7Chris Lattner AU.addRequired<DominatorTree>(); 200b352d6eb49927a7c707cbd9046cfc525b0c3f2d7Chris Lattner AU.setPreservesCFG(); 201b352d6eb49927a7c707cbd9046cfc525b0c3f2d7Chris Lattner } 202b352d6eb49927a7c707cbd9046cfc525b0c3f2d7Chris Lattner }; 203a94d6e87c4c49f2e81b01d66d8bfb591277f8f96Nadav Rotem 204b352d6eb49927a7c707cbd9046cfc525b0c3f2d7Chris Lattner // SROA_SSAUp - SROA that uses SSAUpdater. 205b352d6eb49927a7c707cbd9046cfc525b0c3f2d7Chris Lattner struct SROA_SSAUp : public SROA { 206b352d6eb49927a7c707cbd9046cfc525b0c3f2d7Chris Lattner static char ID; 207b352d6eb49927a7c707cbd9046cfc525b0c3f2d7Chris Lattner public: 2082114a8aaba99e901735e69818bb789757ed05cfdNadav Rotem SROA_SSAUp(int T = -1, int ST = -1, int AT = -1, int SLT = -1) : 2092114a8aaba99e901735e69818bb789757ed05cfdNadav Rotem SROA(T, false, ID, ST, AT, SLT) { 210b352d6eb49927a7c707cbd9046cfc525b0c3f2d7Chris Lattner initializeSROA_SSAUpPass(*PassRegistry::getPassRegistry()); 211b352d6eb49927a7c707cbd9046cfc525b0c3f2d7Chris Lattner } 212a94d6e87c4c49f2e81b01d66d8bfb591277f8f96Nadav Rotem 213b352d6eb49927a7c707cbd9046cfc525b0c3f2d7Chris Lattner // getAnalysisUsage - This pass does not require any passes, but we know it 214b352d6eb49927a7c707cbd9046cfc525b0c3f2d7Chris Lattner // will not alter the CFG, so say so. 215b352d6eb49927a7c707cbd9046cfc525b0c3f2d7Chris Lattner virtual void getAnalysisUsage(AnalysisUsage &AU) const { 216b352d6eb49927a7c707cbd9046cfc525b0c3f2d7Chris Lattner AU.setPreservesCFG(); 217b352d6eb49927a7c707cbd9046cfc525b0c3f2d7Chris Lattner } 218b352d6eb49927a7c707cbd9046cfc525b0c3f2d7Chris Lattner }; 219a94d6e87c4c49f2e81b01d66d8bfb591277f8f96Nadav Rotem 220ed7b41ea90a17c826f195acbc456c4bb733113d6Chris Lattner} 221ed7b41ea90a17c826f195acbc456c4bb733113d6Chris Lattner 222b1686c32fc694636cbf15a59b23b2a741b65ecf4Cameron Zwarichchar SROA_DT::ID = 0; 223b352d6eb49927a7c707cbd9046cfc525b0c3f2d7Chris Lattnerchar SROA_SSAUp::ID = 0; 224b352d6eb49927a7c707cbd9046cfc525b0c3f2d7Chris Lattner 225b1686c32fc694636cbf15a59b23b2a741b65ecf4Cameron ZwarichINITIALIZE_PASS_BEGIN(SROA_DT, "scalarrepl", 226b1686c32fc694636cbf15a59b23b2a741b65ecf4Cameron Zwarich "Scalar Replacement of Aggregates (DT)", false, false) 2272ab36d350293c77fc8941ce1023e4899df7e3a82Owen AndersonINITIALIZE_PASS_DEPENDENCY(DominatorTree) 228b1686c32fc694636cbf15a59b23b2a741b65ecf4Cameron ZwarichINITIALIZE_PASS_END(SROA_DT, "scalarrepl", 229b1686c32fc694636cbf15a59b23b2a741b65ecf4Cameron Zwarich "Scalar Replacement of Aggregates (DT)", false, false) 230b352d6eb49927a7c707cbd9046cfc525b0c3f2d7Chris Lattner 231b352d6eb49927a7c707cbd9046cfc525b0c3f2d7Chris LattnerINITIALIZE_PASS_BEGIN(SROA_SSAUp, "scalarrepl-ssa", 232b352d6eb49927a7c707cbd9046cfc525b0c3f2d7Chris Lattner "Scalar Replacement of Aggregates (SSAUp)", false, false) 233b352d6eb49927a7c707cbd9046cfc525b0c3f2d7Chris LattnerINITIALIZE_PASS_END(SROA_SSAUp, "scalarrepl-ssa", 234b352d6eb49927a7c707cbd9046cfc525b0c3f2d7Chris Lattner "Scalar Replacement of Aggregates (SSAUp)", false, false) 235844731a7f1909f55935e3514c9e713a62d67662eDan Gohman 236d0fde30ce850b78371fd1386338350591f9ff494Brian Gaeke// Public interface to the ScalarReplAggregates pass 237b352d6eb49927a7c707cbd9046cfc525b0c3f2d7Chris LattnerFunctionPass *llvm::createScalarReplAggregatesPass(int Threshold, 2382114a8aaba99e901735e69818bb789757ed05cfdNadav Rotem bool UseDomTree, 2392114a8aaba99e901735e69818bb789757ed05cfdNadav Rotem int StructMemberThreshold, 2402114a8aaba99e901735e69818bb789757ed05cfdNadav Rotem int ArrayElementThreshold, 2412114a8aaba99e901735e69818bb789757ed05cfdNadav Rotem int ScalarLoadThreshold) { 242b1686c32fc694636cbf15a59b23b2a741b65ecf4Cameron Zwarich if (UseDomTree) 2432114a8aaba99e901735e69818bb789757ed05cfdNadav Rotem return new SROA_DT(Threshold, StructMemberThreshold, ArrayElementThreshold, 2442114a8aaba99e901735e69818bb789757ed05cfdNadav Rotem ScalarLoadThreshold); 2452114a8aaba99e901735e69818bb789757ed05cfdNadav Rotem return new SROA_SSAUp(Threshold, StructMemberThreshold, 2462114a8aaba99e901735e69818bb789757ed05cfdNadav Rotem ArrayElementThreshold, ScalarLoadThreshold); 247ff366850aa9956e167e78d4f5b57aae10d8c5779Devang Patel} 248ed7b41ea90a17c826f195acbc456c4bb733113d6Chris Lattner 249ed7b41ea90a17c826f195acbc456c4bb733113d6Chris Lattner 2504cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner//===----------------------------------------------------------------------===// 2514cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner// Convert To Scalar Optimization. 2524cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner//===----------------------------------------------------------------------===// 253963a97f1a365c8d09ca681e922371f9ec3473ee8Chris Lattner 254c4472072641f702dbd99ae12b7da089e75c44a99Chris Lattnernamespace { 255a001b664988f759d194f3d5d880c61449219fc2eChris Lattner/// ConvertToScalarInfo - This class implements the "Convert To Scalar" 256a001b664988f759d194f3d5d880c61449219fc2eChris Lattner/// optimization, which scans the uses of an alloca and determines if it can 257a001b664988f759d194f3d5d880c61449219fc2eChris Lattner/// rewrite it in terms of a single new alloca that can be mem2reg'd. 2584cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattnerclass ConvertToScalarInfo { 259d4c9c3e6b97e095c24d989c0f5ce763f90100ef1Cameron Zwarich /// AllocaSize - The size of the alloca being considered in bytes. 260c4472072641f702dbd99ae12b7da089e75c44a99Chris Lattner unsigned AllocaSize; 261593375d04ab32be0161607a741d310172f142b93Chris Lattner const TargetData &TD; 2622114a8aaba99e901735e69818bb789757ed05cfdNadav Rotem unsigned ScalarLoadThreshold; 2636974302e3ff20746268721959efed807c7711bfcBob Wilson 264a0bada729ffaa1bfc80ef25935bdc5a67432708fChris Lattner /// IsNotTrivial - This is set to true if there is some access to the object 265a001b664988f759d194f3d5d880c61449219fc2eChris Lattner /// which means that mem2reg can't promote it. 266c4472072641f702dbd99ae12b7da089e75c44a99Chris Lattner bool IsNotTrivial; 2676974302e3ff20746268721959efed807c7711bfcBob Wilson 268deb74f21f205aa245568ea965132eb076a3bf88cCameron Zwarich /// ScalarKind - Tracks the kind of alloca being considered for promotion, 269deb74f21f205aa245568ea965132eb076a3bf88cCameron Zwarich /// computed based on the uses of the alloca rather than the LLVM type system. 270deb74f21f205aa245568ea965132eb076a3bf88cCameron Zwarich enum { 271deb74f21f205aa245568ea965132eb076a3bf88cCameron Zwarich Unknown, 2725179782cf03cfabfe89df71677e0ffc772b5fdd5Cameron Zwarich 27315cd80c16b4e63b99dcbe45d2baa9456d414aacaCameron Zwarich // Accesses via GEPs that are consistent with element access of a vector 2745179782cf03cfabfe89df71677e0ffc772b5fdd5Cameron Zwarich // type. This will not be converted into a vector unless there is a later 2755179782cf03cfabfe89df71677e0ffc772b5fdd5Cameron Zwarich // access using an actual vector type. 2765179782cf03cfabfe89df71677e0ffc772b5fdd5Cameron Zwarich ImplicitVector, 2775179782cf03cfabfe89df71677e0ffc772b5fdd5Cameron Zwarich 27815cd80c16b4e63b99dcbe45d2baa9456d414aacaCameron Zwarich // Accesses via vector operations and GEPs that are consistent with the 27915cd80c16b4e63b99dcbe45d2baa9456d414aacaCameron Zwarich // layout of a vector type. 280deb74f21f205aa245568ea965132eb076a3bf88cCameron Zwarich Vector, 2815179782cf03cfabfe89df71677e0ffc772b5fdd5Cameron Zwarich 2825179782cf03cfabfe89df71677e0ffc772b5fdd5Cameron Zwarich // An integer bag-of-bits with bitwise operations for insertion and 2835179782cf03cfabfe89df71677e0ffc772b5fdd5Cameron Zwarich // extraction. Any combination of types can be converted into this kind 2845179782cf03cfabfe89df71677e0ffc772b5fdd5Cameron Zwarich // of scalar. 285deb74f21f205aa245568ea965132eb076a3bf88cCameron Zwarich Integer 286deb74f21f205aa245568ea965132eb076a3bf88cCameron Zwarich } ScalarKind; 287deb74f21f205aa245568ea965132eb076a3bf88cCameron Zwarich 288a001b664988f759d194f3d5d880c61449219fc2eChris Lattner /// VectorTy - This tracks the type that we should promote the vector to if 289a001b664988f759d194f3d5d880c61449219fc2eChris Lattner /// it is possible to turn it into a vector. This starts out null, and if it 290a001b664988f759d194f3d5d880c61449219fc2eChris Lattner /// isn't possible to turn into a vector type, it gets set to VoidTy. 291db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner VectorType *VectorTy; 2926974302e3ff20746268721959efed807c7711bfcBob Wilson 293a94d6e87c4c49f2e81b01d66d8bfb591277f8f96Nadav Rotem /// HadNonMemTransferAccess - True if there is at least one access to the 2941bcdb6ffad79936a96b46080bf0fed867243b32aCameron Zwarich /// alloca that is not a MemTransferInst. We don't want to turn structs into 2951bcdb6ffad79936a96b46080bf0fed867243b32aCameron Zwarich /// large integers unless there is some potential for optimization. 29685b0f468cf8390fca3ec356cd498ce0039dbad4fCameron Zwarich bool HadNonMemTransferAccess; 29785b0f468cf8390fca3ec356cd498ce0039dbad4fCameron Zwarich 29880f020a34ac60c7552c8e9b9c1f4b84c63941b57Pete Cooper /// HadDynamicAccess - True if some element of this alloca was dynamic. 29980f020a34ac60c7552c8e9b9c1f4b84c63941b57Pete Cooper /// We don't yet have support for turning a dynamic access into a large 30080f020a34ac60c7552c8e9b9c1f4b84c63941b57Pete Cooper /// integer. 30180f020a34ac60c7552c8e9b9c1f4b84c63941b57Pete Cooper bool HadDynamicAccess; 30280f020a34ac60c7552c8e9b9c1f4b84c63941b57Pete Cooper 3034cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattnerpublic: 3042114a8aaba99e901735e69818bb789757ed05cfdNadav Rotem explicit ConvertToScalarInfo(unsigned Size, const TargetData &td, 3052114a8aaba99e901735e69818bb789757ed05cfdNadav Rotem unsigned SLT) 3062114a8aaba99e901735e69818bb789757ed05cfdNadav Rotem : AllocaSize(Size), TD(td), ScalarLoadThreshold(SLT), IsNotTrivial(false), 3072114a8aaba99e901735e69818bb789757ed05cfdNadav Rotem ScalarKind(Unknown), VectorTy(0), HadNonMemTransferAccess(false), 3082114a8aaba99e901735e69818bb789757ed05cfdNadav Rotem HadDynamicAccess(false) { } 3096974302e3ff20746268721959efed807c7711bfcBob Wilson 310a001b664988f759d194f3d5d880c61449219fc2eChris Lattner AllocaInst *TryConvert(AllocaInst *AI); 3116974302e3ff20746268721959efed807c7711bfcBob Wilson 3124cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattnerprivate: 31380f020a34ac60c7552c8e9b9c1f4b84c63941b57Pete Cooper bool CanConvertToScalar(Value *V, uint64_t Offset, Value* NonConstantIdx); 314db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner void MergeInTypeForLoadOrStore(Type *In, uint64_t Offset); 315db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner bool MergeInVectorType(VectorType *VInTy, uint64_t Offset); 31680f020a34ac60c7552c8e9b9c1f4b84c63941b57Pete Cooper void ConvertUsesToScalar(Value *Ptr, AllocaInst *NewAI, uint64_t Offset, 31780f020a34ac60c7552c8e9b9c1f4b84c63941b57Pete Cooper Value *NonConstantIdx); 3186974302e3ff20746268721959efed807c7711bfcBob Wilson 319db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Value *ConvertScalar_ExtractValue(Value *NV, Type *ToType, 32080f020a34ac60c7552c8e9b9c1f4b84c63941b57Pete Cooper uint64_t Offset, Value* NonConstantIdx, 32180f020a34ac60c7552c8e9b9c1f4b84c63941b57Pete Cooper IRBuilder<> &Builder); 322593375d04ab32be0161607a741d310172f142b93Chris Lattner Value *ConvertScalar_InsertValue(Value *StoredVal, Value *ExistingVal, 32380f020a34ac60c7552c8e9b9c1f4b84c63941b57Pete Cooper uint64_t Offset, Value* NonConstantIdx, 32480f020a34ac60c7552c8e9b9c1f4b84c63941b57Pete Cooper IRBuilder<> &Builder); 325c4472072641f702dbd99ae12b7da089e75c44a99Chris Lattner}; 326c4472072641f702dbd99ae12b7da089e75c44a99Chris Lattner} // end anonymous namespace. 327c4472072641f702dbd99ae12b7da089e75c44a99Chris Lattner 32891abace4ef6fdfe01bcebfb8e90938e71f8a5c4fChris Lattner 329a001b664988f759d194f3d5d880c61449219fc2eChris Lattner/// TryConvert - Analyze the specified alloca, and if it is safe to do so, 330a001b664988f759d194f3d5d880c61449219fc2eChris Lattner/// rewrite it to be a new alloca which is mem2reg'able. This returns the new 331a001b664988f759d194f3d5d880c61449219fc2eChris Lattner/// alloca if possible or null if not. 332a001b664988f759d194f3d5d880c61449219fc2eChris LattnerAllocaInst *ConvertToScalarInfo::TryConvert(AllocaInst *AI) { 333a001b664988f759d194f3d5d880c61449219fc2eChris Lattner // If we can't convert this scalar, or if mem2reg can trivially do it, bail 334a001b664988f759d194f3d5d880c61449219fc2eChris Lattner // out. 33580f020a34ac60c7552c8e9b9c1f4b84c63941b57Pete Cooper if (!CanConvertToScalar(AI, 0, 0) || !IsNotTrivial) 336a001b664988f759d194f3d5d880c61449219fc2eChris Lattner return 0; 3376974302e3ff20746268721959efed807c7711bfcBob Wilson 3385179782cf03cfabfe89df71677e0ffc772b5fdd5Cameron Zwarich // If an alloca has only memset / memcpy uses, it may still have an Unknown 3395179782cf03cfabfe89df71677e0ffc772b5fdd5Cameron Zwarich // ScalarKind. Treat it as an Integer below. 3405179782cf03cfabfe89df71677e0ffc772b5fdd5Cameron Zwarich if (ScalarKind == Unknown) 3415179782cf03cfabfe89df71677e0ffc772b5fdd5Cameron Zwarich ScalarKind = Integer; 3425179782cf03cfabfe89df71677e0ffc772b5fdd5Cameron Zwarich 3433ebb05d9a6bf6604a4b25770cfda1872983b03b2Cameron Zwarich if (ScalarKind == Vector && VectorTy->getBitWidth() != AllocaSize * 8) 3443ebb05d9a6bf6604a4b25770cfda1872983b03b2Cameron Zwarich ScalarKind = Integer; 3453ebb05d9a6bf6604a4b25770cfda1872983b03b2Cameron Zwarich 346a001b664988f759d194f3d5d880c61449219fc2eChris Lattner // If we were able to find a vector type that can handle this with 347a001b664988f759d194f3d5d880c61449219fc2eChris Lattner // insert/extract elements, and if there was at least one use that had 348a001b664988f759d194f3d5d880c61449219fc2eChris Lattner // a vector type, promote this to a vector. We don't want to promote 349a001b664988f759d194f3d5d880c61449219fc2eChris Lattner // random stuff that doesn't use vectors (e.g. <9 x double>) because then 350a001b664988f759d194f3d5d880c61449219fc2eChris Lattner // we just get a lot of insert/extracts. If at least one vector is 351a001b664988f759d194f3d5d880c61449219fc2eChris Lattner // involved, then we probably really do have a union of vector/array. 352db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *NewTy; 3535b93d3ca6f9c6e81924063abb1487598906dcdabCameron Zwarich if (ScalarKind == Vector) { 3545b93d3ca6f9c6e81924063abb1487598906dcdabCameron Zwarich assert(VectorTy && "Missing type for vector scalar."); 355a001b664988f759d194f3d5d880c61449219fc2eChris Lattner DEBUG(dbgs() << "CONVERT TO VECTOR: " << *AI << "\n TYPE = " 356a001b664988f759d194f3d5d880c61449219fc2eChris Lattner << *VectorTy << '\n'); 357a001b664988f759d194f3d5d880c61449219fc2eChris Lattner NewTy = VectorTy; // Use the vector type. 358a001b664988f759d194f3d5d880c61449219fc2eChris Lattner } else { 35985b0f468cf8390fca3ec356cd498ce0039dbad4fCameron Zwarich unsigned BitWidth = AllocaSize * 8; 3602114a8aaba99e901735e69818bb789757ed05cfdNadav Rotem 3612114a8aaba99e901735e69818bb789757ed05cfdNadav Rotem // Do not convert to scalar integer if the alloca size exceeds the 3622114a8aaba99e901735e69818bb789757ed05cfdNadav Rotem // scalar load threshold. 3632114a8aaba99e901735e69818bb789757ed05cfdNadav Rotem if (BitWidth > ScalarLoadThreshold) 3642114a8aaba99e901735e69818bb789757ed05cfdNadav Rotem return 0; 3652114a8aaba99e901735e69818bb789757ed05cfdNadav Rotem 3665179782cf03cfabfe89df71677e0ffc772b5fdd5Cameron Zwarich if ((ScalarKind == ImplicitVector || ScalarKind == Integer) && 3675179782cf03cfabfe89df71677e0ffc772b5fdd5Cameron Zwarich !HadNonMemTransferAccess && !TD.fitsInLegalInteger(BitWidth)) 36885b0f468cf8390fca3ec356cd498ce0039dbad4fCameron Zwarich return 0; 36980f020a34ac60c7552c8e9b9c1f4b84c63941b57Pete Cooper // Dynamic accesses on integers aren't yet supported. They need us to shift 37080f020a34ac60c7552c8e9b9c1f4b84c63941b57Pete Cooper // by a dynamic amount which could be difficult to work out as we might not 37180f020a34ac60c7552c8e9b9c1f4b84c63941b57Pete Cooper // know whether to use a left or right shift. 37280f020a34ac60c7552c8e9b9c1f4b84c63941b57Pete Cooper if (ScalarKind == Integer && HadDynamicAccess) 37380f020a34ac60c7552c8e9b9c1f4b84c63941b57Pete Cooper return 0; 37485b0f468cf8390fca3ec356cd498ce0039dbad4fCameron Zwarich 375a001b664988f759d194f3d5d880c61449219fc2eChris Lattner DEBUG(dbgs() << "CONVERT TO SCALAR INTEGER: " << *AI << "\n"); 376a001b664988f759d194f3d5d880c61449219fc2eChris Lattner // Create and insert the integer alloca. 37785b0f468cf8390fca3ec356cd498ce0039dbad4fCameron Zwarich NewTy = IntegerType::get(AI->getContext(), BitWidth); 378a001b664988f759d194f3d5d880c61449219fc2eChris Lattner } 379a001b664988f759d194f3d5d880c61449219fc2eChris Lattner AllocaInst *NewAI = new AllocaInst(NewTy, 0, "", AI->getParent()->begin()); 38080f020a34ac60c7552c8e9b9c1f4b84c63941b57Pete Cooper ConvertUsesToScalar(AI, NewAI, 0, 0); 381a001b664988f759d194f3d5d880c61449219fc2eChris Lattner return NewAI; 382a001b664988f759d194f3d5d880c61449219fc2eChris Lattner} 383a001b664988f759d194f3d5d880c61449219fc2eChris Lattner 384c0e2607564c1259f2d2c56cbff8f78dc0853860dCameron Zwarich/// MergeInTypeForLoadOrStore - Add the 'In' type to the accumulated vector type 385c0e2607564c1259f2d2c56cbff8f78dc0853860dCameron Zwarich/// (VectorTy) so far at the offset specified by Offset (which is specified in 386c0e2607564c1259f2d2c56cbff8f78dc0853860dCameron Zwarich/// bytes). 3874cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// 388446d95224b35b0fef06200b950d45839f1d5f262Cameron Zwarich/// There are two cases we handle here: 3894cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// 1) A union of vector types of the same size and potentially its elements. 3904cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// Here we turn element accesses into insert/extract element operations. 3914cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// This promotes a <4 x float> with a store of float to the third element 3924cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// into a <4 x float> that uses insert element. 393446d95224b35b0fef06200b950d45839f1d5f262Cameron Zwarich/// 2) A fully general blob of memory, which we turn into some (potentially 3944cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// large) integer type with extract and insert operations where the loads 395a001b664988f759d194f3d5d880c61449219fc2eChris Lattner/// and stores would mutate the memory. We mark this by setting VectorTy 396a001b664988f759d194f3d5d880c61449219fc2eChris Lattner/// to VoidTy. 397db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattnervoid ConvertToScalarInfo::MergeInTypeForLoadOrStore(Type *In, 398c0e2607564c1259f2d2c56cbff8f78dc0853860dCameron Zwarich uint64_t Offset) { 399a001b664988f759d194f3d5d880c61449219fc2eChris Lattner // If we already decided to turn this into a blob of integer memory, there is 400a001b664988f759d194f3d5d880c61449219fc2eChris Lattner // nothing to be done. 401deb74f21f205aa245568ea965132eb076a3bf88cCameron Zwarich if (ScalarKind == Integer) 4024cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner return; 4036974302e3ff20746268721959efed807c7711bfcBob Wilson 4044cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // If this could be contributing to a vector, analyze it. 405c4472072641f702dbd99ae12b7da089e75c44a99Chris Lattner 4064cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // If the In type is a vector that is the same size as the alloca, see if it 4074cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // matches the existing VecTy. 408db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner if (VectorType *VInTy = dyn_cast<VectorType>(In)) { 409c9ecd14cee020f884313b60f8696384d3e7848f7Cameron Zwarich if (MergeInVectorType(VInTy, Offset)) 4104cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner return; 4114cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } else if (In->isFloatTy() || In->isDoubleTy() || 4124cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner (In->isIntegerTy() && In->getPrimitiveSizeInBits() >= 8 && 4134cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner isPowerOf2_32(In->getPrimitiveSizeInBits()))) { 4149827b78b51f285e90c2b1e5add9b28d10c88595cCameron Zwarich // Full width accesses can be ignored, because they can always be turned 4159827b78b51f285e90c2b1e5add9b28d10c88595cCameron Zwarich // into bitcasts. 4169827b78b51f285e90c2b1e5add9b28d10c88595cCameron Zwarich unsigned EltSize = In->getPrimitiveSizeInBits()/8; 417dd68912801861273dc3dca33cfc18357213049a4Cameron Zwarich if (EltSize == AllocaSize) 4189827b78b51f285e90c2b1e5add9b28d10c88595cCameron Zwarich return; 4195fc1282c1822d692ed1681cdc4c315950c6eb1d8Cameron Zwarich 4204cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // If we're accessing something that could be an element of a vector, see 4214cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // if the implied vector agrees with what we already have and if Offset is 4224cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // compatible with it. 42396cc1d0dfbcf9c7ffffc65f0aa008ff532d444f4Cameron Zwarich if (Offset % EltSize == 0 && AllocaSize % EltSize == 0 && 424446d95224b35b0fef06200b950d45839f1d5f262Cameron Zwarich (!VectorTy || EltSize == VectorTy->getElementType() 425446d95224b35b0fef06200b950d45839f1d5f262Cameron Zwarich ->getPrimitiveSizeInBits()/8)) { 4265fc1282c1822d692ed1681cdc4c315950c6eb1d8Cameron Zwarich if (!VectorTy) { 4275179782cf03cfabfe89df71677e0ffc772b5fdd5Cameron Zwarich ScalarKind = ImplicitVector; 4284cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner VectorTy = VectorType::get(In, AllocaSize/EltSize); 4295fc1282c1822d692ed1681cdc4c315950c6eb1d8Cameron Zwarich } 430446d95224b35b0fef06200b950d45839f1d5f262Cameron Zwarich return; 4314cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 4324cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 4336974302e3ff20746268721959efed807c7711bfcBob Wilson 4344cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Otherwise, we have a case that we can't handle with an optimized vector 4354cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // form. We can still turn this into a large integer. 436deb74f21f205aa245568ea965132eb076a3bf88cCameron Zwarich ScalarKind = Integer; 4374cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner} 438c4472072641f702dbd99ae12b7da089e75c44a99Chris Lattner 439c0e2607564c1259f2d2c56cbff8f78dc0853860dCameron Zwarich/// MergeInVectorType - Handles the vector case of MergeInTypeForLoadOrStore, 440c0e2607564c1259f2d2c56cbff8f78dc0853860dCameron Zwarich/// returning true if the type was successfully merged and false otherwise. 441db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattnerbool ConvertToScalarInfo::MergeInVectorType(VectorType *VInTy, 442c9ecd14cee020f884313b60f8696384d3e7848f7Cameron Zwarich uint64_t Offset) { 443446d95224b35b0fef06200b950d45839f1d5f262Cameron Zwarich if (VInTy->getBitWidth()/8 == AllocaSize && Offset == 0) { 444446d95224b35b0fef06200b950d45839f1d5f262Cameron Zwarich // If we're storing/loading a vector of the right size, allow it as a 445446d95224b35b0fef06200b950d45839f1d5f262Cameron Zwarich // vector. If this the first vector we see, remember the type so that 446446d95224b35b0fef06200b950d45839f1d5f262Cameron Zwarich // we know the element size. If this is a subsequent access, ignore it 447446d95224b35b0fef06200b950d45839f1d5f262Cameron Zwarich // even if it is a differing type but the same size. Worst case we can 448446d95224b35b0fef06200b950d45839f1d5f262Cameron Zwarich // bitcast the resultant vectors. 449446d95224b35b0fef06200b950d45839f1d5f262Cameron Zwarich if (!VectorTy) 450446d95224b35b0fef06200b950d45839f1d5f262Cameron Zwarich VectorTy = VInTy; 4515179782cf03cfabfe89df71677e0ffc772b5fdd5Cameron Zwarich ScalarKind = Vector; 452b2fd770136b92637c5f084b743eab29f910288d5Cameron Zwarich return true; 4535179782cf03cfabfe89df71677e0ffc772b5fdd5Cameron Zwarich } 454b2fd770136b92637c5f084b743eab29f910288d5Cameron Zwarich 455446d95224b35b0fef06200b950d45839f1d5f262Cameron Zwarich return false; 456c9ecd14cee020f884313b60f8696384d3e7848f7Cameron Zwarich} 457c9ecd14cee020f884313b60f8696384d3e7848f7Cameron Zwarich 4584cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// CanConvertToScalar - V is a pointer. If we can convert the pointee and all 4594cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// its accesses to a single vector type, return true and set VecTy to 4604cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// the new type. If we could convert the alloca into a single promotable 4614cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// integer, return true but set VecTy to VoidTy. Further, if the use is not a 4624cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// completely trivial use that mem2reg could promote, set IsNotTrivial. Offset 4634cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// is the current offset from the base of the alloca being analyzed. 4644cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// 4654cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// If we see at least one access to the value that is as a vector type, set the 4664cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// SawVec flag. 46780f020a34ac60c7552c8e9b9c1f4b84c63941b57Pete Cooperbool ConvertToScalarInfo::CanConvertToScalar(Value *V, uint64_t Offset, 46880f020a34ac60c7552c8e9b9c1f4b84c63941b57Pete Cooper Value* NonConstantIdx) { 4694cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner for (Value::use_iterator UI = V->use_begin(), E = V->use_end(); UI!=E; ++UI) { 4704cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Instruction *User = cast<Instruction>(*UI); 4716974302e3ff20746268721959efed807c7711bfcBob Wilson 4724cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (LoadInst *LI = dyn_cast<LoadInst>(User)) { 4734cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Don't break volatile loads. 4742bc3d52b9ab422ee9f7e42a1a4e3b818e623a5f7Eli Friedman if (!LI->isSimple()) 4754cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner return false; 4760488fb649a56b7fc89a5814df5308813f9e5a85dDale Johannesen // Don't touch MMX operations. 4770488fb649a56b7fc89a5814df5308813f9e5a85dDale Johannesen if (LI->getType()->isX86_MMXTy()) 4780488fb649a56b7fc89a5814df5308813f9e5a85dDale Johannesen return false; 47985b0f468cf8390fca3ec356cd498ce0039dbad4fCameron Zwarich HadNonMemTransferAccess = true; 480c0e2607564c1259f2d2c56cbff8f78dc0853860dCameron Zwarich MergeInTypeForLoadOrStore(LI->getType(), Offset); 481add2bd7f5941537a97a41e037ae2277fbeed0b4fChris Lattner continue; 482add2bd7f5941537a97a41e037ae2277fbeed0b4fChris Lattner } 4836974302e3ff20746268721959efed807c7711bfcBob Wilson 4844cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (StoreInst *SI = dyn_cast<StoreInst>(User)) { 4854cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Storing the pointer, not into the value? 4862bc3d52b9ab422ee9f7e42a1a4e3b818e623a5f7Eli Friedman if (SI->getOperand(0) == V || !SI->isSimple()) return false; 4870488fb649a56b7fc89a5814df5308813f9e5a85dDale Johannesen // Don't touch MMX operations. 4880488fb649a56b7fc89a5814df5308813f9e5a85dDale Johannesen if (SI->getOperand(0)->getType()->isX86_MMXTy()) 4890488fb649a56b7fc89a5814df5308813f9e5a85dDale Johannesen return false; 49085b0f468cf8390fca3ec356cd498ce0039dbad4fCameron Zwarich HadNonMemTransferAccess = true; 491c0e2607564c1259f2d2c56cbff8f78dc0853860dCameron Zwarich MergeInTypeForLoadOrStore(SI->getOperand(0)->getType(), Offset); 4927809ecd5b019d26498499121f4d9c0b7de2f0a14Chris Lattner continue; 4937809ecd5b019d26498499121f4d9c0b7de2f0a14Chris Lattner } 4946974302e3ff20746268721959efed807c7711bfcBob Wilson 4954cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (BitCastInst *BCI = dyn_cast<BitCastInst>(User)) { 4965a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky if (!onlyUsedByLifetimeMarkers(BCI)) 4975a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky IsNotTrivial = true; // Can't be mem2reg'd. 49880f020a34ac60c7552c8e9b9c1f4b84c63941b57Pete Cooper if (!CanConvertToScalar(BCI, Offset, NonConstantIdx)) 4994cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner return false; 5003992feb075b27ff37b63017078a977206f97d10dBob Wilson continue; 5013992feb075b27ff37b63017078a977206f97d10dBob Wilson } 5023992feb075b27ff37b63017078a977206f97d10dBob Wilson 5034cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(User)) { 5044cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // If this is a GEP with a variable indices, we can't handle it. 50580f020a34ac60c7552c8e9b9c1f4b84c63941b57Pete Cooper PointerType* PtrTy = dyn_cast<PointerType>(GEP->getPointerOperandType()); 50680f020a34ac60c7552c8e9b9c1f4b84c63941b57Pete Cooper if (!PtrTy) 5074cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner return false; 5086974302e3ff20746268721959efed807c7711bfcBob Wilson 5094cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Compute the offset that this GEP adds to the pointer. 5104cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner SmallVector<Value*, 8> Indices(GEP->op_begin()+1, GEP->op_end()); 51180f020a34ac60c7552c8e9b9c1f4b84c63941b57Pete Cooper Value *GEPNonConstantIdx = 0; 51280f020a34ac60c7552c8e9b9c1f4b84c63941b57Pete Cooper if (!GEP->hasAllConstantIndices()) { 51380f020a34ac60c7552c8e9b9c1f4b84c63941b57Pete Cooper if (!isa<VectorType>(PtrTy->getElementType())) 51480f020a34ac60c7552c8e9b9c1f4b84c63941b57Pete Cooper return false; 51580f020a34ac60c7552c8e9b9c1f4b84c63941b57Pete Cooper if (NonConstantIdx) 51680f020a34ac60c7552c8e9b9c1f4b84c63941b57Pete Cooper return false; 51780f020a34ac60c7552c8e9b9c1f4b84c63941b57Pete Cooper GEPNonConstantIdx = Indices.pop_back_val(); 51880f020a34ac60c7552c8e9b9c1f4b84c63941b57Pete Cooper if (!GEPNonConstantIdx->getType()->isIntegerTy(32)) 51980f020a34ac60c7552c8e9b9c1f4b84c63941b57Pete Cooper return false; 52080f020a34ac60c7552c8e9b9c1f4b84c63941b57Pete Cooper HadDynamicAccess = true; 52180f020a34ac60c7552c8e9b9c1f4b84c63941b57Pete Cooper } else 52280f020a34ac60c7552c8e9b9c1f4b84c63941b57Pete Cooper GEPNonConstantIdx = NonConstantIdx; 52380f020a34ac60c7552c8e9b9c1f4b84c63941b57Pete Cooper uint64_t GEPOffset = TD.getIndexedOffset(PtrTy, 5248fbbb3980755d74539a0aed02bc18842ed2bd18dJay Foad Indices); 5254cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // See if all uses can be converted. 52680f020a34ac60c7552c8e9b9c1f4b84c63941b57Pete Cooper if (!CanConvertToScalar(GEP, Offset+GEPOffset, GEPNonConstantIdx)) 5274cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner return false; 528a001b664988f759d194f3d5d880c61449219fc2eChris Lattner IsNotTrivial = true; // Can't be mem2reg'd. 52985b0f468cf8390fca3ec356cd498ce0039dbad4fCameron Zwarich HadNonMemTransferAccess = true; 5307809ecd5b019d26498499121f4d9c0b7de2f0a14Chris Lattner continue; 5314cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 532ed7b41ea90a17c826f195acbc456c4bb733113d6Chris Lattner 5334cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // If this is a constant sized memset of a constant value (e.g. 0) we can 5344cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // handle it. 5354cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (MemSetInst *MSI = dyn_cast<MemSetInst>(User)) { 53680f020a34ac60c7552c8e9b9c1f4b84c63941b57Pete Cooper // Store to dynamic index. 53780f020a34ac60c7552c8e9b9c1f4b84c63941b57Pete Cooper if (NonConstantIdx) 53880f020a34ac60c7552c8e9b9c1f4b84c63941b57Pete Cooper return false; 5396be41eb7f00319f5ffa1a5435dcd1e81b3ce932dCameron Zwarich // Store of constant value. 5406be41eb7f00319f5ffa1a5435dcd1e81b3ce932dCameron Zwarich if (!isa<ConstantInt>(MSI->getValue())) 541a001b664988f759d194f3d5d880c61449219fc2eChris Lattner return false; 5426be41eb7f00319f5ffa1a5435dcd1e81b3ce932dCameron Zwarich 5436be41eb7f00319f5ffa1a5435dcd1e81b3ce932dCameron Zwarich // Store of constant size. 5446be41eb7f00319f5ffa1a5435dcd1e81b3ce932dCameron Zwarich ConstantInt *Len = dyn_cast<ConstantInt>(MSI->getLength()); 5456be41eb7f00319f5ffa1a5435dcd1e81b3ce932dCameron Zwarich if (!Len) 5466be41eb7f00319f5ffa1a5435dcd1e81b3ce932dCameron Zwarich return false; 5476be41eb7f00319f5ffa1a5435dcd1e81b3ce932dCameron Zwarich 5486be41eb7f00319f5ffa1a5435dcd1e81b3ce932dCameron Zwarich // If the size differs from the alloca, we can only convert the alloca to 5496be41eb7f00319f5ffa1a5435dcd1e81b3ce932dCameron Zwarich // an integer bag-of-bits. 5506be41eb7f00319f5ffa1a5435dcd1e81b3ce932dCameron Zwarich // FIXME: This should handle all of the cases that are currently accepted 5516be41eb7f00319f5ffa1a5435dcd1e81b3ce932dCameron Zwarich // as vector element insertions. 5526be41eb7f00319f5ffa1a5435dcd1e81b3ce932dCameron Zwarich if (Len->getZExtValue() != AllocaSize || Offset != 0) 5536be41eb7f00319f5ffa1a5435dcd1e81b3ce932dCameron Zwarich ScalarKind = Integer; 5546be41eb7f00319f5ffa1a5435dcd1e81b3ce932dCameron Zwarich 555a001b664988f759d194f3d5d880c61449219fc2eChris Lattner IsNotTrivial = true; // Can't be mem2reg'd. 55685b0f468cf8390fca3ec356cd498ce0039dbad4fCameron Zwarich HadNonMemTransferAccess = true; 557a001b664988f759d194f3d5d880c61449219fc2eChris Lattner continue; 5584cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 559fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman 5604cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // If this is a memcpy or memmove into or out of the whole allocation, we 5614cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // can handle it like a load or store of the scalar type. 5624cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (MemTransferInst *MTI = dyn_cast<MemTransferInst>(User)) { 56380f020a34ac60c7552c8e9b9c1f4b84c63941b57Pete Cooper // Store to dynamic index. 56480f020a34ac60c7552c8e9b9c1f4b84c63941b57Pete Cooper if (NonConstantIdx) 56580f020a34ac60c7552c8e9b9c1f4b84c63941b57Pete Cooper return false; 566a001b664988f759d194f3d5d880c61449219fc2eChris Lattner ConstantInt *Len = dyn_cast<ConstantInt>(MTI->getLength()); 567a001b664988f759d194f3d5d880c61449219fc2eChris Lattner if (Len == 0 || Len->getZExtValue() != AllocaSize || Offset != 0) 568a001b664988f759d194f3d5d880c61449219fc2eChris Lattner return false; 5696974302e3ff20746268721959efed807c7711bfcBob Wilson 570a001b664988f759d194f3d5d880c61449219fc2eChris Lattner IsNotTrivial = true; // Can't be mem2reg'd. 571a001b664988f759d194f3d5d880c61449219fc2eChris Lattner continue; 572ed7b41ea90a17c826f195acbc456c4bb733113d6Chris Lattner } 5736974302e3ff20746268721959efed807c7711bfcBob Wilson 5745a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky // If this is a lifetime intrinsic, we can handle it. 5755a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(User)) { 5765a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky if (II->getIntrinsicID() == Intrinsic::lifetime_start || 5775a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky II->getIntrinsicID() == Intrinsic::lifetime_end) { 5785a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky continue; 5795a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky } 5805a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky } 5815a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky 5824cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Otherwise, we cannot handle this! 5834cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner return false; 584a10b29b84b63c448b7cb423598d3a38b0f55cddbChris Lattner } 5856974302e3ff20746268721959efed807c7711bfcBob Wilson 5864cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner return true; 587ed7b41ea90a17c826f195acbc456c4bb733113d6Chris Lattner} 588a59adc40153f3e0f9843952c127d179b5ebe6c4cChris Lattner 5894cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// ConvertUsesToScalar - Convert all of the users of Ptr to use the new alloca 5904cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// directly. This happens when we are converting an "integer union" to a 5914cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// single integer scalar, or when we are converting a "vector union" to a 5924cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// vector with insert/extractelement instructions. 5934cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// 5944cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// Offset is an offset from the original alloca, in bits that need to be 5954cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// shifted to the right. By the end of this, there should be no uses of Ptr. 5964cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattnervoid ConvertToScalarInfo::ConvertUsesToScalar(Value *Ptr, AllocaInst *NewAI, 59780f020a34ac60c7552c8e9b9c1f4b84c63941b57Pete Cooper uint64_t Offset, 59880f020a34ac60c7552c8e9b9c1f4b84c63941b57Pete Cooper Value* NonConstantIdx) { 5994cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner while (!Ptr->use_empty()) { 6004cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Instruction *User = cast<Instruction>(Ptr->use_back()); 601b742defa0a8f3e477c3ed641da49aab276937556Bob Wilson 6024cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (BitCastInst *CI = dyn_cast<BitCastInst>(User)) { 60380f020a34ac60c7552c8e9b9c1f4b84c63941b57Pete Cooper ConvertUsesToScalar(CI, NewAI, Offset, NonConstantIdx); 6044cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner CI->eraseFromParent(); 6054cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner continue; 6064cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 607b742defa0a8f3e477c3ed641da49aab276937556Bob Wilson 6084cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(User)) { 6094cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Compute the offset that this GEP adds to the pointer. 6104cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner SmallVector<Value*, 8> Indices(GEP->op_begin()+1, GEP->op_end()); 6113eeba88631db6da7d45df67f677556297bd93f75Pete Cooper Value* GEPNonConstantIdx = 0; 6123eeba88631db6da7d45df67f677556297bd93f75Pete Cooper if (!GEP->hasAllConstantIndices()) { 6133eeba88631db6da7d45df67f677556297bd93f75Pete Cooper assert(!NonConstantIdx && 6143eeba88631db6da7d45df67f677556297bd93f75Pete Cooper "Dynamic GEP reading from dynamic GEP unsupported"); 6153eeba88631db6da7d45df67f677556297bd93f75Pete Cooper GEPNonConstantIdx = Indices.pop_back_val(); 6163eeba88631db6da7d45df67f677556297bd93f75Pete Cooper } else 6173eeba88631db6da7d45df67f677556297bd93f75Pete Cooper GEPNonConstantIdx = NonConstantIdx; 6184cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner uint64_t GEPOffset = TD.getIndexedOffset(GEP->getPointerOperandType(), 6198fbbb3980755d74539a0aed02bc18842ed2bd18dJay Foad Indices); 6203eeba88631db6da7d45df67f677556297bd93f75Pete Cooper ConvertUsesToScalar(GEP, NewAI, Offset+GEPOffset*8, GEPNonConstantIdx); 6214cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner GEP->eraseFromParent(); 6224cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner continue; 6234cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 6246974302e3ff20746268721959efed807c7711bfcBob Wilson 62561db1f56d0b717d67557bbb2a9d83af1449458cbChris Lattner IRBuilder<> Builder(User); 6266974302e3ff20746268721959efed807c7711bfcBob Wilson 6274cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (LoadInst *LI = dyn_cast<LoadInst>(User)) { 6284cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // The load is a bit extract from NewAI shifted right by Offset bits. 629a9390a4d5f5d568059a80970d22194b165d097a7Benjamin Kramer Value *LoadedVal = Builder.CreateLoad(NewAI); 6304cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Value *NewLoadVal 63180f020a34ac60c7552c8e9b9c1f4b84c63941b57Pete Cooper = ConvertScalar_ExtractValue(LoadedVal, LI->getType(), Offset, 63280f020a34ac60c7552c8e9b9c1f4b84c63941b57Pete Cooper NonConstantIdx, Builder); 6334cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner LI->replaceAllUsesWith(NewLoadVal); 6344cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner LI->eraseFromParent(); 6354cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner continue; 6364cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 6376974302e3ff20746268721959efed807c7711bfcBob Wilson 6384cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (StoreInst *SI = dyn_cast<StoreInst>(User)) { 6394cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner assert(SI->getOperand(0) != Ptr && "Consistency error!"); 6404cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Instruction *Old = Builder.CreateLoad(NewAI, NewAI->getName()+".in"); 6414cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Value *New = ConvertScalar_InsertValue(SI->getOperand(0), Old, Offset, 64280f020a34ac60c7552c8e9b9c1f4b84c63941b57Pete Cooper NonConstantIdx, Builder); 6434cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Builder.CreateStore(New, NewAI); 6444cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner SI->eraseFromParent(); 6456974302e3ff20746268721959efed807c7711bfcBob Wilson 6464cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // If the load we just inserted is now dead, then the inserted store 6474cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // overwrote the entire thing. 6484cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (Old->use_empty()) 6494cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Old->eraseFromParent(); 6504cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner continue; 6514cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 6526974302e3ff20746268721959efed807c7711bfcBob Wilson 6534cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // If this is a constant sized memset of a constant value (e.g. 0) we can 6544cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // transform it into a store of the expanded constant value. 6554cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (MemSetInst *MSI = dyn_cast<MemSetInst>(User)) { 6564cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner assert(MSI->getRawDest() == Ptr && "Consistency error!"); 65780f020a34ac60c7552c8e9b9c1f4b84c63941b57Pete Cooper assert(!NonConstantIdx && "Cannot replace dynamic memset with insert"); 65801b305f94c663d000e2128c7ea8c0c4e02e9eeb4Duncan Sands int64_t SNumBytes = cast<ConstantInt>(MSI->getLength())->getSExtValue(); 6591fe6bfca593404e261922990f230326934dda4d6Chris Lattner if (SNumBytes > 0 && (SNumBytes >> 32) == 0) { 6607e2fa3142aca46d9435a5804932ef76123c0cf71Aaron Ballman unsigned NumBytes = static_cast<unsigned>(SNumBytes); 6614cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner unsigned Val = cast<ConstantInt>(MSI->getValue())->getZExtValue(); 6626974302e3ff20746268721959efed807c7711bfcBob Wilson 6634cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Compute the value replicated the right number of times. 6644cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner APInt APVal(NumBytes*8, Val); 6652674089cefe519195e00bdf879647438cfb1cb0fDaniel Dunbar 6664cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Splat the value if non-zero. 6674cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (Val) 6684cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner for (unsigned i = 1; i != NumBytes; ++i) 6694cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner APVal |= APVal << 8; 6706974302e3ff20746268721959efed807c7711bfcBob Wilson 6714cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Instruction *Old = Builder.CreateLoad(NewAI, NewAI->getName()+".in"); 6724cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Value *New = ConvertScalar_InsertValue( 6734cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner ConstantInt::get(User->getContext(), APVal), 67480f020a34ac60c7552c8e9b9c1f4b84c63941b57Pete Cooper Old, Offset, 0, Builder); 6754cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Builder.CreateStore(New, NewAI); 6766974302e3ff20746268721959efed807c7711bfcBob Wilson 6774cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // If the load we just inserted is now dead, then the memset overwrote 6784cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // the entire thing. 6794cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (Old->use_empty()) 6806974302e3ff20746268721959efed807c7711bfcBob Wilson Old->eraseFromParent(); 6814cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 6824cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner MSI->eraseFromParent(); 6834cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner continue; 684b742defa0a8f3e477c3ed641da49aab276937556Bob Wilson } 685fca55c8ac7d12e4139ad0ab7d74b76c47935aef6Daniel Dunbar 6864cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // If this is a memcpy or memmove into or out of the whole allocation, we 6874cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // can handle it like a load or store of the scalar type. 6884cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (MemTransferInst *MTI = dyn_cast<MemTransferInst>(User)) { 6894cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner assert(Offset == 0 && "must be store to start of alloca"); 69080f020a34ac60c7552c8e9b9c1f4b84c63941b57Pete Cooper assert(!NonConstantIdx && "Cannot replace dynamic transfer with insert"); 6916974302e3ff20746268721959efed807c7711bfcBob Wilson 6924cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // If the source and destination are both to the same alloca, then this is 6934cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // a noop copy-to-self, just delete it. Otherwise, emit a load and store 6944cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // as appropriate. 695bd1801b5553c8be3960255a92738464e0010b6f6Dan Gohman AllocaInst *OrigAI = cast<AllocaInst>(GetUnderlyingObject(Ptr, &TD, 0)); 6966974302e3ff20746268721959efed807c7711bfcBob Wilson 697bd1801b5553c8be3960255a92738464e0010b6f6Dan Gohman if (GetUnderlyingObject(MTI->getSource(), &TD, 0) != OrigAI) { 6984cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Dest must be OrigAI, change this to be a load from the original 6994cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // pointer (bitcasted), then a store to our new alloca. 7004cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner assert(MTI->getRawDest() == Ptr && "Neither use is of pointer?"); 7014cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Value *SrcPtr = MTI->getSource(); 702db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner PointerType* SPTy = cast<PointerType>(SrcPtr->getType()); 703db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner PointerType* AIPTy = cast<PointerType>(NewAI->getType()); 704e90a6333c3a4514f88c8a3dddd10d9bcddcd6d85Mon P Wang if (SPTy->getAddressSpace() != AIPTy->getAddressSpace()) { 705e90a6333c3a4514f88c8a3dddd10d9bcddcd6d85Mon P Wang AIPTy = PointerType::get(AIPTy->getElementType(), 706e90a6333c3a4514f88c8a3dddd10d9bcddcd6d85Mon P Wang SPTy->getAddressSpace()); 707e90a6333c3a4514f88c8a3dddd10d9bcddcd6d85Mon P Wang } 708e90a6333c3a4514f88c8a3dddd10d9bcddcd6d85Mon P Wang SrcPtr = Builder.CreateBitCast(SrcPtr, AIPTy); 709e90a6333c3a4514f88c8a3dddd10d9bcddcd6d85Mon P Wang 7104cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner LoadInst *SrcVal = Builder.CreateLoad(SrcPtr, "srcval"); 7114cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner SrcVal->setAlignment(MTI->getAlignment()); 7124cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Builder.CreateStore(SrcVal, NewAI); 713bd1801b5553c8be3960255a92738464e0010b6f6Dan Gohman } else if (GetUnderlyingObject(MTI->getDest(), &TD, 0) != OrigAI) { 7144cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Src must be OrigAI, change this to be a load from NewAI then a store 7154cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // through the original dest pointer (bitcasted). 7164cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner assert(MTI->getRawSource() == Ptr && "Neither use is of pointer?"); 7174cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner LoadInst *SrcVal = Builder.CreateLoad(NewAI, "srcval"); 718b742defa0a8f3e477c3ed641da49aab276937556Bob Wilson 719db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner PointerType* DPTy = cast<PointerType>(MTI->getDest()->getType()); 720db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner PointerType* AIPTy = cast<PointerType>(NewAI->getType()); 721e90a6333c3a4514f88c8a3dddd10d9bcddcd6d85Mon P Wang if (DPTy->getAddressSpace() != AIPTy->getAddressSpace()) { 722e90a6333c3a4514f88c8a3dddd10d9bcddcd6d85Mon P Wang AIPTy = PointerType::get(AIPTy->getElementType(), 723e90a6333c3a4514f88c8a3dddd10d9bcddcd6d85Mon P Wang DPTy->getAddressSpace()); 724e90a6333c3a4514f88c8a3dddd10d9bcddcd6d85Mon P Wang } 725e90a6333c3a4514f88c8a3dddd10d9bcddcd6d85Mon P Wang Value *DstPtr = Builder.CreateBitCast(MTI->getDest(), AIPTy); 726e90a6333c3a4514f88c8a3dddd10d9bcddcd6d85Mon P Wang 7274cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner StoreInst *NewStore = Builder.CreateStore(SrcVal, DstPtr); 7284cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner NewStore->setAlignment(MTI->getAlignment()); 7294cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } else { 7304cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Noop transfer. Src == Dst 7314cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 7325fac55fafb53fde5c548bcd08e07418e9d8e549fMatthijs Kooijman 7334cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner MTI->eraseFromParent(); 7344cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner continue; 7354cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 7366974302e3ff20746268721959efed807c7711bfcBob Wilson 7375a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(User)) { 7385a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky if (II->getIntrinsicID() == Intrinsic::lifetime_start || 7395a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky II->getIntrinsicID() == Intrinsic::lifetime_end) { 7405a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky // There's no need to preserve these, as the resulting alloca will be 7415a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky // converted to a register anyways. 7425a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky II->eraseFromParent(); 7435a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky continue; 7445a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky } 7455a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky } 7465a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky 7474cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner llvm_unreachable("Unsupported operation!"); 74888e6dc8bf14e8a98888f62173a6581386b8d29a0Chris Lattner } 7492674089cefe519195e00bdf879647438cfb1cb0fDaniel Dunbar} 7502674089cefe519195e00bdf879647438cfb1cb0fDaniel Dunbar 7514cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// ConvertScalar_ExtractValue - Extract a value of type ToType from an integer 7524cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// or vector value FromVal, extracting the bits from the offset specified by 7534cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// Offset. This returns the value, which is of type ToType. 7544cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// 7554cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// This happens when we are converting an "integer union" to a single 7564cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// integer scalar, or when we are converting a "vector union" to a vector with 7574cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// insert/extractelement instructions. 7584cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// 7594cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// Offset is an offset from the original alloca, in bits that need to be 7604cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// shifted to the right. 7614cc576bc5ea27951f3bb15ccefbe483293bf8eafChris LattnerValue *ConvertToScalarInfo:: 762db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris LattnerConvertScalar_ExtractValue(Value *FromVal, Type *ToType, 76380f020a34ac60c7552c8e9b9c1f4b84c63941b57Pete Cooper uint64_t Offset, Value* NonConstantIdx, 76480f020a34ac60c7552c8e9b9c1f4b84c63941b57Pete Cooper IRBuilder<> &Builder) { 7654cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // If the load is of the whole new alloca, no conversion is needed. 766db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *FromType = FromVal->getType(); 767be0761c8202405cdd33f1103d262c0aa97895a8eMon P Wang if (FromType == ToType && Offset == 0) 7684cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner return FromVal; 7694cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner 7704cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // If the result alloca is a vector type, this is either an element 7714cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // access or a bitcast to another vector type of the same size. 772db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner if (VectorType *VTy = dyn_cast<VectorType>(FromType)) { 7730398d6135daef709f80837e457a75dc2e1c2aab7Cameron Zwarich unsigned FromTypeSize = TD.getTypeAllocSize(FromType); 7749827b78b51f285e90c2b1e5add9b28d10c88595cCameron Zwarich unsigned ToTypeSize = TD.getTypeAllocSize(ToType); 775446d95224b35b0fef06200b950d45839f1d5f262Cameron Zwarich if (FromTypeSize == ToTypeSize) 776a9390a4d5f5d568059a80970d22194b165d097a7Benjamin Kramer return Builder.CreateBitCast(FromVal, ToType); 7774cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner 7784cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Otherwise it must be an element access. 7794cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner unsigned Elt = 0; 7804cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (Offset) { 7814cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner unsigned EltSize = TD.getTypeAllocSizeInBits(VTy->getElementType()); 7824cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Elt = Offset/EltSize; 7834cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner assert(EltSize*Elt == Offset && "Invalid modulus in validity checking"); 784b742defa0a8f3e477c3ed641da49aab276937556Bob Wilson } 7854cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Return the element extracted out of it. 78680f020a34ac60c7552c8e9b9c1f4b84c63941b57Pete Cooper Value *Idx; 78780f020a34ac60c7552c8e9b9c1f4b84c63941b57Pete Cooper if (NonConstantIdx) { 78880f020a34ac60c7552c8e9b9c1f4b84c63941b57Pete Cooper if (Elt) 78980f020a34ac60c7552c8e9b9c1f4b84c63941b57Pete Cooper Idx = Builder.CreateAdd(NonConstantIdx, 79080f020a34ac60c7552c8e9b9c1f4b84c63941b57Pete Cooper Builder.getInt32(Elt), 79180f020a34ac60c7552c8e9b9c1f4b84c63941b57Pete Cooper "dyn.offset"); 79280f020a34ac60c7552c8e9b9c1f4b84c63941b57Pete Cooper else 79380f020a34ac60c7552c8e9b9c1f4b84c63941b57Pete Cooper Idx = NonConstantIdx; 79480f020a34ac60c7552c8e9b9c1f4b84c63941b57Pete Cooper } else 79580f020a34ac60c7552c8e9b9c1f4b84c63941b57Pete Cooper Idx = Builder.getInt32(Elt); 79680f020a34ac60c7552c8e9b9c1f4b84c63941b57Pete Cooper Value *V = Builder.CreateExtractElement(FromVal, Idx); 7974cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (V->getType() != ToType) 798a9390a4d5f5d568059a80970d22194b165d097a7Benjamin Kramer V = Builder.CreateBitCast(V, ToType); 7994cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner return V; 8004cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 8016974302e3ff20746268721959efed807c7711bfcBob Wilson 8024cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // If ToType is a first class aggregate, extract out each of the pieces and 8034cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // use insertvalue's to form the FCA. 804db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner if (StructType *ST = dyn_cast<StructType>(ToType)) { 80580f020a34ac60c7552c8e9b9c1f4b84c63941b57Pete Cooper assert(!NonConstantIdx && 80680f020a34ac60c7552c8e9b9c1f4b84c63941b57Pete Cooper "Dynamic indexing into struct types not supported"); 8074cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner const StructLayout &Layout = *TD.getStructLayout(ST); 8084cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Value *Res = UndefValue::get(ST); 8094cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner for (unsigned i = 0, e = ST->getNumElements(); i != e; ++i) { 8104cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Value *Elt = ConvertScalar_ExtractValue(FromVal, ST->getElementType(i), 8114cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Offset+Layout.getElementOffsetInBits(i), 81280f020a34ac60c7552c8e9b9c1f4b84c63941b57Pete Cooper 0, Builder); 813a9390a4d5f5d568059a80970d22194b165d097a7Benjamin Kramer Res = Builder.CreateInsertValue(Res, Elt, i); 8144cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 8154cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner return Res; 8164cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 8176974302e3ff20746268721959efed807c7711bfcBob Wilson 818db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner if (ArrayType *AT = dyn_cast<ArrayType>(ToType)) { 81980f020a34ac60c7552c8e9b9c1f4b84c63941b57Pete Cooper assert(!NonConstantIdx && 82080f020a34ac60c7552c8e9b9c1f4b84c63941b57Pete Cooper "Dynamic indexing into array types not supported"); 8214cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner uint64_t EltSize = TD.getTypeAllocSizeInBits(AT->getElementType()); 8224cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Value *Res = UndefValue::get(AT); 8234cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner for (unsigned i = 0, e = AT->getNumElements(); i != e; ++i) { 8244cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Value *Elt = ConvertScalar_ExtractValue(FromVal, AT->getElementType(), 82580f020a34ac60c7552c8e9b9c1f4b84c63941b57Pete Cooper Offset+i*EltSize, 0, Builder); 826a9390a4d5f5d568059a80970d22194b165d097a7Benjamin Kramer Res = Builder.CreateInsertValue(Res, Elt, i); 8274cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 8284cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner return Res; 829b742defa0a8f3e477c3ed641da49aab276937556Bob Wilson } 8302674089cefe519195e00bdf879647438cfb1cb0fDaniel Dunbar 8314cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Otherwise, this must be a union that was converted to an integer value. 832db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner IntegerType *NTy = cast<IntegerType>(FromVal->getType()); 833b742defa0a8f3e477c3ed641da49aab276937556Bob Wilson 8344cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // If this is a big-endian system and the load is narrower than the 8354cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // full alloca type, we need to do a shift to get the right bits. 8364cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner int ShAmt = 0; 8374cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (TD.isBigEndian()) { 8384cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // On big-endian machines, the lowest bit is stored at the bit offset 8394cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // from the pointer given by getTypeStoreSizeInBits. This matters for 8404cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // integers with a bitwidth that is not a multiple of 8. 8414cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner ShAmt = TD.getTypeStoreSizeInBits(NTy) - 8424cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner TD.getTypeStoreSizeInBits(ToType) - Offset; 843b742defa0a8f3e477c3ed641da49aab276937556Bob Wilson } else { 8444cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner ShAmt = Offset; 845b742defa0a8f3e477c3ed641da49aab276937556Bob Wilson } 846b742defa0a8f3e477c3ed641da49aab276937556Bob Wilson 8474cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Note: we support negative bitwidths (with shl) which are not defined. 8484cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // We do this to support (f.e.) loads off the end of a structure where 8494cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // only some bits are used. 8504cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (ShAmt > 0 && (unsigned)ShAmt < NTy->getBitWidth()) 8514cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner FromVal = Builder.CreateLShr(FromVal, 852a9390a4d5f5d568059a80970d22194b165d097a7Benjamin Kramer ConstantInt::get(FromVal->getType(), ShAmt)); 8534cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner else if (ShAmt < 0 && (unsigned)-ShAmt < NTy->getBitWidth()) 8546974302e3ff20746268721959efed807c7711bfcBob Wilson FromVal = Builder.CreateShl(FromVal, 855a9390a4d5f5d568059a80970d22194b165d097a7Benjamin Kramer ConstantInt::get(FromVal->getType(), -ShAmt)); 856b742defa0a8f3e477c3ed641da49aab276937556Bob Wilson 8574cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Finally, unconditionally truncate the integer to the right width. 8584cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner unsigned LIBitWidth = TD.getTypeSizeInBits(ToType); 8594cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (LIBitWidth < NTy->getBitWidth()) 8604cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner FromVal = 8616974302e3ff20746268721959efed807c7711bfcBob Wilson Builder.CreateTrunc(FromVal, IntegerType::get(FromVal->getContext(), 862a9390a4d5f5d568059a80970d22194b165d097a7Benjamin Kramer LIBitWidth)); 8634cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner else if (LIBitWidth > NTy->getBitWidth()) 8644cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner FromVal = 8656974302e3ff20746268721959efed807c7711bfcBob Wilson Builder.CreateZExt(FromVal, IntegerType::get(FromVal->getContext(), 866a9390a4d5f5d568059a80970d22194b165d097a7Benjamin Kramer LIBitWidth)); 8674cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner 8684cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // If the result is an integer, this is a trunc or bitcast. 8694cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (ToType->isIntegerTy()) { 8704cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Should be done. 8714cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } else if (ToType->isFloatingPointTy() || ToType->isVectorTy()) { 8724cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Just do a bitcast, we know the sizes match up. 873a9390a4d5f5d568059a80970d22194b165d097a7Benjamin Kramer FromVal = Builder.CreateBitCast(FromVal, ToType); 8744cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } else { 8754cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Otherwise must be a pointer. 876a9390a4d5f5d568059a80970d22194b165d097a7Benjamin Kramer FromVal = Builder.CreateIntToPtr(FromVal, ToType); 877372dda8881c7a32a6f5ce0f76a713e3a9ef46ea1Chris Lattner } 8784cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner assert(FromVal->getType() == ToType && "Didn't convert right?"); 8794cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner return FromVal; 880372dda8881c7a32a6f5ce0f76a713e3a9ef46ea1Chris Lattner} 881372dda8881c7a32a6f5ce0f76a713e3a9ef46ea1Chris Lattner 8824cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// ConvertScalar_InsertValue - Insert the value "SV" into the existing integer 8834cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// or vector value "Old" at the offset specified by Offset. 8844cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// 8854cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// This happens when we are converting an "integer union" to a 8864cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// single integer scalar, or when we are converting a "vector union" to a 8874cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// vector with insert/extractelement instructions. 8884cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// 8894cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// Offset is an offset from the original alloca, in bits that need to be 8904cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// shifted to the right. 89180f020a34ac60c7552c8e9b9c1f4b84c63941b57Pete Cooper/// 89280f020a34ac60c7552c8e9b9c1f4b84c63941b57Pete Cooper/// NonConstantIdx is an index value if there was a GEP with a non-constant 89380f020a34ac60c7552c8e9b9c1f4b84c63941b57Pete Cooper/// index value. If this is 0 then all GEPs used to find this insert address 89480f020a34ac60c7552c8e9b9c1f4b84c63941b57Pete Cooper/// are constant. 8954cc576bc5ea27951f3bb15ccefbe483293bf8eafChris LattnerValue *ConvertToScalarInfo:: 8964cc576bc5ea27951f3bb15ccefbe483293bf8eafChris LattnerConvertScalar_InsertValue(Value *SV, Value *Old, 89780f020a34ac60c7552c8e9b9c1f4b84c63941b57Pete Cooper uint64_t Offset, Value* NonConstantIdx, 89880f020a34ac60c7552c8e9b9c1f4b84c63941b57Pete Cooper IRBuilder<> &Builder) { 8994cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Convert the stored type to the actual type, shift it left to insert 9004cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // then 'or' into place. 901db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *AllocaType = Old->getType(); 9024cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner LLVMContext &Context = Old->getContext(); 9032674089cefe519195e00bdf879647438cfb1cb0fDaniel Dunbar 904db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner if (VectorType *VTy = dyn_cast<VectorType>(AllocaType)) { 9054cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner uint64_t VecSize = TD.getTypeAllocSizeInBits(VTy); 9064cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner uint64_t ValSize = TD.getTypeAllocSizeInBits(SV->getType()); 9076974302e3ff20746268721959efed807c7711bfcBob Wilson 9084cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Changing the whole vector with memset or with an access of a different 9094cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // vector type? 910446d95224b35b0fef06200b950d45839f1d5f262Cameron Zwarich if (ValSize == VecSize) 911a9390a4d5f5d568059a80970d22194b165d097a7Benjamin Kramer return Builder.CreateBitCast(SV, AllocaType); 912b2fd770136b92637c5f084b743eab29f910288d5Cameron Zwarich 9134cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Must be an element insertion. 91490747e34e6ca7162eaf8dde032649071045f161dCameron Zwarich Type *EltTy = VTy->getElementType(); 91590747e34e6ca7162eaf8dde032649071045f161dCameron Zwarich if (SV->getType() != EltTy) 91690747e34e6ca7162eaf8dde032649071045f161dCameron Zwarich SV = Builder.CreateBitCast(SV, EltTy); 91790747e34e6ca7162eaf8dde032649071045f161dCameron Zwarich uint64_t EltSize = TD.getTypeAllocSizeInBits(EltTy); 9184cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner unsigned Elt = Offset/EltSize; 91980f020a34ac60c7552c8e9b9c1f4b84c63941b57Pete Cooper Value *Idx; 92080f020a34ac60c7552c8e9b9c1f4b84c63941b57Pete Cooper if (NonConstantIdx) { 92180f020a34ac60c7552c8e9b9c1f4b84c63941b57Pete Cooper if (Elt) 92280f020a34ac60c7552c8e9b9c1f4b84c63941b57Pete Cooper Idx = Builder.CreateAdd(NonConstantIdx, 92380f020a34ac60c7552c8e9b9c1f4b84c63941b57Pete Cooper Builder.getInt32(Elt), 92480f020a34ac60c7552c8e9b9c1f4b84c63941b57Pete Cooper "dyn.offset"); 92580f020a34ac60c7552c8e9b9c1f4b84c63941b57Pete Cooper else 92680f020a34ac60c7552c8e9b9c1f4b84c63941b57Pete Cooper Idx = NonConstantIdx; 92780f020a34ac60c7552c8e9b9c1f4b84c63941b57Pete Cooper } else 92880f020a34ac60c7552c8e9b9c1f4b84c63941b57Pete Cooper Idx = Builder.getInt32(Elt); 92980f020a34ac60c7552c8e9b9c1f4b84c63941b57Pete Cooper return Builder.CreateInsertElement(Old, SV, Idx); 930b742defa0a8f3e477c3ed641da49aab276937556Bob Wilson } 9316974302e3ff20746268721959efed807c7711bfcBob Wilson 9324cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // If SV is a first-class aggregate value, insert each value recursively. 933db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner if (StructType *ST = dyn_cast<StructType>(SV->getType())) { 93480f020a34ac60c7552c8e9b9c1f4b84c63941b57Pete Cooper assert(!NonConstantIdx && 93580f020a34ac60c7552c8e9b9c1f4b84c63941b57Pete Cooper "Dynamic indexing into struct types not supported"); 9364cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner const StructLayout &Layout = *TD.getStructLayout(ST); 9374cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner for (unsigned i = 0, e = ST->getNumElements(); i != e; ++i) { 938a9390a4d5f5d568059a80970d22194b165d097a7Benjamin Kramer Value *Elt = Builder.CreateExtractValue(SV, i); 9396974302e3ff20746268721959efed807c7711bfcBob Wilson Old = ConvertScalar_InsertValue(Elt, Old, 9404cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Offset+Layout.getElementOffsetInBits(i), 94180f020a34ac60c7552c8e9b9c1f4b84c63941b57Pete Cooper 0, Builder); 9424cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 9434cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner return Old; 9444cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 9456974302e3ff20746268721959efed807c7711bfcBob Wilson 946db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner if (ArrayType *AT = dyn_cast<ArrayType>(SV->getType())) { 94780f020a34ac60c7552c8e9b9c1f4b84c63941b57Pete Cooper assert(!NonConstantIdx && 94880f020a34ac60c7552c8e9b9c1f4b84c63941b57Pete Cooper "Dynamic indexing into array types not supported"); 9494cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner uint64_t EltSize = TD.getTypeAllocSizeInBits(AT->getElementType()); 9504cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner for (unsigned i = 0, e = AT->getNumElements(); i != e; ++i) { 951a9390a4d5f5d568059a80970d22194b165d097a7Benjamin Kramer Value *Elt = Builder.CreateExtractValue(SV, i); 95280f020a34ac60c7552c8e9b9c1f4b84c63941b57Pete Cooper Old = ConvertScalar_InsertValue(Elt, Old, Offset+i*EltSize, 0, Builder); 9534cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 9544cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner return Old; 9554cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 9564cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner 9574cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // If SV is a float, convert it to the appropriate integer type. 9584cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // If it is a pointer, do the same. 9594cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner unsigned SrcWidth = TD.getTypeSizeInBits(SV->getType()); 9604cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner unsigned DestWidth = TD.getTypeSizeInBits(AllocaType); 9614cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner unsigned SrcStoreWidth = TD.getTypeStoreSizeInBits(SV->getType()); 9624cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner unsigned DestStoreWidth = TD.getTypeStoreSizeInBits(AllocaType); 9634cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (SV->getType()->isFloatingPointTy() || SV->getType()->isVectorTy()) 964a9390a4d5f5d568059a80970d22194b165d097a7Benjamin Kramer SV = Builder.CreateBitCast(SV, IntegerType::get(SV->getContext(),SrcWidth)); 9654cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner else if (SV->getType()->isPointerTy()) 966a9390a4d5f5d568059a80970d22194b165d097a7Benjamin Kramer SV = Builder.CreatePtrToInt(SV, TD.getIntPtrType(SV->getContext())); 9674cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner 9684cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Zero extend or truncate the value if needed. 9694cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (SV->getType() != AllocaType) { 9704cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (SV->getType()->getPrimitiveSizeInBits() < 9714cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner AllocaType->getPrimitiveSizeInBits()) 972a9390a4d5f5d568059a80970d22194b165d097a7Benjamin Kramer SV = Builder.CreateZExt(SV, AllocaType); 9734cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner else { 9744cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Truncation may be needed if storing more than the alloca can hold 9754cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // (undefined behavior). 976a9390a4d5f5d568059a80970d22194b165d097a7Benjamin Kramer SV = Builder.CreateTrunc(SV, AllocaType); 9774cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner SrcWidth = DestWidth; 9784cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner SrcStoreWidth = DestStoreWidth; 9794cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 9804cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 9814cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner 9824cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // If this is a big-endian system and the store is narrower than the 9834cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // full alloca type, we need to do a shift to get the right bits. 9844cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner int ShAmt = 0; 9854cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (TD.isBigEndian()) { 9864cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // On big-endian machines, the lowest bit is stored at the bit offset 9874cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // from the pointer given by getTypeStoreSizeInBits. This matters for 9884cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // integers with a bitwidth that is not a multiple of 8. 9894cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner ShAmt = DestStoreWidth - SrcStoreWidth - Offset; 9904cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } else { 9914cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner ShAmt = Offset; 9924cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 9934cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner 9944cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Note: we support negative bitwidths (with shr) which are not defined. 9954cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // We do this to support (f.e.) stores off the end of a structure where 9964cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // only some bits in the structure are set. 9974cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner APInt Mask(APInt::getLowBitsSet(DestWidth, SrcWidth)); 9984cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (ShAmt > 0 && (unsigned)ShAmt < DestWidth) { 999a9390a4d5f5d568059a80970d22194b165d097a7Benjamin Kramer SV = Builder.CreateShl(SV, ConstantInt::get(SV->getType(), ShAmt)); 10004cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Mask <<= ShAmt; 10014cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } else if (ShAmt < 0 && (unsigned)-ShAmt < DestWidth) { 1002a9390a4d5f5d568059a80970d22194b165d097a7Benjamin Kramer SV = Builder.CreateLShr(SV, ConstantInt::get(SV->getType(), -ShAmt)); 10034cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Mask = Mask.lshr(-ShAmt); 10044cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 10054cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner 10064cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Mask out the bits we are about to insert from the old value, and or 10074cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // in the new bits. 10084cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (SrcWidth != DestWidth) { 10094cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner assert(DestWidth > SrcWidth); 10104cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Old = Builder.CreateAnd(Old, ConstantInt::get(Context, ~Mask), "mask"); 10114cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner SV = Builder.CreateOr(Old, SV, "ins"); 10124cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 10134cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner return SV; 1014b742defa0a8f3e477c3ed641da49aab276937556Bob Wilson} 1015b742defa0a8f3e477c3ed641da49aab276937556Bob Wilson 1016b742defa0a8f3e477c3ed641da49aab276937556Bob Wilson 10174cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner//===----------------------------------------------------------------------===// 10184cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner// SRoA Driver 10194cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner//===----------------------------------------------------------------------===// 1020b742defa0a8f3e477c3ed641da49aab276937556Bob Wilson 1021b742defa0a8f3e477c3ed641da49aab276937556Bob Wilson 10224cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattnerbool SROA::runOnFunction(Function &F) { 10234cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner TD = getAnalysisIfAvailable<TargetData>(); 1024b742defa0a8f3e477c3ed641da49aab276937556Bob Wilson 10254cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner bool Changed = performPromotion(F); 1026b742defa0a8f3e477c3ed641da49aab276937556Bob Wilson 10274cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // FIXME: ScalarRepl currently depends on TargetData more than it 10284cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // theoretically needs to. It should be refactored in order to support 10294cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // target-independent IR. Until this is done, just skip the actual 10304cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // scalar-replacement portion of this pass. 10314cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (!TD) return Changed; 10324cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner 10334cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner while (1) { 10344cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner bool LocalChange = performScalarRepl(F); 10354cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (!LocalChange) break; // No need to repromote if no scalarrepl 10364cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Changed = true; 10374cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner LocalChange = performPromotion(F); 10384cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (!LocalChange) break; // No need to re-scalarrepl if no promotion 10392674089cefe519195e00bdf879647438cfb1cb0fDaniel Dunbar } 10404cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner 10414cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner return Changed; 1042d93afec1dbbb1abb3df55e2e007b5f256d09f84aChris Lattner} 1043d93afec1dbbb1abb3df55e2e007b5f256d09f84aChris Lattner 1044d0f56132cfa6e25fb9692e84ea12444c86b92ae4Chris Lattnernamespace { 1045d0f56132cfa6e25fb9692e84ea12444c86b92ae4Chris Lattnerclass AllocaPromoter : public LoadAndStorePromoter { 1046d0f56132cfa6e25fb9692e84ea12444c86b92ae4Chris Lattner AllocaInst *AI; 1047231a5ab746ca12000aa57208869a98f78781aa6bDevang Patel DIBuilder *DIB; 10484fd3c5957e6a272b60d6446e745136187d07f812Devang Patel SmallVector<DbgDeclareInst *, 4> DDIs; 10494fd3c5957e6a272b60d6446e745136187d07f812Devang Patel SmallVector<DbgValueInst *, 4> DVIs; 1050d0f56132cfa6e25fb9692e84ea12444c86b92ae4Chris Lattnerpublic: 1051c827939046670a9800659b83e2048f1d3a79a531Cameron Zwarich AllocaPromoter(const SmallVectorImpl<Instruction*> &Insts, SSAUpdater &S, 1052231a5ab746ca12000aa57208869a98f78781aa6bDevang Patel DIBuilder *DB) 10534fd3c5957e6a272b60d6446e745136187d07f812Devang Patel : LoadAndStorePromoter(Insts, S), AI(0), DIB(DB) {} 1054a94d6e87c4c49f2e81b01d66d8bfb591277f8f96Nadav Rotem 1055deaf55f69865bbc997a569c2a689ec5b0fbdefefChris Lattner void run(AllocaInst *AI, const SmallVectorImpl<Instruction*> &Insts) { 1056d0f56132cfa6e25fb9692e84ea12444c86b92ae4Chris Lattner // Remember which alloca we're promoting (for isInstInList). 1057d0f56132cfa6e25fb9692e84ea12444c86b92ae4Chris Lattner this->AI = AI; 1058125ef76934f37e3fdc8ce4a2cc238850d06c5912Rafael Espindola if (MDNode *DebugNode = MDNode::getIfExists(AI->getContext(), AI)) { 10594fd3c5957e6a272b60d6446e745136187d07f812Devang Patel for (Value::use_iterator UI = DebugNode->use_begin(), 10604fd3c5957e6a272b60d6446e745136187d07f812Devang Patel E = DebugNode->use_end(); UI != E; ++UI) 10614fd3c5957e6a272b60d6446e745136187d07f812Devang Patel if (DbgDeclareInst *DDI = dyn_cast<DbgDeclareInst>(*UI)) 10624fd3c5957e6a272b60d6446e745136187d07f812Devang Patel DDIs.push_back(DDI); 10634fd3c5957e6a272b60d6446e745136187d07f812Devang Patel else if (DbgValueInst *DVI = dyn_cast<DbgValueInst>(*UI)) 10644fd3c5957e6a272b60d6446e745136187d07f812Devang Patel DVIs.push_back(DVI); 1065125ef76934f37e3fdc8ce4a2cc238850d06c5912Rafael Espindola } 10664fd3c5957e6a272b60d6446e745136187d07f812Devang Patel 1067deaf55f69865bbc997a569c2a689ec5b0fbdefefChris Lattner LoadAndStorePromoter::run(Insts); 1068d0f56132cfa6e25fb9692e84ea12444c86b92ae4Chris Lattner AI->eraseFromParent(); 1069a94d6e87c4c49f2e81b01d66d8bfb591277f8f96Nadav Rotem for (SmallVector<DbgDeclareInst *, 4>::iterator I = DDIs.begin(), 10704fd3c5957e6a272b60d6446e745136187d07f812Devang Patel E = DDIs.end(); I != E; ++I) { 10714fd3c5957e6a272b60d6446e745136187d07f812Devang Patel DbgDeclareInst *DDI = *I; 1072231a5ab746ca12000aa57208869a98f78781aa6bDevang Patel DDI->eraseFromParent(); 10734fd3c5957e6a272b60d6446e745136187d07f812Devang Patel } 1074a94d6e87c4c49f2e81b01d66d8bfb591277f8f96Nadav Rotem for (SmallVector<DbgValueInst *, 4>::iterator I = DVIs.begin(), 10754fd3c5957e6a272b60d6446e745136187d07f812Devang Patel E = DVIs.end(); I != E; ++I) { 10764fd3c5957e6a272b60d6446e745136187d07f812Devang Patel DbgValueInst *DVI = *I; 10774fd3c5957e6a272b60d6446e745136187d07f812Devang Patel DVI->eraseFromParent(); 10784fd3c5957e6a272b60d6446e745136187d07f812Devang Patel } 1079e0a1a5ba91df6817f9ffae7af65ed0bda66f7620Chris Lattner } 1080a94d6e87c4c49f2e81b01d66d8bfb591277f8f96Nadav Rotem 1081d0f56132cfa6e25fb9692e84ea12444c86b92ae4Chris Lattner virtual bool isInstInList(Instruction *I, 1082d0f56132cfa6e25fb9692e84ea12444c86b92ae4Chris Lattner const SmallVectorImpl<Instruction*> &Insts) const { 1083d0f56132cfa6e25fb9692e84ea12444c86b92ae4Chris Lattner if (LoadInst *LI = dyn_cast<LoadInst>(I)) 1084d0f56132cfa6e25fb9692e84ea12444c86b92ae4Chris Lattner return LI->getOperand(0) == AI; 1085d0f56132cfa6e25fb9692e84ea12444c86b92ae4Chris Lattner return cast<StoreInst>(I)->getPointerOperand() == AI; 1086e0a1a5ba91df6817f9ffae7af65ed0bda66f7620Chris Lattner } 1087231a5ab746ca12000aa57208869a98f78781aa6bDevang Patel 10884fd3c5957e6a272b60d6446e745136187d07f812Devang Patel virtual void updateDebugInfo(Instruction *Inst) const { 1089a94d6e87c4c49f2e81b01d66d8bfb591277f8f96Nadav Rotem for (SmallVector<DbgDeclareInst *, 4>::const_iterator I = DDIs.begin(), 10904fd3c5957e6a272b60d6446e745136187d07f812Devang Patel E = DDIs.end(); I != E; ++I) { 10914fd3c5957e6a272b60d6446e745136187d07f812Devang Patel DbgDeclareInst *DDI = *I; 10924fd3c5957e6a272b60d6446e745136187d07f812Devang Patel if (StoreInst *SI = dyn_cast<StoreInst>(Inst)) 10934fd3c5957e6a272b60d6446e745136187d07f812Devang Patel ConvertDebugDeclareToDebugValue(DDI, SI, *DIB); 10944fd3c5957e6a272b60d6446e745136187d07f812Devang Patel else if (LoadInst *LI = dyn_cast<LoadInst>(Inst)) 10954fd3c5957e6a272b60d6446e745136187d07f812Devang Patel ConvertDebugDeclareToDebugValue(DDI, LI, *DIB); 10964fd3c5957e6a272b60d6446e745136187d07f812Devang Patel } 1097a94d6e87c4c49f2e81b01d66d8bfb591277f8f96Nadav Rotem for (SmallVector<DbgValueInst *, 4>::const_iterator I = DVIs.begin(), 10984fd3c5957e6a272b60d6446e745136187d07f812Devang Patel E = DVIs.end(); I != E; ++I) { 10994fd3c5957e6a272b60d6446e745136187d07f812Devang Patel DbgValueInst *DVI = *I; 11006a1c7796d3966851456b835d69909e3df7f5e966Benjamin Kramer Value *Arg = NULL; 11014fd3c5957e6a272b60d6446e745136187d07f812Devang Patel if (StoreInst *SI = dyn_cast<StoreInst>(Inst)) { 11024fd3c5957e6a272b60d6446e745136187d07f812Devang Patel // If an argument is zero extended then use argument directly. The ZExt 11034fd3c5957e6a272b60d6446e745136187d07f812Devang Patel // may be zapped by an optimization pass in future. 11044fd3c5957e6a272b60d6446e745136187d07f812Devang Patel if (ZExtInst *ZExt = dyn_cast<ZExtInst>(SI->getOperand(0))) 11056a1c7796d3966851456b835d69909e3df7f5e966Benjamin Kramer Arg = dyn_cast<Argument>(ZExt->getOperand(0)); 11064fd3c5957e6a272b60d6446e745136187d07f812Devang Patel if (SExtInst *SExt = dyn_cast<SExtInst>(SI->getOperand(0))) 11076a1c7796d3966851456b835d69909e3df7f5e966Benjamin Kramer Arg = dyn_cast<Argument>(SExt->getOperand(0)); 11086a1c7796d3966851456b835d69909e3df7f5e966Benjamin Kramer if (!Arg) 11096a1c7796d3966851456b835d69909e3df7f5e966Benjamin Kramer Arg = SI->getOperand(0); 11104fd3c5957e6a272b60d6446e745136187d07f812Devang Patel } else if (LoadInst *LI = dyn_cast<LoadInst>(Inst)) { 11116a1c7796d3966851456b835d69909e3df7f5e966Benjamin Kramer Arg = LI->getOperand(0); 11126a1c7796d3966851456b835d69909e3df7f5e966Benjamin Kramer } else { 11136a1c7796d3966851456b835d69909e3df7f5e966Benjamin Kramer continue; 11144fd3c5957e6a272b60d6446e745136187d07f812Devang Patel } 11156a1c7796d3966851456b835d69909e3df7f5e966Benjamin Kramer Instruction *DbgVal = 11166a1c7796d3966851456b835d69909e3df7f5e966Benjamin Kramer DIB->insertDbgValueIntrinsic(Arg, 0, DIVariable(DVI->getVariable()), 11176a1c7796d3966851456b835d69909e3df7f5e966Benjamin Kramer Inst); 11186a1c7796d3966851456b835d69909e3df7f5e966Benjamin Kramer DbgVal->setDebugLoc(DVI->getDebugLoc()); 11194fd3c5957e6a272b60d6446e745136187d07f812Devang Patel } 1120231a5ab746ca12000aa57208869a98f78781aa6bDevang Patel } 1121d0f56132cfa6e25fb9692e84ea12444c86b92ae4Chris Lattner}; 1122d0f56132cfa6e25fb9692e84ea12444c86b92ae4Chris Lattner} // end anon namespace 112378c50b8cd68d266d4ed6f8eca443cf8142a01204Bob Wilson 1124c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner/// isSafeSelectToSpeculate - Select instructions that use an alloca and are 1125c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner/// subsequently loaded can be rewritten to load both input pointers and then 1126c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner/// select between the result, allowing the load of the alloca to be promoted. 1127c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner/// From this: 1128c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner/// %P2 = select i1 %cond, i32* %Alloca, i32* %Other 1129c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner/// %V = load i32* %P2 1130c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner/// to: 1131c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner/// %V1 = load i32* %Alloca -> will be mem2reg'd 1132c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner/// %V2 = load i32* %Other 1133e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner/// %V = select i1 %cond, i32 %V1, i32 %V2 1134c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner/// 1135c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner/// We can do this to a select if its only uses are loads and if the operand to 1136c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner/// the select can be loaded unconditionally. 1137c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattnerstatic bool isSafeSelectToSpeculate(SelectInst *SI, const TargetData *TD) { 1138c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner bool TDerefable = SI->getTrueValue()->isDereferenceablePointer(); 1139c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner bool FDerefable = SI->getFalseValue()->isDereferenceablePointer(); 1140a94d6e87c4c49f2e81b01d66d8bfb591277f8f96Nadav Rotem 1141c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner for (Value::use_iterator UI = SI->use_begin(), UE = SI->use_end(); 1142c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner UI != UE; ++UI) { 1143c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner LoadInst *LI = dyn_cast<LoadInst>(*UI); 11442bc3d52b9ab422ee9f7e42a1a4e3b818e623a5f7Eli Friedman if (LI == 0 || !LI->isSimple()) return false; 1145a94d6e87c4c49f2e81b01d66d8bfb591277f8f96Nadav Rotem 1146e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner // Both operands to the select need to be dereferencable, either absolutely 1147c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner // (e.g. allocas) or at this point because we can see other accesses to it. 1148c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner if (!TDerefable && !isSafeToLoadUnconditionally(SI->getTrueValue(), LI, 1149c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner LI->getAlignment(), TD)) 1150c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner return false; 1151c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner if (!FDerefable && !isSafeToLoadUnconditionally(SI->getFalseValue(), LI, 1152c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner LI->getAlignment(), TD)) 1153c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner return false; 1154c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner } 1155a94d6e87c4c49f2e81b01d66d8bfb591277f8f96Nadav Rotem 1156c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner return true; 1157c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner} 1158c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner 1159e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner/// isSafePHIToSpeculate - PHI instructions that use an alloca and are 1160e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner/// subsequently loaded can be rewritten to load both input pointers in the pred 1161e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner/// blocks and then PHI the results, allowing the load of the alloca to be 1162e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner/// promoted. 1163e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner/// From this: 1164e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner/// %P2 = phi [i32* %Alloca, i32* %Other] 1165e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner/// %V = load i32* %P2 1166e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner/// to: 1167e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner/// %V1 = load i32* %Alloca -> will be mem2reg'd 1168e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner/// ... 1169e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner/// %V2 = load i32* %Other 1170e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner/// ... 1171e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner/// %V = phi [i32 %V1, i32 %V2] 1172e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner/// 1173e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner/// We can do this to a select if its only uses are loads and if the operand to 1174e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner/// the select can be loaded unconditionally. 1175e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattnerstatic bool isSafePHIToSpeculate(PHINode *PN, const TargetData *TD) { 1176e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner // For now, we can only do this promotion if the load is in the same block as 1177e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner // the PHI, and if there are no stores between the phi and load. 1178e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner // TODO: Allow recursive phi users. 1179e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner // TODO: Allow stores. 1180e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner BasicBlock *BB = PN->getParent(); 1181e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner unsigned MaxAlign = 0; 1182e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner for (Value::use_iterator UI = PN->use_begin(), UE = PN->use_end(); 1183e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner UI != UE; ++UI) { 1184e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner LoadInst *LI = dyn_cast<LoadInst>(*UI); 11852bc3d52b9ab422ee9f7e42a1a4e3b818e623a5f7Eli Friedman if (LI == 0 || !LI->isSimple()) return false; 1186a94d6e87c4c49f2e81b01d66d8bfb591277f8f96Nadav Rotem 1187e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner // For now we only allow loads in the same block as the PHI. This is a 1188e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner // common case that happens when instcombine merges two loads through a PHI. 1189e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner if (LI->getParent() != BB) return false; 1190a94d6e87c4c49f2e81b01d66d8bfb591277f8f96Nadav Rotem 1191e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner // Ensure that there are no instructions between the PHI and the load that 1192e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner // could store. 1193e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner for (BasicBlock::iterator BBI = PN; &*BBI != LI; ++BBI) 1194e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner if (BBI->mayWriteToMemory()) 1195e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner return false; 1196a94d6e87c4c49f2e81b01d66d8bfb591277f8f96Nadav Rotem 1197e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner MaxAlign = std::max(MaxAlign, LI->getAlignment()); 1198e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner } 1199a94d6e87c4c49f2e81b01d66d8bfb591277f8f96Nadav Rotem 1200e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner // Okay, we know that we have one or more loads in the same block as the PHI. 1201e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner // We can transform this if it is safe to push the loads into the predecessor 1202e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner // blocks. The only thing to watch out for is that we can't put a possibly 1203e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner // trapping load in the predecessor if it is a critical edge. 1204e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i) { 1205e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner BasicBlock *Pred = PN->getIncomingBlock(i); 1206d102a03b36fb522899cefc31a396c9793b929cf6Eli Friedman Value *InVal = PN->getIncomingValue(i); 1207d102a03b36fb522899cefc31a396c9793b929cf6Eli Friedman 1208d102a03b36fb522899cefc31a396c9793b929cf6Eli Friedman // If the terminator of the predecessor has side-effects (an invoke), 1209d102a03b36fb522899cefc31a396c9793b929cf6Eli Friedman // there is no safe place to put a load in the predecessor. 1210d102a03b36fb522899cefc31a396c9793b929cf6Eli Friedman if (Pred->getTerminator()->mayHaveSideEffects()) 1211d102a03b36fb522899cefc31a396c9793b929cf6Eli Friedman return false; 1212d102a03b36fb522899cefc31a396c9793b929cf6Eli Friedman 1213d102a03b36fb522899cefc31a396c9793b929cf6Eli Friedman // If the value is produced by the terminator of the predecessor 1214d102a03b36fb522899cefc31a396c9793b929cf6Eli Friedman // (an invoke), there is no valid place to put a load in the predecessor. 1215d102a03b36fb522899cefc31a396c9793b929cf6Eli Friedman if (Pred->getTerminator() == InVal) 1216d102a03b36fb522899cefc31a396c9793b929cf6Eli Friedman return false; 1217e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner 1218e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner // If the predecessor has a single successor, then the edge isn't critical. 1219e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner if (Pred->getTerminator()->getNumSuccessors() == 1) 1220e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner continue; 1221e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner 1222e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner // If this pointer is always safe to load, or if we can prove that there is 1223e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner // already a load in the block, then we can move the load to the pred block. 1224e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner if (InVal->isDereferenceablePointer() || 1225e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner isSafeToLoadUnconditionally(InVal, Pred->getTerminator(), MaxAlign, TD)) 1226e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner continue; 1227a94d6e87c4c49f2e81b01d66d8bfb591277f8f96Nadav Rotem 1228e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner return false; 1229e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner } 1230a94d6e87c4c49f2e81b01d66d8bfb591277f8f96Nadav Rotem 1231e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner return true; 1232e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner} 1233e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner 1234c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner 1235c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner/// tryToMakeAllocaBePromotable - This returns true if the alloca only has 1236c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner/// direct (non-volatile) loads and stores to it. If the alloca is close but 1237c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner/// not quite there, this will transform the code to allow promotion. As such, 1238c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner/// it is a non-pure predicate. 1239c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattnerstatic bool tryToMakeAllocaBePromotable(AllocaInst *AI, const TargetData *TD) { 1240c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner SetVector<Instruction*, SmallVector<Instruction*, 4>, 1241c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner SmallPtrSet<Instruction*, 4> > InstsToRewrite; 1242a94d6e87c4c49f2e81b01d66d8bfb591277f8f96Nadav Rotem 1243c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner for (Value::use_iterator UI = AI->use_begin(), UE = AI->use_end(); 1244c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner UI != UE; ++UI) { 1245c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner User *U = *UI; 1246c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner if (LoadInst *LI = dyn_cast<LoadInst>(U)) { 12472bc3d52b9ab422ee9f7e42a1a4e3b818e623a5f7Eli Friedman if (!LI->isSimple()) 1248c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner return false; 1249c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner continue; 1250c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner } 1251a94d6e87c4c49f2e81b01d66d8bfb591277f8f96Nadav Rotem 1252c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner if (StoreInst *SI = dyn_cast<StoreInst>(U)) { 12532bc3d52b9ab422ee9f7e42a1a4e3b818e623a5f7Eli Friedman if (SI->getOperand(0) == AI || !SI->isSimple()) 1254c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner return false; // Don't allow a store OF the AI, only INTO the AI. 1255c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner continue; 1256c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner } 1257c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner 1258c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner if (SelectInst *SI = dyn_cast<SelectInst>(U)) { 1259c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner // If the condition being selected on is a constant, fold the select, yes 1260c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner // this does (rarely) happen early on. 1261c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner if (ConstantInt *CI = dyn_cast<ConstantInt>(SI->getCondition())) { 1262c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner Value *Result = SI->getOperand(1+CI->isZero()); 1263c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner SI->replaceAllUsesWith(Result); 1264c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner SI->eraseFromParent(); 1265a94d6e87c4c49f2e81b01d66d8bfb591277f8f96Nadav Rotem 1266c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner // This is very rare and we just scrambled the use list of AI, start 1267c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner // over completely. 1268c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner return tryToMakeAllocaBePromotable(AI, TD); 1269c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner } 1270c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner 1271c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner // If it is safe to turn "load (select c, AI, ptr)" into a select of two 1272c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner // loads, then we can transform this by rewriting the select. 1273c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner if (!isSafeSelectToSpeculate(SI, TD)) 1274c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner return false; 1275a94d6e87c4c49f2e81b01d66d8bfb591277f8f96Nadav Rotem 1276c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner InstsToRewrite.insert(SI); 1277c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner continue; 1278c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner } 1279a94d6e87c4c49f2e81b01d66d8bfb591277f8f96Nadav Rotem 1280e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner if (PHINode *PN = dyn_cast<PHINode>(U)) { 1281e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner if (PN->use_empty()) { // Dead PHIs can be stripped. 1282e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner InstsToRewrite.insert(PN); 1283e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner continue; 1284e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner } 1285a94d6e87c4c49f2e81b01d66d8bfb591277f8f96Nadav Rotem 1286e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner // If it is safe to turn "load (phi [AI, ptr, ...])" into a PHI of loads 1287e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner // in the pred blocks, then we can transform this by rewriting the PHI. 1288e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner if (!isSafePHIToSpeculate(PN, TD)) 1289e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner return false; 1290a94d6e87c4c49f2e81b01d66d8bfb591277f8f96Nadav Rotem 1291e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner InstsToRewrite.insert(PN); 1292e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner continue; 1293e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner } 1294a94d6e87c4c49f2e81b01d66d8bfb591277f8f96Nadav Rotem 12955a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky if (BitCastInst *BCI = dyn_cast<BitCastInst>(U)) { 12965a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky if (onlyUsedByLifetimeMarkers(BCI)) { 12975a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky InstsToRewrite.insert(BCI); 12985a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky continue; 12995a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky } 13005a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky } 1301a94d6e87c4c49f2e81b01d66d8bfb591277f8f96Nadav Rotem 1302c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner return false; 1303c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner } 1304c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner 1305c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner // If there are no instructions to rewrite, then all uses are load/stores and 1306c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner // we're done! 1307c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner if (InstsToRewrite.empty()) 1308c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner return true; 1309a94d6e87c4c49f2e81b01d66d8bfb591277f8f96Nadav Rotem 1310c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner // If we have instructions that need to be rewritten for this to be promotable 1311c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner // take care of it now. 1312c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner for (unsigned i = 0, e = InstsToRewrite.size(); i != e; ++i) { 13135a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky if (BitCastInst *BCI = dyn_cast<BitCastInst>(InstsToRewrite[i])) { 13145a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky // This could only be a bitcast used by nothing but lifetime intrinsics. 13155a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky for (BitCastInst::use_iterator I = BCI->use_begin(), E = BCI->use_end(); 13165a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky I != E;) { 13175a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky Use &U = I.getUse(); 13185a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky ++I; 13195a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky cast<Instruction>(U.getUser())->eraseFromParent(); 13205a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky } 13215a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky BCI->eraseFromParent(); 13225a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky continue; 13235a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky } 13245a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky 1325e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner if (SelectInst *SI = dyn_cast<SelectInst>(InstsToRewrite[i])) { 1326e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner // Selects in InstsToRewrite only have load uses. Rewrite each as two 1327e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner // loads with a new select. 1328e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner while (!SI->use_empty()) { 1329e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner LoadInst *LI = cast<LoadInst>(SI->use_back()); 1330a94d6e87c4c49f2e81b01d66d8bfb591277f8f96Nadav Rotem 1331e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner IRBuilder<> Builder(LI); 1332a94d6e87c4c49f2e81b01d66d8bfb591277f8f96Nadav Rotem LoadInst *TrueLoad = 1333e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner Builder.CreateLoad(SI->getTrueValue(), LI->getName()+".t"); 1334a94d6e87c4c49f2e81b01d66d8bfb591277f8f96Nadav Rotem LoadInst *FalseLoad = 1335394d1f1948c1b5c9e902059104b08a4837dfbbeeNick Lewycky Builder.CreateLoad(SI->getFalseValue(), LI->getName()+".f"); 1336a94d6e87c4c49f2e81b01d66d8bfb591277f8f96Nadav Rotem 1337e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner // Transfer alignment and TBAA info if present. 1338e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner TrueLoad->setAlignment(LI->getAlignment()); 1339e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner FalseLoad->setAlignment(LI->getAlignment()); 1340e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner if (MDNode *Tag = LI->getMetadata(LLVMContext::MD_tbaa)) { 1341e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner TrueLoad->setMetadata(LLVMContext::MD_tbaa, Tag); 1342e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner FalseLoad->setMetadata(LLVMContext::MD_tbaa, Tag); 1343e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner } 1344a94d6e87c4c49f2e81b01d66d8bfb591277f8f96Nadav Rotem 1345e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner Value *V = Builder.CreateSelect(SI->getCondition(), TrueLoad, FalseLoad); 1346e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner V->takeName(LI); 1347e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner LI->replaceAllUsesWith(V); 1348e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner LI->eraseFromParent(); 1349c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner } 1350a94d6e87c4c49f2e81b01d66d8bfb591277f8f96Nadav Rotem 1351e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner // Now that all the loads are gone, the select is gone too. 1352e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner SI->eraseFromParent(); 1353e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner continue; 1354e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner } 1355a94d6e87c4c49f2e81b01d66d8bfb591277f8f96Nadav Rotem 1356e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner // Otherwise, we have a PHI node which allows us to push the loads into the 1357e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner // predecessors. 1358e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner PHINode *PN = cast<PHINode>(InstsToRewrite[i]); 1359e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner if (PN->use_empty()) { 1360e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner PN->eraseFromParent(); 1361e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner continue; 1362e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner } 1363a94d6e87c4c49f2e81b01d66d8bfb591277f8f96Nadav Rotem 1364db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *LoadTy = cast<PointerType>(PN->getType())->getElementType(); 13653ecfc861b4365f341c5c969b40e1afccde676e6fJay Foad PHINode *NewPN = PHINode::Create(LoadTy, PN->getNumIncomingValues(), 13663ecfc861b4365f341c5c969b40e1afccde676e6fJay Foad PN->getName()+".ld", PN); 1367e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner 1368e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner // Get the TBAA tag and alignment to use from one of the loads. It doesn't 1369e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner // matter which one we get and if any differ, it doesn't matter. 1370e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner LoadInst *SomeLoad = cast<LoadInst>(PN->use_back()); 1371e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner MDNode *TBAATag = SomeLoad->getMetadata(LLVMContext::MD_tbaa); 1372e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner unsigned Align = SomeLoad->getAlignment(); 1373a94d6e87c4c49f2e81b01d66d8bfb591277f8f96Nadav Rotem 1374e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner // Rewrite all loads of the PN to use the new PHI. 1375e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner while (!PN->use_empty()) { 1376e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner LoadInst *LI = cast<LoadInst>(PN->use_back()); 1377e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner LI->replaceAllUsesWith(NewPN); 1378c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner LI->eraseFromParent(); 1379c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner } 1380a94d6e87c4c49f2e81b01d66d8bfb591277f8f96Nadav Rotem 1381e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner // Inject loads into all of the pred blocks. Keep track of which blocks we 1382e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner // insert them into in case we have multiple edges from the same block. 1383e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner DenseMap<BasicBlock*, LoadInst*> InsertedLoads; 1384a94d6e87c4c49f2e81b01d66d8bfb591277f8f96Nadav Rotem 1385e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i) { 1386e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner BasicBlock *Pred = PN->getIncomingBlock(i); 1387e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner LoadInst *&Load = InsertedLoads[Pred]; 1388e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner if (Load == 0) { 1389e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner Load = new LoadInst(PN->getIncomingValue(i), 1390e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner PN->getName() + "." + Pred->getName(), 1391e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner Pred->getTerminator()); 1392e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner Load->setAlignment(Align); 1393e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner if (TBAATag) Load->setMetadata(LLVMContext::MD_tbaa, TBAATag); 1394e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner } 1395a94d6e87c4c49f2e81b01d66d8bfb591277f8f96Nadav Rotem 1396e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner NewPN->addIncoming(Load, Pred); 1397e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner } 1398a94d6e87c4c49f2e81b01d66d8bfb591277f8f96Nadav Rotem 1399e3357863aaabe297c5fa819d083f2308ebb5f2c2Chris Lattner PN->eraseFromParent(); 1400c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner } 1401a94d6e87c4c49f2e81b01d66d8bfb591277f8f96Nadav Rotem 1402c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner ++NumAdjusted; 1403c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner return true; 1404c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner} 1405c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner 14064cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattnerbool SROA::performPromotion(Function &F) { 14074cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner std::vector<AllocaInst*> Allocas; 1408e0a1a5ba91df6817f9ffae7af65ed0bda66f7620Chris Lattner DominatorTree *DT = 0; 1409b1686c32fc694636cbf15a59b23b2a741b65ecf4Cameron Zwarich if (HasDomTree) 1410e0a1a5ba91df6817f9ffae7af65ed0bda66f7620Chris Lattner DT = &getAnalysis<DominatorTree>(); 1411b742defa0a8f3e477c3ed641da49aab276937556Bob Wilson 14124cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner BasicBlock &BB = F.getEntryBlock(); // Get the entry node for the function 1413231a5ab746ca12000aa57208869a98f78781aa6bDevang Patel DIBuilder DIB(*F.getParent()); 14144cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner bool Changed = false; 1415deaf55f69865bbc997a569c2a689ec5b0fbdefefChris Lattner SmallVector<Instruction*, 64> Insts; 14164cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner while (1) { 14174cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Allocas.clear(); 14184cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner 14194cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Find allocas that are safe to promote, by looking at all instructions in 14204cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // the entry node 14214cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner for (BasicBlock::iterator I = BB.begin(), E = --BB.end(); I != E; ++I) 14224cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (AllocaInst *AI = dyn_cast<AllocaInst>(I)) // Is it an alloca? 1423c87c50a39c1bc27437352feee0f6aba2d50fa1b5Chris Lattner if (tryToMakeAllocaBePromotable(AI, TD)) 14244cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Allocas.push_back(AI); 14254cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner 14264cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (Allocas.empty()) break; 14274cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner 1428b1686c32fc694636cbf15a59b23b2a741b65ecf4Cameron Zwarich if (HasDomTree) 1429419e8a62997987e0509efe721c1ea81ac29f09f3Cameron Zwarich PromoteMemToReg(Allocas, *DT); 1430e0a1a5ba91df6817f9ffae7af65ed0bda66f7620Chris Lattner else { 1431e0a1a5ba91df6817f9ffae7af65ed0bda66f7620Chris Lattner SSAUpdater SSA; 1432deaf55f69865bbc997a569c2a689ec5b0fbdefefChris Lattner for (unsigned i = 0, e = Allocas.size(); i != e; ++i) { 1433deaf55f69865bbc997a569c2a689ec5b0fbdefefChris Lattner AllocaInst *AI = Allocas[i]; 1434a94d6e87c4c49f2e81b01d66d8bfb591277f8f96Nadav Rotem 1435deaf55f69865bbc997a569c2a689ec5b0fbdefefChris Lattner // Build list of instructions to promote. 1436deaf55f69865bbc997a569c2a689ec5b0fbdefefChris Lattner for (Value::use_iterator UI = AI->use_begin(), E = AI->use_end(); 1437deaf55f69865bbc997a569c2a689ec5b0fbdefefChris Lattner UI != E; ++UI) 1438deaf55f69865bbc997a569c2a689ec5b0fbdefefChris Lattner Insts.push_back(cast<Instruction>(*UI)); 1439231a5ab746ca12000aa57208869a98f78781aa6bDevang Patel AllocaPromoter(Insts, SSA, &DIB).run(AI, Insts); 1440deaf55f69865bbc997a569c2a689ec5b0fbdefefChris Lattner Insts.clear(); 1441deaf55f69865bbc997a569c2a689ec5b0fbdefefChris Lattner } 1442e0a1a5ba91df6817f9ffae7af65ed0bda66f7620Chris Lattner } 14434cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner NumPromoted += Allocas.size(); 14444cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Changed = true; 14454cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 14464cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner 14474cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner return Changed; 14484cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner} 14494cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner 14504cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner 14514cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// ShouldAttemptScalarRepl - Decide if an alloca is a good candidate for 14524cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// SROA. It must be a struct or array type with a small number of elements. 14532114a8aaba99e901735e69818bb789757ed05cfdNadav Rotembool SROA::ShouldAttemptScalarRepl(AllocaInst *AI) { 1454db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *T = AI->getAllocatedType(); 14552114a8aaba99e901735e69818bb789757ed05cfdNadav Rotem // Do not promote any struct that has too many members. 1456db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner if (StructType *ST = dyn_cast<StructType>(T)) 14572114a8aaba99e901735e69818bb789757ed05cfdNadav Rotem return ST->getNumElements() <= StructMemberThreshold; 14582114a8aaba99e901735e69818bb789757ed05cfdNadav Rotem // Do not promote any array that has too many elements. 1459db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner if (ArrayType *AT = dyn_cast<ArrayType>(T)) 14602114a8aaba99e901735e69818bb789757ed05cfdNadav Rotem return AT->getNumElements() <= ArrayElementThreshold; 14614cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner return false; 14624cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner} 14634cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner 14644cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner// performScalarRepl - This algorithm is a simple worklist driven algorithm, 14659174d5c7383490d79b6a483d73cded54e32275d6Nick Lewycky// which runs on all of the alloca instructions in the function, removing them 14669174d5c7383490d79b6a483d73cded54e32275d6Nick Lewycky// if they are only used by getelementptr instructions. 14674cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner// 14684cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattnerbool SROA::performScalarRepl(Function &F) { 14694cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner std::vector<AllocaInst*> WorkList; 14704cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner 14714cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Scan the entry basic block, adding allocas to the worklist. 14724cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner BasicBlock &BB = F.getEntryBlock(); 14734cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner for (BasicBlock::iterator I = BB.begin(), E = BB.end(); I != E; ++I) 14744cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (AllocaInst *A = dyn_cast<AllocaInst>(I)) 14754cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner WorkList.push_back(A); 14764cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner 14774cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Process the worklist 14784cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner bool Changed = false; 14794cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner while (!WorkList.empty()) { 14804cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner AllocaInst *AI = WorkList.back(); 14814cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner WorkList.pop_back(); 14826974302e3ff20746268721959efed807c7711bfcBob Wilson 14834cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Handle dead allocas trivially. These can be formed by SROA'ing arrays 14844cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // with unused elements. 14854cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (AI->use_empty()) { 14864cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner AI->eraseFromParent(); 14874cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Changed = true; 14884cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner continue; 1489d93afec1dbbb1abb3df55e2e007b5f256d09f84aChris Lattner } 14904cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner 14914cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // If this alloca is impossible for us to promote, reject it early. 14924cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (AI->isArrayAllocation() || !AI->getAllocatedType()->isSized()) 14934cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner continue; 14946974302e3ff20746268721959efed807c7711bfcBob Wilson 14954cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Check to see if we can perform the core SROA transformation. We cannot 14964cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // transform the allocation instruction if it is an array allocation 14974cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // (allocations OF arrays are ok though), and an allocation of a scalar 14984cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // value cannot be decomposed at all. 14994cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner uint64_t AllocaSize = TD->getTypeAllocSize(AI->getAllocatedType()); 150044118f0e25c25fedda1ccdd6a72f072c0b5c96e7Dan Gohman 15014cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Do not promote [0 x %struct]. 15024cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (AllocaSize == 0) continue; 15036974302e3ff20746268721959efed807c7711bfcBob Wilson 15044cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Do not promote any struct whose size is too big. 15054cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (AllocaSize > SRThreshold) continue; 15066974302e3ff20746268721959efed807c7711bfcBob Wilson 15074cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // If the alloca looks like a good candidate for scalar replacement, and if 15084cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // all its users can be transformed, then split up the aggregate into its 15094cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // separate elements. 15104cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (ShouldAttemptScalarRepl(AI) && isSafeAllocaToScalarRepl(AI)) { 15114cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner DoScalarReplacement(AI, WorkList); 15124cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Changed = true; 15134cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner continue; 151420adc9dc4650313f017b27d9818eb2176238113dMon P Wang } 15154cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner 15164cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // If we can turn this aggregate value (potentially with casts) into a 15174cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // simple scalar value that can be mem2reg'd into a register value. 15184cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // IsNotTrivial tracks whether this is something that mem2reg could have 15194cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // promoted itself. If so, we don't want to transform it needlessly. Note 15204cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // that we can't just check based on the type: the alloca may be of an i32 15214cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // but that has pointer arithmetic to set byte 3 of it or something. 15222114a8aaba99e901735e69818bb789757ed05cfdNadav Rotem if (AllocaInst *NewAI = ConvertToScalarInfo( 15232114a8aaba99e901735e69818bb789757ed05cfdNadav Rotem (unsigned)AllocaSize, *TD, ScalarLoadThreshold).TryConvert(AI)) { 15244cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner NewAI->takeName(AI); 15254cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner AI->eraseFromParent(); 15264cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner ++NumConverted; 15274cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Changed = true; 15284cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner continue; 15296974302e3ff20746268721959efed807c7711bfcBob Wilson } 15306974302e3ff20746268721959efed807c7711bfcBob Wilson 15314cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Otherwise, couldn't process this alloca. 1532372dda8881c7a32a6f5ce0f76a713e3a9ef46ea1Chris Lattner } 15334cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner 15344cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner return Changed; 1535372dda8881c7a32a6f5ce0f76a713e3a9ef46ea1Chris Lattner} 1536d2fa781169175b827e50953a1d0b7edc6b0c4801Chris Lattner 15374cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// DoScalarReplacement - This alloca satisfied the isSafeAllocaToScalarRepl 15384cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// predicate, do SROA now. 15396974302e3ff20746268721959efed807c7711bfcBob Wilsonvoid SROA::DoScalarReplacement(AllocaInst *AI, 15404cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner std::vector<AllocaInst*> &WorkList) { 15414cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner DEBUG(dbgs() << "Found inst to SROA: " << *AI << '\n'); 15424cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner SmallVector<AllocaInst*, 32> ElementAllocas; 1543db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner if (StructType *ST = dyn_cast<StructType>(AI->getAllocatedType())) { 15444cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner ElementAllocas.reserve(ST->getNumContainedTypes()); 15454cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner for (unsigned i = 0, e = ST->getNumContainedTypes(); i != e; ++i) { 15466974302e3ff20746268721959efed807c7711bfcBob Wilson AllocaInst *NA = new AllocaInst(ST->getContainedType(i), 0, 15474cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner AI->getAlignment(), 15484cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner AI->getName() + "." + Twine(i), AI); 15494cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner ElementAllocas.push_back(NA); 15504cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner WorkList.push_back(NA); // Add to worklist for recursive processing 15514cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 15524cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } else { 1553db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner ArrayType *AT = cast<ArrayType>(AI->getAllocatedType()); 15544cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner ElementAllocas.reserve(AT->getNumElements()); 1555db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *ElTy = AT->getElementType(); 15564cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner for (unsigned i = 0, e = AT->getNumElements(); i != e; ++i) { 15574cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner AllocaInst *NA = new AllocaInst(ElTy, 0, AI->getAlignment(), 15584cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner AI->getName() + "." + Twine(i), AI); 15594cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner ElementAllocas.push_back(NA); 15604cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner WorkList.push_back(NA); // Add to worklist for recursive processing 15614cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 15624cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 1563d2fa781169175b827e50953a1d0b7edc6b0c4801Chris Lattner 15644cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Now that we have created the new alloca instructions, rewrite all the 15654cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // uses of the old alloca. 15664cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner RewriteForScalarRepl(AI, AI, 0, ElementAllocas); 1567d2fa781169175b827e50953a1d0b7edc6b0c4801Chris Lattner 15684cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Now erase any instructions that were made dead while rewriting the alloca. 15694cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner DeleteDeadInstructions(); 15704cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner AI->eraseFromParent(); 15714cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner 1572fe60104ac97f3a8736dcfbfdf9547c7b7cc7b951Dan Gohman ++NumReplaced; 15734cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner} 15744cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner 15754cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// DeleteDeadInstructions - Erase instructions on the DeadInstrs list, 15764cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// recursively including all their operands that become trivially dead. 15774cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattnervoid SROA::DeleteDeadInstructions() { 15784cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner while (!DeadInsts.empty()) { 15794cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Instruction *I = cast<Instruction>(DeadInsts.pop_back_val()); 15804cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner 15814cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner for (User::op_iterator OI = I->op_begin(), E = I->op_end(); OI != E; ++OI) 15824cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (Instruction *U = dyn_cast<Instruction>(*OI)) { 15834cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Zero out the operand and see if it becomes trivially dead. 15844cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // (But, don't add allocas to the dead instruction list -- they are 15854cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // already on the worklist and will be deleted separately.) 15864cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner *OI = 0; 15874cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (isInstructionTriviallyDead(U) && !isa<AllocaInst>(U)) 15884cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner DeadInsts.push_back(U); 1589d2fa781169175b827e50953a1d0b7edc6b0c4801Chris Lattner } 1590d2fa781169175b827e50953a1d0b7edc6b0c4801Chris Lattner 15914cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner I->eraseFromParent(); 15924cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 15934cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner} 15946974302e3ff20746268721959efed807c7711bfcBob Wilson 15954cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// isSafeForScalarRepl - Check if instruction I is a safe use with regard to 15964cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// performing scalar replacement of alloca AI. The results are flagged in 15974cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// the Info parameter. Offset indicates the position within AI that is 15984cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// referenced by this instruction. 15996c95d24927b11fb76bc3e76ebe6a8198d74fc178Chris Lattnervoid SROA::isSafeForScalarRepl(Instruction *I, uint64_t Offset, 16004cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner AllocaInfo &Info) { 16014cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner for (Value::use_iterator UI = I->use_begin(), E = I->use_end(); UI!=E; ++UI) { 16024cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Instruction *User = cast<Instruction>(*UI); 16034cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner 16044cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (BitCastInst *BC = dyn_cast<BitCastInst>(User)) { 16056c95d24927b11fb76bc3e76ebe6a8198d74fc178Chris Lattner isSafeForScalarRepl(BC, Offset, Info); 16064cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } else if (GetElementPtrInst *GEPI = dyn_cast<GetElementPtrInst>(User)) { 16074cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner uint64_t GEPOffset = Offset; 16086c95d24927b11fb76bc3e76ebe6a8198d74fc178Chris Lattner isSafeGEP(GEPI, GEPOffset, Info); 16094cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (!Info.isUnsafe) 16106c95d24927b11fb76bc3e76ebe6a8198d74fc178Chris Lattner isSafeForScalarRepl(GEPI, GEPOffset, Info); 161119101c7585c191376d898e3e66e35acd9bd777c2Gabor Greif } else if (MemIntrinsic *MI = dyn_cast<MemIntrinsic>(User)) { 16124cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner ConstantInt *Length = dyn_cast<ConstantInt>(MI->getLength()); 1613d01a0da090407762fe3b770d84f049d72d06467eChris Lattner if (Length == 0) 1614d01a0da090407762fe3b770d84f049d72d06467eChris Lattner return MarkUnsafe(Info, User); 16157e2fa3142aca46d9435a5804932ef76123c0cf71Aaron Ballman if (Length->isNegative()) 16167e2fa3142aca46d9435a5804932ef76123c0cf71Aaron Ballman return MarkUnsafe(Info, User); 16177e2fa3142aca46d9435a5804932ef76123c0cf71Aaron Ballman 16186c95d24927b11fb76bc3e76ebe6a8198d74fc178Chris Lattner isSafeMemAccess(Offset, Length->getZExtValue(), 0, 1619145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner UI.getOperandNo() == 0, Info, MI, 1620145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner true /*AllowWholeAccess*/); 16214cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } else if (LoadInst *LI = dyn_cast<LoadInst>(User)) { 16222bc3d52b9ab422ee9f7e42a1a4e3b818e623a5f7Eli Friedman if (!LI->isSimple()) 1623d01a0da090407762fe3b770d84f049d72d06467eChris Lattner return MarkUnsafe(Info, User); 1624db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *LIType = LI->getType(); 16256c95d24927b11fb76bc3e76ebe6a8198d74fc178Chris Lattner isSafeMemAccess(Offset, TD->getTypeAllocSize(LIType), 1626145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner LIType, false, Info, LI, true /*AllowWholeAccess*/); 1627d01a0da090407762fe3b770d84f049d72d06467eChris Lattner Info.hasALoadOrStore = true; 1628a94d6e87c4c49f2e81b01d66d8bfb591277f8f96Nadav Rotem 16294cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } else if (StoreInst *SI = dyn_cast<StoreInst>(User)) { 16304cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Store is ok if storing INTO the pointer, not storing the pointer 16312bc3d52b9ab422ee9f7e42a1a4e3b818e623a5f7Eli Friedman if (!SI->isSimple() || SI->getOperand(0) == I) 1632d01a0da090407762fe3b770d84f049d72d06467eChris Lattner return MarkUnsafe(Info, User); 1633a94d6e87c4c49f2e81b01d66d8bfb591277f8f96Nadav Rotem 1634db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *SIType = SI->getOperand(0)->getType(); 16356c95d24927b11fb76bc3e76ebe6a8198d74fc178Chris Lattner isSafeMemAccess(Offset, TD->getTypeAllocSize(SIType), 1636145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner SIType, true, Info, SI, true /*AllowWholeAccess*/); 1637145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner Info.hasALoadOrStore = true; 16385a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky } else if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(User)) { 16395a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky if (II->getIntrinsicID() != Intrinsic::lifetime_start && 16405a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky II->getIntrinsicID() != Intrinsic::lifetime_end) 16415a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky return MarkUnsafe(Info, User); 1642145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner } else if (isa<PHINode>(User) || isa<SelectInst>(User)) { 1643145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner isSafePHISelectUseForScalarRepl(User, Offset, Info); 1644145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner } else { 1645145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner return MarkUnsafe(Info, User); 1646145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner } 1647145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner if (Info.isUnsafe) return; 1648145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner } 1649145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner} 1650a94d6e87c4c49f2e81b01d66d8bfb591277f8f96Nadav Rotem 1651145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner 1652145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner/// isSafePHIUseForScalarRepl - If we see a PHI node or select using a pointer 1653145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner/// derived from the alloca, we can often still split the alloca into elements. 1654145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner/// This is useful if we have a large alloca where one element is phi'd 1655145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner/// together somewhere: we can SRoA and promote all the other elements even if 1656145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner/// we end up not being able to promote this one. 1657145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner/// 1658145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner/// All we require is that the uses of the PHI do not index into other parts of 1659145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner/// the alloca. The most important use case for this is single load and stores 1660145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner/// that are PHI'd together, which can happen due to code sinking. 1661145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattnervoid SROA::isSafePHISelectUseForScalarRepl(Instruction *I, uint64_t Offset, 1662145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner AllocaInfo &Info) { 1663145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner // If we've already checked this PHI, don't do it again. 1664145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner if (PHINode *PN = dyn_cast<PHINode>(I)) 1665145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner if (!Info.CheckedPHIs.insert(PN)) 1666145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner return; 1667a94d6e87c4c49f2e81b01d66d8bfb591277f8f96Nadav Rotem 1668145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner for (Value::use_iterator UI = I->use_begin(), E = I->use_end(); UI!=E; ++UI) { 1669145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner Instruction *User = cast<Instruction>(*UI); 1670a94d6e87c4c49f2e81b01d66d8bfb591277f8f96Nadav Rotem 1671145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner if (BitCastInst *BC = dyn_cast<BitCastInst>(User)) { 1672145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner isSafePHISelectUseForScalarRepl(BC, Offset, Info); 1673145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner } else if (GetElementPtrInst *GEPI = dyn_cast<GetElementPtrInst>(User)) { 1674145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner // Only allow "bitcast" GEPs for simplicity. We could generalize this, 1675145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner // but would have to prove that we're staying inside of an element being 1676145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner // promoted. 1677145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner if (!GEPI->hasAllZeroIndices()) 1678145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner return MarkUnsafe(Info, User); 1679145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner isSafePHISelectUseForScalarRepl(GEPI, Offset, Info); 1680145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner } else if (LoadInst *LI = dyn_cast<LoadInst>(User)) { 16812bc3d52b9ab422ee9f7e42a1a4e3b818e623a5f7Eli Friedman if (!LI->isSimple()) 1682145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner return MarkUnsafe(Info, User); 1683db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *LIType = LI->getType(); 1684145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner isSafeMemAccess(Offset, TD->getTypeAllocSize(LIType), 1685145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner LIType, false, Info, LI, false /*AllowWholeAccess*/); 1686145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner Info.hasALoadOrStore = true; 1687a94d6e87c4c49f2e81b01d66d8bfb591277f8f96Nadav Rotem 1688145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner } else if (StoreInst *SI = dyn_cast<StoreInst>(User)) { 1689145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner // Store is ok if storing INTO the pointer, not storing the pointer 16902bc3d52b9ab422ee9f7e42a1a4e3b818e623a5f7Eli Friedman if (!SI->isSimple() || SI->getOperand(0) == I) 1691145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner return MarkUnsafe(Info, User); 1692a94d6e87c4c49f2e81b01d66d8bfb591277f8f96Nadav Rotem 1693db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *SIType = SI->getOperand(0)->getType(); 1694145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner isSafeMemAccess(Offset, TD->getTypeAllocSize(SIType), 1695145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner SIType, true, Info, SI, false /*AllowWholeAccess*/); 1696d01a0da090407762fe3b770d84f049d72d06467eChris Lattner Info.hasALoadOrStore = true; 1697145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner } else if (isa<PHINode>(User) || isa<SelectInst>(User)) { 1698145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner isSafePHISelectUseForScalarRepl(User, Offset, Info); 16994cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } else { 1700d01a0da090407762fe3b770d84f049d72d06467eChris Lattner return MarkUnsafe(Info, User); 1701d2fa781169175b827e50953a1d0b7edc6b0c4801Chris Lattner } 17024cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (Info.isUnsafe) return; 1703d2fa781169175b827e50953a1d0b7edc6b0c4801Chris Lattner } 1704d2fa781169175b827e50953a1d0b7edc6b0c4801Chris Lattner} 1705d2fa781169175b827e50953a1d0b7edc6b0c4801Chris Lattner 17064cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// isSafeGEP - Check if a GEP instruction can be handled for scalar 17074cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// replacement. It is safe when all the indices are constant, in-bounds 17084cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// references, and when the resulting offset corresponds to an element within 17094cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// the alloca type. The results are flagged in the Info parameter. Upon 17104cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// return, Offset is adjusted as specified by the GEP indices. 17116c95d24927b11fb76bc3e76ebe6a8198d74fc178Chris Lattnervoid SROA::isSafeGEP(GetElementPtrInst *GEPI, 17124cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner uint64_t &Offset, AllocaInfo &Info) { 17134cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner gep_type_iterator GEPIt = gep_type_begin(GEPI), E = gep_type_end(GEPI); 17144cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (GEPIt == E) 17154cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner return; 1716cbf73908f1d4cc1cb7104bfd451af30c177cb7a5Pete Cooper bool NonConstant = false; 1717cbf73908f1d4cc1cb7104bfd451af30c177cb7a5Pete Cooper unsigned NonConstantIdxSize = 0; 17185ffe6acd577696a41932c7b82db06a04687e07baChris Lattner 17194cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Walk through the GEP type indices, checking the types that this indexes 17204cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // into. 17214cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner for (; GEPIt != E; ++GEPIt) { 17224cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Ignore struct elements, no extra checking needed for these. 17234cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if ((*GEPIt)->isStructTy()) 17244cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner continue; 17255ffe6acd577696a41932c7b82db06a04687e07baChris Lattner 17264cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner ConstantInt *IdxVal = dyn_cast<ConstantInt>(GEPIt.getOperand()); 1727cbf73908f1d4cc1cb7104bfd451af30c177cb7a5Pete Cooper if (!IdxVal) { 1728cbf73908f1d4cc1cb7104bfd451af30c177cb7a5Pete Cooper // Non constant GEPs are only a problem on arrays, structs, and pointers 1729cbf73908f1d4cc1cb7104bfd451af30c177cb7a5Pete Cooper // Vectors can be dynamically indexed. 1730cbf73908f1d4cc1cb7104bfd451af30c177cb7a5Pete Cooper // FIXME: Add support for dynamic indexing on arrays. This should be 1731cbf73908f1d4cc1cb7104bfd451af30c177cb7a5Pete Cooper // ok on any subarrays of the alloca array, eg, a[0][i] is ok, but a[i][0] 1732cbf73908f1d4cc1cb7104bfd451af30c177cb7a5Pete Cooper // isn't. 1733cbf73908f1d4cc1cb7104bfd451af30c177cb7a5Pete Cooper if (!(*GEPIt)->isVectorTy()) 1734cbf73908f1d4cc1cb7104bfd451af30c177cb7a5Pete Cooper return MarkUnsafe(Info, GEPI); 1735cbf73908f1d4cc1cb7104bfd451af30c177cb7a5Pete Cooper NonConstant = true; 1736cbf73908f1d4cc1cb7104bfd451af30c177cb7a5Pete Cooper NonConstantIdxSize = TD->getTypeAllocSize(*GEPIt); 1737cbf73908f1d4cc1cb7104bfd451af30c177cb7a5Pete Cooper } 17385ffe6acd577696a41932c7b82db06a04687e07baChris Lattner } 173941b33f437f70dcf63e35d08e5f4202258ef05c15Eli Friedman 17404cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Compute the offset due to this GEP and check if the alloca has a 17414cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // component element at that offset. 17424cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner SmallVector<Value*, 8> Indices(GEPI->op_begin() + 1, GEPI->op_end()); 1743cbf73908f1d4cc1cb7104bfd451af30c177cb7a5Pete Cooper // If this GEP is non constant then the last operand must have been a 1744cbf73908f1d4cc1cb7104bfd451af30c177cb7a5Pete Cooper // dynamic index into a vector. Pop this now as it has no impact on the 1745cbf73908f1d4cc1cb7104bfd451af30c177cb7a5Pete Cooper // constant part of the offset. 1746cbf73908f1d4cc1cb7104bfd451af30c177cb7a5Pete Cooper if (NonConstant) 1747cbf73908f1d4cc1cb7104bfd451af30c177cb7a5Pete Cooper Indices.pop_back(); 17488fbbb3980755d74539a0aed02bc18842ed2bd18dJay Foad Offset += TD->getIndexedOffset(GEPI->getPointerOperandType(), Indices); 1749cbf73908f1d4cc1cb7104bfd451af30c177cb7a5Pete Cooper if (!TypeHasComponent(Info.AI->getAllocatedType(), Offset, 1750cbf73908f1d4cc1cb7104bfd451af30c177cb7a5Pete Cooper NonConstantIdxSize)) 1751d01a0da090407762fe3b770d84f049d72d06467eChris Lattner MarkUnsafe(Info, GEPI); 17524cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner} 175341b33f437f70dcf63e35d08e5f4202258ef05c15Eli Friedman 1754704d1347c5009f674408fae6f78343b415891274Bob Wilson/// isHomogeneousAggregate - Check if type T is a struct or array containing 1755704d1347c5009f674408fae6f78343b415891274Bob Wilson/// elements of the same type (which is always true for arrays). If so, 1756704d1347c5009f674408fae6f78343b415891274Bob Wilson/// return true with NumElts and EltTy set to the number of elements and the 1757704d1347c5009f674408fae6f78343b415891274Bob Wilson/// element type, respectively. 1758db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattnerstatic bool isHomogeneousAggregate(Type *T, unsigned &NumElts, 1759db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *&EltTy) { 1760db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner if (ArrayType *AT = dyn_cast<ArrayType>(T)) { 1761704d1347c5009f674408fae6f78343b415891274Bob Wilson NumElts = AT->getNumElements(); 1762f0908aeade2f41d2fed82de8d85448358b379328Bob Wilson EltTy = (NumElts == 0 ? 0 : AT->getElementType()); 1763704d1347c5009f674408fae6f78343b415891274Bob Wilson return true; 1764704d1347c5009f674408fae6f78343b415891274Bob Wilson } 1765db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner if (StructType *ST = dyn_cast<StructType>(T)) { 1766704d1347c5009f674408fae6f78343b415891274Bob Wilson NumElts = ST->getNumContainedTypes(); 1767f0908aeade2f41d2fed82de8d85448358b379328Bob Wilson EltTy = (NumElts == 0 ? 0 : ST->getContainedType(0)); 1768704d1347c5009f674408fae6f78343b415891274Bob Wilson for (unsigned n = 1; n < NumElts; ++n) { 1769704d1347c5009f674408fae6f78343b415891274Bob Wilson if (ST->getContainedType(n) != EltTy) 1770704d1347c5009f674408fae6f78343b415891274Bob Wilson return false; 1771704d1347c5009f674408fae6f78343b415891274Bob Wilson } 1772704d1347c5009f674408fae6f78343b415891274Bob Wilson return true; 1773704d1347c5009f674408fae6f78343b415891274Bob Wilson } 1774704d1347c5009f674408fae6f78343b415891274Bob Wilson return false; 1775704d1347c5009f674408fae6f78343b415891274Bob Wilson} 1776704d1347c5009f674408fae6f78343b415891274Bob Wilson 1777704d1347c5009f674408fae6f78343b415891274Bob Wilson/// isCompatibleAggregate - Check if T1 and T2 are either the same type or are 1778704d1347c5009f674408fae6f78343b415891274Bob Wilson/// "homogeneous" aggregates with the same element type and number of elements. 1779db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattnerstatic bool isCompatibleAggregate(Type *T1, Type *T2) { 1780704d1347c5009f674408fae6f78343b415891274Bob Wilson if (T1 == T2) 1781704d1347c5009f674408fae6f78343b415891274Bob Wilson return true; 1782704d1347c5009f674408fae6f78343b415891274Bob Wilson 1783704d1347c5009f674408fae6f78343b415891274Bob Wilson unsigned NumElts1, NumElts2; 1784db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *EltTy1, *EltTy2; 1785704d1347c5009f674408fae6f78343b415891274Bob Wilson if (isHomogeneousAggregate(T1, NumElts1, EltTy1) && 1786704d1347c5009f674408fae6f78343b415891274Bob Wilson isHomogeneousAggregate(T2, NumElts2, EltTy2) && 1787704d1347c5009f674408fae6f78343b415891274Bob Wilson NumElts1 == NumElts2 && 1788704d1347c5009f674408fae6f78343b415891274Bob Wilson EltTy1 == EltTy2) 1789704d1347c5009f674408fae6f78343b415891274Bob Wilson return true; 1790704d1347c5009f674408fae6f78343b415891274Bob Wilson 1791704d1347c5009f674408fae6f78343b415891274Bob Wilson return false; 1792704d1347c5009f674408fae6f78343b415891274Bob Wilson} 1793704d1347c5009f674408fae6f78343b415891274Bob Wilson 17944cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// isSafeMemAccess - Check if a load/store/memcpy operates on the entire AI 17954cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// alloca or has an offset and size that corresponds to a component element 17964cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// within it. The offset checked here may have been formed from a GEP with a 17974cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// pointer bitcasted to a different type. 1798145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner/// 1799145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner/// If AllowWholeAccess is true, then this allows uses of the entire alloca as a 1800145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner/// unit. If false, it only allows accesses known to be in a single element. 18016c95d24927b11fb76bc3e76ebe6a8198d74fc178Chris Lattnervoid SROA::isSafeMemAccess(uint64_t Offset, uint64_t MemSize, 1802db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *MemOpType, bool isStore, 1803145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner AllocaInfo &Info, Instruction *TheAccess, 1804145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner bool AllowWholeAccess) { 18054cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Check if this is a load/store of the entire alloca. 1806145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner if (Offset == 0 && AllowWholeAccess && 18076c95d24927b11fb76bc3e76ebe6a8198d74fc178Chris Lattner MemSize == TD->getTypeAllocSize(Info.AI->getAllocatedType())) { 1808704d1347c5009f674408fae6f78343b415891274Bob Wilson // This can be safe for MemIntrinsics (where MemOpType is 0) and integer 1809704d1347c5009f674408fae6f78343b415891274Bob Wilson // loads/stores (which are essentially the same as the MemIntrinsics with 1810704d1347c5009f674408fae6f78343b415891274Bob Wilson // regard to copying padding between elements). But, if an alloca is 1811704d1347c5009f674408fae6f78343b415891274Bob Wilson // flagged as both a source and destination of such operations, we'll need 1812704d1347c5009f674408fae6f78343b415891274Bob Wilson // to check later for padding between elements. 1813704d1347c5009f674408fae6f78343b415891274Bob Wilson if (!MemOpType || MemOpType->isIntegerTy()) { 1814704d1347c5009f674408fae6f78343b415891274Bob Wilson if (isStore) 1815704d1347c5009f674408fae6f78343b415891274Bob Wilson Info.isMemCpyDst = true; 1816704d1347c5009f674408fae6f78343b415891274Bob Wilson else 1817704d1347c5009f674408fae6f78343b415891274Bob Wilson Info.isMemCpySrc = true; 18184cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner return; 18194cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 1820704d1347c5009f674408fae6f78343b415891274Bob Wilson // This is also safe for references using a type that is compatible with 1821704d1347c5009f674408fae6f78343b415891274Bob Wilson // the type of the alloca, so that loads/stores can be rewritten using 1822704d1347c5009f674408fae6f78343b415891274Bob Wilson // insertvalue/extractvalue. 18236c95d24927b11fb76bc3e76ebe6a8198d74fc178Chris Lattner if (isCompatibleAggregate(MemOpType, Info.AI->getAllocatedType())) { 18247e9b427c879ae32b72fd24aeaf011e87e5692fd7Chris Lattner Info.hasSubelementAccess = true; 1825704d1347c5009f674408fae6f78343b415891274Bob Wilson return; 18267e9b427c879ae32b72fd24aeaf011e87e5692fd7Chris Lattner } 18274cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 18284cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Check if the offset/size correspond to a component within the alloca type. 1829db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *T = Info.AI->getAllocatedType(); 18307e9b427c879ae32b72fd24aeaf011e87e5692fd7Chris Lattner if (TypeHasComponent(T, Offset, MemSize)) { 18317e9b427c879ae32b72fd24aeaf011e87e5692fd7Chris Lattner Info.hasSubelementAccess = true; 18324cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner return; 18337e9b427c879ae32b72fd24aeaf011e87e5692fd7Chris Lattner } 18344cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner 1835d01a0da090407762fe3b770d84f049d72d06467eChris Lattner return MarkUnsafe(Info, TheAccess); 18365ffe6acd577696a41932c7b82db06a04687e07baChris Lattner} 18375ffe6acd577696a41932c7b82db06a04687e07baChris Lattner 18384cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// TypeHasComponent - Return true if T has a component type with the 18394cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// specified offset and size. If Size is zero, do not check the size. 1840db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattnerbool SROA::TypeHasComponent(Type *T, uint64_t Offset, uint64_t Size) { 1841db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *EltTy; 18424cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner uint64_t EltSize; 1843db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner if (StructType *ST = dyn_cast<StructType>(T)) { 18444cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner const StructLayout *Layout = TD->getStructLayout(ST); 18454cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner unsigned EltIdx = Layout->getElementContainingOffset(Offset); 18464cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner EltTy = ST->getContainedType(EltIdx); 18474cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner EltSize = TD->getTypeAllocSize(EltTy); 18484cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Offset -= Layout->getElementOffset(EltIdx); 1849db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner } else if (ArrayType *AT = dyn_cast<ArrayType>(T)) { 18504cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner EltTy = AT->getElementType(); 18514cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner EltSize = TD->getTypeAllocSize(EltTy); 18524cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (Offset >= AT->getNumElements() * EltSize) 18534cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner return false; 18544cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Offset %= EltSize; 18556399b7c51076846942a0c05b4823ca9a8f55b5fcPete Cooper } else if (VectorType *VT = dyn_cast<VectorType>(T)) { 18566399b7c51076846942a0c05b4823ca9a8f55b5fcPete Cooper EltTy = VT->getElementType(); 18576399b7c51076846942a0c05b4823ca9a8f55b5fcPete Cooper EltSize = TD->getTypeAllocSize(EltTy); 18586399b7c51076846942a0c05b4823ca9a8f55b5fcPete Cooper if (Offset >= VT->getNumElements() * EltSize) 18596399b7c51076846942a0c05b4823ca9a8f55b5fcPete Cooper return false; 18606399b7c51076846942a0c05b4823ca9a8f55b5fcPete Cooper Offset %= EltSize; 18614cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } else { 18624cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner return false; 18634cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 18644cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (Offset == 0 && (Size == 0 || EltSize == Size)) 18654cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner return true; 18664cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Check if the component spans multiple elements. 18674cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (Offset + Size > EltSize) 18684cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner return false; 18694cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner return TypeHasComponent(EltTy, Offset, Size); 18704cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner} 18713cb3650a278e37aa6378127c51e407d2823139b4Duncan Sands 18724cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// RewriteForScalarRepl - Alloca AI is being split into NewElts, so rewrite 18734cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// the instruction I, which references it, to use the separate elements. 18744cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// Offset indicates the position within AI that is referenced by this 18754cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// instruction. 18764cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattnervoid SROA::RewriteForScalarRepl(Instruction *I, AllocaInst *AI, uint64_t Offset, 18774cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner SmallVector<AllocaInst*, 32> &NewElts) { 1878145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner for (Value::use_iterator UI = I->use_begin(), E = I->use_end(); UI!=E;) { 1879145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner Use &TheUse = UI.getUse(); 1880145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner Instruction *User = cast<Instruction>(*UI++); 18813cb3650a278e37aa6378127c51e407d2823139b4Duncan Sands 18824cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (BitCastInst *BC = dyn_cast<BitCastInst>(User)) { 18834cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner RewriteBitCast(BC, AI, Offset, NewElts); 1884145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner continue; 1885145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner } 1886a94d6e87c4c49f2e81b01d66d8bfb591277f8f96Nadav Rotem 1887145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner if (GetElementPtrInst *GEPI = dyn_cast<GetElementPtrInst>(User)) { 18884cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner RewriteGEP(GEPI, AI, Offset, NewElts); 1889145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner continue; 1890145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner } 1891a94d6e87c4c49f2e81b01d66d8bfb591277f8f96Nadav Rotem 1892145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner if (MemIntrinsic *MI = dyn_cast<MemIntrinsic>(User)) { 18934cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner ConstantInt *Length = dyn_cast<ConstantInt>(MI->getLength()); 18944cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner uint64_t MemSize = Length->getZExtValue(); 18954cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (Offset == 0 && 18964cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner MemSize == TD->getTypeAllocSize(AI->getAllocatedType())) 18974cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner RewriteMemIntrinUserOfAlloca(MI, I, AI, NewElts); 18984cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Otherwise the intrinsic can only touch a single element and the 18994cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // address operand will be updated, so nothing else needs to be done. 1900145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner continue; 1901145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner } 19025a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky 19035a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(User)) { 19045a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky if (II->getIntrinsicID() == Intrinsic::lifetime_start || 19055a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky II->getIntrinsicID() == Intrinsic::lifetime_end) { 19065a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky RewriteLifetimeIntrinsic(II, AI, Offset, NewElts); 19075a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky } 19085a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky continue; 19095a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky } 1910a94d6e87c4c49f2e81b01d66d8bfb591277f8f96Nadav Rotem 1911145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner if (LoadInst *LI = dyn_cast<LoadInst>(User)) { 1912db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *LIType = LI->getType(); 1913a94d6e87c4c49f2e81b01d66d8bfb591277f8f96Nadav Rotem 1914704d1347c5009f674408fae6f78343b415891274Bob Wilson if (isCompatibleAggregate(LIType, AI->getAllocatedType())) { 19154cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Replace: 19164cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // %res = load { i32, i32 }* %alloc 19174cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // with: 19184cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // %load.0 = load i32* %alloc.0 19194cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // %insert.0 insertvalue { i32, i32 } zeroinitializer, i32 %load.0, 0 19204cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // %load.1 = load i32* %alloc.1 19214cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // %insert = insertvalue { i32, i32 } %insert.0, i32 %load.1, 1 19224cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // (Also works for arrays instead of structs) 19234cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Value *Insert = UndefValue::get(LIType); 1924abb25122050349ccf77f8afb198a985e7a4d95eeDevang Patel IRBuilder<> Builder(LI); 19254cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner for (unsigned i = 0, e = NewElts.size(); i != e; ++i) { 1926abb25122050349ccf77f8afb198a985e7a4d95eeDevang Patel Value *Load = Builder.CreateLoad(NewElts[i], "load"); 1927abb25122050349ccf77f8afb198a985e7a4d95eeDevang Patel Insert = Builder.CreateInsertValue(Insert, Load, i, "insert"); 19284cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 19294cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner LI->replaceAllUsesWith(Insert); 19304cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner DeadInsts.push_back(LI); 19314cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } else if (LIType->isIntegerTy() && 19324cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner TD->getTypeAllocSize(LIType) == 19334cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner TD->getTypeAllocSize(AI->getAllocatedType())) { 19344cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // If this is a load of the entire alloca to an integer, rewrite it. 19354cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner RewriteLoadUserOfWholeAlloca(LI, AI, NewElts); 19364cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 1937145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner continue; 1938145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner } 1939a94d6e87c4c49f2e81b01d66d8bfb591277f8f96Nadav Rotem 1940145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner if (StoreInst *SI = dyn_cast<StoreInst>(User)) { 19414cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Value *Val = SI->getOperand(0); 1942db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *SIType = Val->getType(); 1943704d1347c5009f674408fae6f78343b415891274Bob Wilson if (isCompatibleAggregate(SIType, AI->getAllocatedType())) { 19444cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Replace: 19454cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // store { i32, i32 } %val, { i32, i32 }* %alloc 19464cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // with: 19474cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // %val.0 = extractvalue { i32, i32 } %val, 0 19484cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // store i32 %val.0, i32* %alloc.0 19494cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // %val.1 = extractvalue { i32, i32 } %val, 1 19504cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // store i32 %val.1, i32* %alloc.1 19514cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // (Also works for arrays instead of structs) 1952abb25122050349ccf77f8afb198a985e7a4d95eeDevang Patel IRBuilder<> Builder(SI); 19534cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner for (unsigned i = 0, e = NewElts.size(); i != e; ++i) { 1954abb25122050349ccf77f8afb198a985e7a4d95eeDevang Patel Value *Extract = Builder.CreateExtractValue(Val, i, Val->getName()); 1955abb25122050349ccf77f8afb198a985e7a4d95eeDevang Patel Builder.CreateStore(Extract, NewElts[i]); 19564cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 19574cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner DeadInsts.push_back(SI); 19584cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } else if (SIType->isIntegerTy() && 19594cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner TD->getTypeAllocSize(SIType) == 19604cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner TD->getTypeAllocSize(AI->getAllocatedType())) { 19614cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // If this is a store of the entire alloca from an integer, rewrite it. 19624cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner RewriteStoreUserOfWholeAlloca(SI, AI, NewElts); 196339a1c04323a5993d6b2993e615ec44c16e19aeeaChris Lattner } 1964145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner continue; 1965145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner } 1966a94d6e87c4c49f2e81b01d66d8bfb591277f8f96Nadav Rotem 1967145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner if (isa<SelectInst>(User) || isa<PHINode>(User)) { 1968a94d6e87c4c49f2e81b01d66d8bfb591277f8f96Nadav Rotem // If we have a PHI user of the alloca itself (as opposed to a GEP or 1969145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner // bitcast) we have to rewrite it. GEP and bitcast uses will be RAUW'd to 1970145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner // the new pointer. 1971145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner if (!isa<AllocaInst>(I)) continue; 1972a94d6e87c4c49f2e81b01d66d8bfb591277f8f96Nadav Rotem 1973145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner assert(Offset == 0 && NewElts[0] && 1974145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner "Direct alloca use should have a zero offset"); 1975a94d6e87c4c49f2e81b01d66d8bfb591277f8f96Nadav Rotem 1976145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner // If we have a use of the alloca, we know the derived uses will be 1977145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner // utilizing just the first element of the scalarized result. Insert a 1978145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner // bitcast of the first alloca before the user as required. 1979145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner AllocaInst *NewAI = NewElts[0]; 1980145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner BitCastInst *BCI = new BitCastInst(NewAI, AI->getType(), "", NewAI); 1981145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner NewAI->moveBefore(BCI); 1982145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner TheUse = BCI; 1983145c532e68acdf70d40bab5bc2034f692848b8dcChris Lattner continue; 198439a1c04323a5993d6b2993e615ec44c16e19aeeaChris Lattner } 19854cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 19864cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner} 19873cb3650a278e37aa6378127c51e407d2823139b4Duncan Sands 19884cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// RewriteBitCast - Update a bitcast reference to the alloca being replaced 19894cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// and recursively continue updating all of its uses. 19904cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattnervoid SROA::RewriteBitCast(BitCastInst *BC, AllocaInst *AI, uint64_t Offset, 19914cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner SmallVector<AllocaInst*, 32> &NewElts) { 19924cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner RewriteForScalarRepl(BC, AI, Offset, NewElts); 19934cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (BC->getOperand(0) != AI) 19944cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner return; 199539a1c04323a5993d6b2993e615ec44c16e19aeeaChris Lattner 19964cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // The bitcast references the original alloca. Replace its uses with 199775f69e3a3dff78cb89ded1d6c96ccb65603a82d9Eli Friedman // references to the alloca containing offset zero (which is normally at 199875f69e3a3dff78cb89ded1d6c96ccb65603a82d9Eli Friedman // index zero, but might not be in cases involving structs with elements 199975f69e3a3dff78cb89ded1d6c96ccb65603a82d9Eli Friedman // of size zero). 200075f69e3a3dff78cb89ded1d6c96ccb65603a82d9Eli Friedman Type *T = AI->getAllocatedType(); 200175f69e3a3dff78cb89ded1d6c96ccb65603a82d9Eli Friedman uint64_t EltOffset = 0; 200275f69e3a3dff78cb89ded1d6c96ccb65603a82d9Eli Friedman Type *IdxTy; 200375f69e3a3dff78cb89ded1d6c96ccb65603a82d9Eli Friedman uint64_t Idx = FindElementAndOffset(T, EltOffset, IdxTy); 200475f69e3a3dff78cb89ded1d6c96ccb65603a82d9Eli Friedman Instruction *Val = NewElts[Idx]; 20054cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (Val->getType() != BC->getDestTy()) { 20064cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Val = new BitCastInst(Val, BC->getDestTy(), "", BC); 20074cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Val->takeName(BC); 200839a1c04323a5993d6b2993e615ec44c16e19aeeaChris Lattner } 20094cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner BC->replaceAllUsesWith(Val); 20104cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner DeadInsts.push_back(BC); 201139a1c04323a5993d6b2993e615ec44c16e19aeeaChris Lattner} 2012372dda8881c7a32a6f5ce0f76a713e3a9ef46ea1Chris Lattner 20134cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// FindElementAndOffset - Return the index of the element containing Offset 20144cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// within the specified type, which must be either a struct or an array. 20154cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// Sets T to the type of the element and Offset to the offset within that 20164cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// element. IdxTy is set to the type of the index result to be used in a 20174cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// GEP instruction. 2018db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattneruint64_t SROA::FindElementAndOffset(Type *&T, uint64_t &Offset, 2019db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *&IdxTy) { 20204cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner uint64_t Idx = 0; 2021db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner if (StructType *ST = dyn_cast<StructType>(T)) { 20224cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner const StructLayout *Layout = TD->getStructLayout(ST); 20234cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Idx = Layout->getElementContainingOffset(Offset); 20244cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner T = ST->getContainedType(Idx); 20254cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Offset -= Layout->getElementOffset(Idx); 20264cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner IdxTy = Type::getInt32Ty(T->getContext()); 20274cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner return Idx; 20286399b7c51076846942a0c05b4823ca9a8f55b5fcPete Cooper } else if (ArrayType *AT = dyn_cast<ArrayType>(T)) { 20296399b7c51076846942a0c05b4823ca9a8f55b5fcPete Cooper T = AT->getElementType(); 20306399b7c51076846942a0c05b4823ca9a8f55b5fcPete Cooper uint64_t EltSize = TD->getTypeAllocSize(T); 20316399b7c51076846942a0c05b4823ca9a8f55b5fcPete Cooper Idx = Offset / EltSize; 20326399b7c51076846942a0c05b4823ca9a8f55b5fcPete Cooper Offset -= Idx * EltSize; 20336399b7c51076846942a0c05b4823ca9a8f55b5fcPete Cooper IdxTy = Type::getInt64Ty(T->getContext()); 20346399b7c51076846942a0c05b4823ca9a8f55b5fcPete Cooper return Idx; 2035f5990edc877c4e63503c589928a00ec6ec751830Chris Lattner } 20366399b7c51076846942a0c05b4823ca9a8f55b5fcPete Cooper VectorType *VT = cast<VectorType>(T); 20376399b7c51076846942a0c05b4823ca9a8f55b5fcPete Cooper T = VT->getElementType(); 20384cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner uint64_t EltSize = TD->getTypeAllocSize(T); 20394cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Idx = Offset / EltSize; 20404cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Offset -= Idx * EltSize; 20414cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner IdxTy = Type::getInt64Ty(T->getContext()); 20424cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner return Idx; 20435e062a1eda2c4adffd428a35e737a431fc37f4e0Chris Lattner} 2044a188894d67a3cc2516b25aae9b3cbdbff4b0babeChris Lattner 20454cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// RewriteGEP - Check if this GEP instruction moves the pointer across 20464cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// elements of the alloca that are being split apart, and if so, rewrite 20474cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// the GEP to be relative to the new element. 20484cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattnervoid SROA::RewriteGEP(GetElementPtrInst *GEPI, AllocaInst *AI, uint64_t Offset, 20494cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner SmallVector<AllocaInst*, 32> &NewElts) { 20504cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner uint64_t OldOffset = Offset; 20514cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner SmallVector<Value*, 8> Indices(GEPI->op_begin() + 1, GEPI->op_end()); 2052cbf73908f1d4cc1cb7104bfd451af30c177cb7a5Pete Cooper // If the GEP was dynamic then it must have been a dynamic vector lookup. 2053cbf73908f1d4cc1cb7104bfd451af30c177cb7a5Pete Cooper // In this case, it must be the last GEP operand which is dynamic so keep that 2054cbf73908f1d4cc1cb7104bfd451af30c177cb7a5Pete Cooper // aside until we've found the constant GEP offset then add it back in at the 2055cbf73908f1d4cc1cb7104bfd451af30c177cb7a5Pete Cooper // end. 2056cbf73908f1d4cc1cb7104bfd451af30c177cb7a5Pete Cooper Value* NonConstantIdx = 0; 2057cbf73908f1d4cc1cb7104bfd451af30c177cb7a5Pete Cooper if (!GEPI->hasAllConstantIndices()) 2058cbf73908f1d4cc1cb7104bfd451af30c177cb7a5Pete Cooper NonConstantIdx = Indices.pop_back_val(); 20598fbbb3980755d74539a0aed02bc18842ed2bd18dJay Foad Offset += TD->getIndexedOffset(GEPI->getPointerOperandType(), Indices); 20604cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner 20614cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner RewriteForScalarRepl(GEPI, AI, Offset, NewElts); 20624cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner 2063db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *T = AI->getAllocatedType(); 2064db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *IdxTy; 20654cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner uint64_t OldIdx = FindElementAndOffset(T, OldOffset, IdxTy); 20664cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (GEPI->getOperand(0) == AI) 20674cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner OldIdx = ~0ULL; // Force the GEP to be rewritten. 20684cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner 20694cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner T = AI->getAllocatedType(); 20704cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner uint64_t EltOffset = Offset; 20714cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner uint64_t Idx = FindElementAndOffset(T, EltOffset, IdxTy); 20724cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner 20734cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // If this GEP does not move the pointer across elements of the alloca 20744cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // being split, then it does not needs to be rewritten. 20754cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (Idx == OldIdx) 2076c4472072641f702dbd99ae12b7da089e75c44a99Chris Lattner return; 2077c4472072641f702dbd99ae12b7da089e75c44a99Chris Lattner 2078db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *i32Ty = Type::getInt32Ty(AI->getContext()); 20794cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner SmallVector<Value*, 8> NewArgs; 20804cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner NewArgs.push_back(Constant::getNullValue(i32Ty)); 20814cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner while (EltOffset != 0) { 20824cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner uint64_t EltIdx = FindElementAndOffset(T, EltOffset, IdxTy); 20834cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner NewArgs.push_back(ConstantInt::get(IdxTy, EltIdx)); 20842e0d5f84325303fa95997cd66485811bd0a6ef70Chris Lattner } 208506e6c385cbf550ab73ad70bd3e02d9ad2fd3089cPete Cooper if (NonConstantIdx) { 208606e6c385cbf550ab73ad70bd3e02d9ad2fd3089cPete Cooper Type* GepTy = T; 208706e6c385cbf550ab73ad70bd3e02d9ad2fd3089cPete Cooper // This GEP has a dynamic index. We need to add "i32 0" to index through 208806e6c385cbf550ab73ad70bd3e02d9ad2fd3089cPete Cooper // any structs or arrays in the original type until we get to the vector 208906e6c385cbf550ab73ad70bd3e02d9ad2fd3089cPete Cooper // to index. 209006e6c385cbf550ab73ad70bd3e02d9ad2fd3089cPete Cooper while (!isa<VectorType>(GepTy)) { 209106e6c385cbf550ab73ad70bd3e02d9ad2fd3089cPete Cooper NewArgs.push_back(Constant::getNullValue(i32Ty)); 209206e6c385cbf550ab73ad70bd3e02d9ad2fd3089cPete Cooper GepTy = cast<CompositeType>(GepTy)->getTypeAtIndex(0U); 209306e6c385cbf550ab73ad70bd3e02d9ad2fd3089cPete Cooper } 2094cbf73908f1d4cc1cb7104bfd451af30c177cb7a5Pete Cooper NewArgs.push_back(NonConstantIdx); 209506e6c385cbf550ab73ad70bd3e02d9ad2fd3089cPete Cooper } 20964cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Instruction *Val = NewElts[Idx]; 20974cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (NewArgs.size() > 1) { 2098a9203109f4ac95aa7e9624f2838e3d89623ec902Jay Foad Val = GetElementPtrInst::CreateInBounds(Val, NewArgs, "", GEPI); 20994cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Val->takeName(GEPI); 21004cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 21014cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (Val->getType() != GEPI->getType()) 21024cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Val = new BitCastInst(Val, GEPI->getType(), Val->getName(), GEPI); 21034cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner GEPI->replaceAllUsesWith(Val); 21044cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner DeadInsts.push_back(GEPI); 2105a188894d67a3cc2516b25aae9b3cbdbff4b0babeChris Lattner} 2106a188894d67a3cc2516b25aae9b3cbdbff4b0babeChris Lattner 21075a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky/// RewriteLifetimeIntrinsic - II is a lifetime.start/lifetime.end. Rewrite it 21085a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky/// to mark the lifetime of the scalarized memory. 21095a1cb644c903da49dc612a0ba5044505d066259eNick Lewyckyvoid SROA::RewriteLifetimeIntrinsic(IntrinsicInst *II, AllocaInst *AI, 21105a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky uint64_t Offset, 21115a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky SmallVector<AllocaInst*, 32> &NewElts) { 21125a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky ConstantInt *OldSize = cast<ConstantInt>(II->getArgOperand(0)); 21135a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky // Put matching lifetime markers on everything from Offset up to 21145a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky // Offset+OldSize. 21155a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky Type *AIType = AI->getAllocatedType(); 21165a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky uint64_t NewOffset = Offset; 21175a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky Type *IdxTy; 21185a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky uint64_t Idx = FindElementAndOffset(AIType, NewOffset, IdxTy); 21195a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky 21205a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky IRBuilder<> Builder(II); 21215a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky uint64_t Size = OldSize->getLimitedValue(); 21225a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky 21235a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky if (NewOffset) { 21245a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky // Splice the first element and index 'NewOffset' bytes in. SROA will 21255a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky // split the alloca again later. 21265a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky Value *V = Builder.CreateBitCast(NewElts[Idx], Builder.getInt8PtrTy()); 21275a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky V = Builder.CreateGEP(V, Builder.getInt64(NewOffset)); 21285a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky 21295a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky IdxTy = NewElts[Idx]->getAllocatedType(); 21305a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky uint64_t EltSize = TD->getTypeAllocSize(IdxTy) - NewOffset; 21315a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky if (EltSize > Size) { 21325a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky EltSize = Size; 21335a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky Size = 0; 21345a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky } else { 21355a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky Size -= EltSize; 21365a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky } 21375a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky if (II->getIntrinsicID() == Intrinsic::lifetime_start) 21385a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky Builder.CreateLifetimeStart(V, Builder.getInt64(EltSize)); 21395a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky else 21405a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky Builder.CreateLifetimeEnd(V, Builder.getInt64(EltSize)); 21415a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky ++Idx; 21425a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky } 21435a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky 21445a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky for (; Idx != NewElts.size() && Size; ++Idx) { 21455a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky IdxTy = NewElts[Idx]->getAllocatedType(); 21465a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky uint64_t EltSize = TD->getTypeAllocSize(IdxTy); 21475a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky if (EltSize > Size) { 21485a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky EltSize = Size; 21495a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky Size = 0; 21505a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky } else { 21515a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky Size -= EltSize; 21525a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky } 21535a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky if (II->getIntrinsicID() == Intrinsic::lifetime_start) 21545a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky Builder.CreateLifetimeStart(NewElts[Idx], 21555a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky Builder.getInt64(EltSize)); 21565a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky else 21575a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky Builder.CreateLifetimeEnd(NewElts[Idx], 21585a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky Builder.getInt64(EltSize)); 21595a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky } 21605a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky DeadInsts.push_back(II); 21615a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky} 21625a1cb644c903da49dc612a0ba5044505d066259eNick Lewycky 21634cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// RewriteMemIntrinUserOfAlloca - MI is a memcpy/memset/memmove from or to AI. 21644cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// Rewrite it to copy or set the elements of the scalarized memory. 21654cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattnervoid SROA::RewriteMemIntrinUserOfAlloca(MemIntrinsic *MI, Instruction *Inst, 21664cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner AllocaInst *AI, 21674cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner SmallVector<AllocaInst*, 32> &NewElts) { 21684cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // If this is a memcpy/memmove, construct the other pointer as the 21694cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // appropriate type. The "Other" pointer is the pointer that goes to memory 21704cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // that doesn't have anything to do with the alloca that we are promoting. For 21714cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // memset, this Value* stays null. 21724cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Value *OtherPtr = 0; 21734cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner unsigned MemAlignment = MI->getAlignment(); 21744cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (MemTransferInst *MTI = dyn_cast<MemTransferInst>(MI)) { // memmove/memcopy 21754cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (Inst == MTI->getRawDest()) 21764cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner OtherPtr = MTI->getRawSource(); 21774cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner else { 21784cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner assert(Inst == MTI->getRawSource()); 21794cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner OtherPtr = MTI->getRawDest(); 2180a188894d67a3cc2516b25aae9b3cbdbff4b0babeChris Lattner } 21814cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 21823ce5e887aef457701da95f1c6ccbd58ec3d32fe4Chris Lattner 21834cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // If there is an other pointer, we want to convert it to the same pointer 21844cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // type as AI has, so we can GEP through it safely. 21854cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (OtherPtr) { 21860238f8c430050d23ef861169bb4c4f930af0ef97Chris Lattner unsigned AddrSpace = 21870238f8c430050d23ef861169bb4c4f930af0ef97Chris Lattner cast<PointerType>(OtherPtr->getType())->getAddressSpace(); 21884cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner 21894cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Remove bitcasts and all-zero GEPs from OtherPtr. This is an 21904cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // optimization, but it's also required to detect the corner case where 21914cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // both pointer operands are referencing the same memory, and where 21924cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // OtherPtr may be a bitcast or GEP that currently being rewritten. (This 21934cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // function is only called for mem intrinsics that access the whole 21944cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // aggregate, so non-zero GEPs are not an issue here.) 21950238f8c430050d23ef861169bb4c4f930af0ef97Chris Lattner OtherPtr = OtherPtr->stripPointerCasts(); 21966974302e3ff20746268721959efed807c7711bfcBob Wilson 21974cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Copying the alloca to itself is a no-op: just delete it. 21984cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (OtherPtr == AI || OtherPtr == NewElts[0]) { 21994cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // This code will run twice for a no-op memcpy -- once for each operand. 22004cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Put only one reference to MI on the DeadInsts list. 22014cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner for (SmallVector<Value*, 32>::const_iterator I = DeadInsts.begin(), 22024cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner E = DeadInsts.end(); I != E; ++I) 22034cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (*I == MI) return; 22044cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner DeadInsts.push_back(MI); 22054cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner return; 2206c570487d45f7426dc5f75c0309122d6f9330ecf7Chris Lattner } 22076974302e3ff20746268721959efed807c7711bfcBob Wilson 22084cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // If the pointer is not the right type, insert a bitcast to the right 22094cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // type. 2210db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *NewTy = 22110238f8c430050d23ef861169bb4c4f930af0ef97Chris Lattner PointerType::get(AI->getType()->getElementType(), AddrSpace); 22126974302e3ff20746268721959efed807c7711bfcBob Wilson 22130238f8c430050d23ef861169bb4c4f930af0ef97Chris Lattner if (OtherPtr->getType() != NewTy) 22140238f8c430050d23ef861169bb4c4f930af0ef97Chris Lattner OtherPtr = new BitCastInst(OtherPtr, NewTy, OtherPtr->getName(), MI); 2215a188894d67a3cc2516b25aae9b3cbdbff4b0babeChris Lattner } 22166974302e3ff20746268721959efed807c7711bfcBob Wilson 22174cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Process each element of the aggregate. 22184cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner bool SROADest = MI->getRawDest() == Inst; 22196974302e3ff20746268721959efed807c7711bfcBob Wilson 22204cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Constant *Zero = Constant::getNullValue(Type::getInt32Ty(MI->getContext())); 22214b3dfbd220835cbba519162712c9cb6afaa44059Duncan Sands 22224cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner for (unsigned i = 0, e = NewElts.size(); i != e; ++i) { 22234cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // If this is a memcpy/memmove, emit a GEP of the other element address. 22244cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Value *OtherElt = 0; 22254cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner unsigned OtherEltAlign = MemAlignment; 22266974302e3ff20746268721959efed807c7711bfcBob Wilson 22274cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (OtherPtr) { 22284cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Value *Idx[2] = { Zero, 22294cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner ConstantInt::get(Type::getInt32Ty(MI->getContext()), i) }; 2230a9203109f4ac95aa7e9624f2838e3d89623ec902Jay Foad OtherElt = GetElementPtrInst::CreateInBounds(OtherPtr, Idx, 22314cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner OtherPtr->getName()+"."+Twine(i), 22324cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner MI); 22334cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner uint64_t EltOffset; 2234db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner PointerType *OtherPtrTy = cast<PointerType>(OtherPtr->getType()); 2235db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *OtherTy = OtherPtrTy->getElementType(); 2236db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner if (StructType *ST = dyn_cast<StructType>(OtherTy)) { 22374cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner EltOffset = TD->getStructLayout(ST)->getElementOffset(i); 22384cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } else { 2239db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *EltTy = cast<SequentialType>(OtherTy)->getElementType(); 22404cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner EltOffset = TD->getTypeAllocSize(EltTy)*i; 22414cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 22426974302e3ff20746268721959efed807c7711bfcBob Wilson 22434cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // The alignment of the other pointer is the guaranteed alignment of the 22444cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // element, which is affected by both the known alignment of the whole 22454cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // mem intrinsic and the alignment of the element. If the alignment of 22464cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // the memcpy (f.e.) is 32 but the element is at a 4-byte offset, then the 22474cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // known alignment is just 4 bytes. 22484cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner OtherEltAlign = (unsigned)MinAlign(OtherEltAlign, EltOffset); 22499bc67da0a9982f2f7597d1d46cf18f079e4f8f98Chris Lattner } 22506974302e3ff20746268721959efed807c7711bfcBob Wilson 22514cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Value *EltPtr = NewElts[i]; 2252db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *EltTy = cast<PointerType>(EltPtr->getType())->getElementType(); 22536974302e3ff20746268721959efed807c7711bfcBob Wilson 22544cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // If we got down to a scalar, insert a load or store as appropriate. 22554cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (EltTy->isSingleValueType()) { 22564cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (isa<MemTransferInst>(MI)) { 22574cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (SROADest) { 22584cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // From Other to Alloca. 22594cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Value *Elt = new LoadInst(OtherElt, "tmp", false, OtherEltAlign, MI); 22604cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner new StoreInst(Elt, EltPtr, MI); 22614cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } else { 22624cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // From Alloca to Other. 22634cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Value *Elt = new LoadInst(EltPtr, "tmp", MI); 22644cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner new StoreInst(Elt, OtherElt, false, OtherEltAlign, MI); 22654cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 22664cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner continue; 226733e24adc3bc3d046aa05cf903fb74da1610b57cbChris Lattner } 22684cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner assert(isa<MemSetInst>(MI)); 22696974302e3ff20746268721959efed807c7711bfcBob Wilson 22704cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // If the stored element is zero (common case), just store a null 22714cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // constant. 22724cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Constant *StoreVal; 22736f14c8c7c1ec97797a04631abad6885bfaabcc6dGabor Greif if (ConstantInt *CI = dyn_cast<ConstantInt>(MI->getArgOperand(1))) { 22744cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (CI->isZero()) { 22754cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner StoreVal = Constant::getNullValue(EltTy); // 0.0, null, 0, <0,0> 22764cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } else { 22774cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // If EltTy is a vector type, get the element type. 2278db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *ValTy = EltTy->getScalarType(); 2279c570487d45f7426dc5f75c0309122d6f9330ecf7Chris Lattner 22804cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Construct an integer with the right value. 22814cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner unsigned EltSize = TD->getTypeSizeInBits(ValTy); 22824cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner APInt OneVal(EltSize, CI->getZExtValue()); 22834cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner APInt TotalVal(OneVal); 22844cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Set each byte. 22854cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner for (unsigned i = 0; 8*i < EltSize; ++i) { 22864cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner TotalVal = TotalVal.shl(8); 22874cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner TotalVal |= OneVal; 22884cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 22896974302e3ff20746268721959efed807c7711bfcBob Wilson 22904cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Convert the integer value to the appropriate type. 2291d55c1c16598eba6111fb3a5b6e5dbc6469a562f7Chris Lattner StoreVal = ConstantInt::get(CI->getContext(), TotalVal); 22924cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (ValTy->isPointerTy()) 22934cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner StoreVal = ConstantExpr::getIntToPtr(StoreVal, ValTy); 22944cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner else if (ValTy->isFloatingPointTy()) 22954cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner StoreVal = ConstantExpr::getBitCast(StoreVal, ValTy); 22964cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner assert(StoreVal->getType() == ValTy && "Type mismatch!"); 22976974302e3ff20746268721959efed807c7711bfcBob Wilson 22984cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // If the requested value was a vector constant, create it. 2299c055a8782ee66f6041cc00997857d98d6b9e9b4aCameron Zwarich if (EltTy->isVectorTy()) { 2300c055a8782ee66f6041cc00997857d98d6b9e9b4aCameron Zwarich unsigned NumElts = cast<VectorType>(EltTy)->getNumElements(); 23014ca829e89567f002fc74eb0e3e532a7c7662e031Chris Lattner StoreVal = ConstantVector::getSplat(NumElts, StoreVal); 23024cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 23034cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 23044cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner new StoreInst(StoreVal, EltPtr, MI); 23054cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner continue; 23064cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 23074cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Otherwise, if we're storing a byte variable, use a memset call for 23084cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // this element. 23094cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 23106974302e3ff20746268721959efed807c7711bfcBob Wilson 23114cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner unsigned EltSize = TD->getTypeAllocSize(EltTy); 231275f69e3a3dff78cb89ded1d6c96ccb65603a82d9Eli Friedman if (!EltSize) 231375f69e3a3dff78cb89ded1d6c96ccb65603a82d9Eli Friedman continue; 23146974302e3ff20746268721959efed807c7711bfcBob Wilson 231561db1f56d0b717d67557bbb2a9d83af1449458cbChris Lattner IRBuilder<> Builder(MI); 23166974302e3ff20746268721959efed807c7711bfcBob Wilson 23174cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Finally, insert the meminst for this element. 231861db1f56d0b717d67557bbb2a9d83af1449458cbChris Lattner if (isa<MemSetInst>(MI)) { 231961db1f56d0b717d67557bbb2a9d83af1449458cbChris Lattner Builder.CreateMemSet(EltPtr, MI->getArgOperand(1), EltSize, 232061db1f56d0b717d67557bbb2a9d83af1449458cbChris Lattner MI->isVolatile()); 23214cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } else { 232261db1f56d0b717d67557bbb2a9d83af1449458cbChris Lattner assert(isa<MemTransferInst>(MI)); 232361db1f56d0b717d67557bbb2a9d83af1449458cbChris Lattner Value *Dst = SROADest ? EltPtr : OtherElt; // Dest ptr 232461db1f56d0b717d67557bbb2a9d83af1449458cbChris Lattner Value *Src = SROADest ? OtherElt : EltPtr; // Src ptr 23256974302e3ff20746268721959efed807c7711bfcBob Wilson 232661db1f56d0b717d67557bbb2a9d83af1449458cbChris Lattner if (isa<MemCpyInst>(MI)) 232761db1f56d0b717d67557bbb2a9d83af1449458cbChris Lattner Builder.CreateMemCpy(Dst, Src, EltSize, OtherEltAlign,MI->isVolatile()); 232861db1f56d0b717d67557bbb2a9d83af1449458cbChris Lattner else 232961db1f56d0b717d67557bbb2a9d83af1449458cbChris Lattner Builder.CreateMemMove(Dst, Src, EltSize,OtherEltAlign,MI->isVolatile()); 23304cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 2331a188894d67a3cc2516b25aae9b3cbdbff4b0babeChris Lattner } 23324cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner DeadInsts.push_back(MI); 2333a188894d67a3cc2516b25aae9b3cbdbff4b0babeChris Lattner} 233479b3bd395dc3303cde65e18e0524ed2f70268c99Chris Lattner 23354cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// RewriteStoreUserOfWholeAlloca - We found a store of an integer that 23364cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// overwrites the entire allocation. Extract out the pieces of the stored 23374cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// integer and store them individually. 23384cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattnervoid SROA::RewriteStoreUserOfWholeAlloca(StoreInst *SI, AllocaInst *AI, 23394cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner SmallVector<AllocaInst*, 32> &NewElts){ 23404cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Extract each element out of the integer according to its structure offset 23414cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // and store the element value to the individual alloca. 23424cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Value *SrcVal = SI->getOperand(0); 2343db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *AllocaEltTy = AI->getAllocatedType(); 23444cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner uint64_t AllocaSizeBits = TD->getTypeAllocSizeInBits(AllocaEltTy); 23456974302e3ff20746268721959efed807c7711bfcBob Wilson 234670728532799d751b8e0e97719dcb3344a2fc97deChris Lattner IRBuilder<> Builder(SI); 2347a94d6e87c4c49f2e81b01d66d8bfb591277f8f96Nadav Rotem 23484cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Handle tail padding by extending the operand 23494cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (TD->getTypeSizeInBits(SrcVal->getType()) != AllocaSizeBits) 235070728532799d751b8e0e97719dcb3344a2fc97deChris Lattner SrcVal = Builder.CreateZExt(SrcVal, 235170728532799d751b8e0e97719dcb3344a2fc97deChris Lattner IntegerType::get(SI->getContext(), AllocaSizeBits)); 23524b3dfbd220835cbba519162712c9cb6afaa44059Duncan Sands 23534cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner DEBUG(dbgs() << "PROMOTING STORE TO WHOLE ALLOCA: " << *AI << '\n' << *SI 23544cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner << '\n'); 23554b3dfbd220835cbba519162712c9cb6afaa44059Duncan Sands 23564cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // There are two forms here: AI could be an array or struct. Both cases 23574cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // have different ways to compute the element offset. 2358db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner if (StructType *EltSTy = dyn_cast<StructType>(AllocaEltTy)) { 23594cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner const StructLayout *Layout = TD->getStructLayout(EltSTy); 23606974302e3ff20746268721959efed807c7711bfcBob Wilson 23614cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner for (unsigned i = 0, e = NewElts.size(); i != e; ++i) { 23624cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Get the number of bits to shift SrcVal to get the value. 2363db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *FieldTy = EltSTy->getElementType(i); 23644cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner uint64_t Shift = Layout->getElementOffsetInBits(i); 23656974302e3ff20746268721959efed807c7711bfcBob Wilson 23664cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (TD->isBigEndian()) 23674cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Shift = AllocaSizeBits-Shift-TD->getTypeAllocSizeInBits(FieldTy); 23686974302e3ff20746268721959efed807c7711bfcBob Wilson 23694cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Value *EltVal = SrcVal; 23704cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (Shift) { 23714cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Value *ShiftVal = ConstantInt::get(EltVal->getType(), Shift); 237270728532799d751b8e0e97719dcb3344a2fc97deChris Lattner EltVal = Builder.CreateLShr(EltVal, ShiftVal, "sroa.store.elt"); 23734cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 23746974302e3ff20746268721959efed807c7711bfcBob Wilson 23754cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Truncate down to an integer of the right size. 23764cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner uint64_t FieldSizeBits = TD->getTypeSizeInBits(FieldTy); 23776974302e3ff20746268721959efed807c7711bfcBob Wilson 23784cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Ignore zero sized fields like {}, they obviously contain no data. 23794cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (FieldSizeBits == 0) continue; 23806974302e3ff20746268721959efed807c7711bfcBob Wilson 23814cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (FieldSizeBits != AllocaSizeBits) 238270728532799d751b8e0e97719dcb3344a2fc97deChris Lattner EltVal = Builder.CreateTrunc(EltVal, 238370728532799d751b8e0e97719dcb3344a2fc97deChris Lattner IntegerType::get(SI->getContext(), FieldSizeBits)); 23844cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Value *DestField = NewElts[i]; 23854cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (EltVal->getType() == FieldTy) { 23864cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Storing to an integer field of this size, just do it. 23874cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } else if (FieldTy->isFloatingPointTy() || FieldTy->isVectorTy()) { 23884cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Bitcast to the right element type (for fp/vector values). 238970728532799d751b8e0e97719dcb3344a2fc97deChris Lattner EltVal = Builder.CreateBitCast(EltVal, FieldTy); 23904cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } else { 23914cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Otherwise, bitcast the dest pointer (for aggregates). 239270728532799d751b8e0e97719dcb3344a2fc97deChris Lattner DestField = Builder.CreateBitCast(DestField, 239370728532799d751b8e0e97719dcb3344a2fc97deChris Lattner PointerType::getUnqual(EltVal->getType())); 23944cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 23954cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner new StoreInst(EltVal, DestField, SI); 23964cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 23976974302e3ff20746268721959efed807c7711bfcBob Wilson 23989d34c4d678cfc836a59a114b7b2cf91e9dd5eac4Chris Lattner } else { 2399db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner ArrayType *ATy = cast<ArrayType>(AllocaEltTy); 2400db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *ArrayEltTy = ATy->getElementType(); 24014cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner uint64_t ElementOffset = TD->getTypeAllocSizeInBits(ArrayEltTy); 24024cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner uint64_t ElementSizeBits = TD->getTypeSizeInBits(ArrayEltTy); 24034b3dfbd220835cbba519162712c9cb6afaa44059Duncan Sands 24044cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner uint64_t Shift; 24056974302e3ff20746268721959efed807c7711bfcBob Wilson 24064cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (TD->isBigEndian()) 24074cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Shift = AllocaSizeBits-ElementOffset; 24086974302e3ff20746268721959efed807c7711bfcBob Wilson else 24094cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Shift = 0; 24106974302e3ff20746268721959efed807c7711bfcBob Wilson 24114cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner for (unsigned i = 0, e = NewElts.size(); i != e; ++i) { 24124cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Ignore zero sized fields like {}, they obviously contain no data. 24134cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (ElementSizeBits == 0) continue; 24146974302e3ff20746268721959efed807c7711bfcBob Wilson 24154cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Value *EltVal = SrcVal; 24164cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (Shift) { 24174cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Value *ShiftVal = ConstantInt::get(EltVal->getType(), Shift); 241870728532799d751b8e0e97719dcb3344a2fc97deChris Lattner EltVal = Builder.CreateLShr(EltVal, ShiftVal, "sroa.store.elt"); 24194cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 24206974302e3ff20746268721959efed807c7711bfcBob Wilson 24214cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Truncate down to an integer of the right size. 24224cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (ElementSizeBits != AllocaSizeBits) 242370728532799d751b8e0e97719dcb3344a2fc97deChris Lattner EltVal = Builder.CreateTrunc(EltVal, 242470728532799d751b8e0e97719dcb3344a2fc97deChris Lattner IntegerType::get(SI->getContext(), 242570728532799d751b8e0e97719dcb3344a2fc97deChris Lattner ElementSizeBits)); 24264cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Value *DestField = NewElts[i]; 24274cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (EltVal->getType() == ArrayEltTy) { 24284cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Storing to an integer field of this size, just do it. 24294cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } else if (ArrayEltTy->isFloatingPointTy() || 24304cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner ArrayEltTy->isVectorTy()) { 24314cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Bitcast to the right element type (for fp/vector values). 243270728532799d751b8e0e97719dcb3344a2fc97deChris Lattner EltVal = Builder.CreateBitCast(EltVal, ArrayEltTy); 24334cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } else { 24344cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Otherwise, bitcast the dest pointer (for aggregates). 243570728532799d751b8e0e97719dcb3344a2fc97deChris Lattner DestField = Builder.CreateBitCast(DestField, 243670728532799d751b8e0e97719dcb3344a2fc97deChris Lattner PointerType::getUnqual(EltVal->getType())); 24374cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 24384cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner new StoreInst(EltVal, DestField, SI); 24396974302e3ff20746268721959efed807c7711bfcBob Wilson 24404cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (TD->isBigEndian()) 24414cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Shift -= ElementOffset; 24426974302e3ff20746268721959efed807c7711bfcBob Wilson else 24434cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Shift += ElementOffset; 24444cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 2445800de31776356910eb877e71df9f32b0a6215324Chris Lattner } 24466974302e3ff20746268721959efed807c7711bfcBob Wilson 24474cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner DeadInsts.push_back(SI); 2448800de31776356910eb877e71df9f32b0a6215324Chris Lattner} 2449800de31776356910eb877e71df9f32b0a6215324Chris Lattner 24504cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// RewriteLoadUserOfWholeAlloca - We found a load of the entire allocation to 24514cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// an integer. Load the individual pieces to form the aggregate value. 24524cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattnervoid SROA::RewriteLoadUserOfWholeAlloca(LoadInst *LI, AllocaInst *AI, 24534cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner SmallVector<AllocaInst*, 32> &NewElts) { 24544cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Extract each element out of the NewElts according to its structure offset 24554cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // and form the result value. 2456db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *AllocaEltTy = AI->getAllocatedType(); 24574cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner uint64_t AllocaSizeBits = TD->getTypeAllocSizeInBits(AllocaEltTy); 24586974302e3ff20746268721959efed807c7711bfcBob Wilson 24594cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner DEBUG(dbgs() << "PROMOTING LOAD OF WHOLE ALLOCA: " << *AI << '\n' << *LI 24604cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner << '\n'); 24616974302e3ff20746268721959efed807c7711bfcBob Wilson 24624cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // There are two forms here: AI could be an array or struct. Both cases 24634cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // have different ways to compute the element offset. 24644cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner const StructLayout *Layout = 0; 24654cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner uint64_t ArrayEltBitOffset = 0; 2466db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner if (StructType *EltSTy = dyn_cast<StructType>(AllocaEltTy)) { 24674cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Layout = TD->getStructLayout(EltSTy); 24684cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } else { 2469db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *ArrayEltTy = cast<ArrayType>(AllocaEltTy)->getElementType(); 24704cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner ArrayEltBitOffset = TD->getTypeAllocSizeInBits(ArrayEltTy); 24716974302e3ff20746268721959efed807c7711bfcBob Wilson } 24726974302e3ff20746268721959efed807c7711bfcBob Wilson 24736974302e3ff20746268721959efed807c7711bfcBob Wilson Value *ResultVal = 24744cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Constant::getNullValue(IntegerType::get(LI->getContext(), AllocaSizeBits)); 24756974302e3ff20746268721959efed807c7711bfcBob Wilson 24764cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner for (unsigned i = 0, e = NewElts.size(); i != e; ++i) { 24774cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Load the value from the alloca. If the NewElt is an aggregate, cast 24784cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // the pointer to an integer of the same size before doing the load. 24794cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Value *SrcField = NewElts[i]; 2480db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *FieldTy = 24814cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner cast<PointerType>(SrcField->getType())->getElementType(); 24824cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner uint64_t FieldSizeBits = TD->getTypeSizeInBits(FieldTy); 24836974302e3ff20746268721959efed807c7711bfcBob Wilson 24844cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Ignore zero sized fields like {}, they obviously contain no data. 24854cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (FieldSizeBits == 0) continue; 24866974302e3ff20746268721959efed807c7711bfcBob Wilson 2487db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner IntegerType *FieldIntTy = IntegerType::get(LI->getContext(), 24884cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner FieldSizeBits); 24894cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (!FieldTy->isIntegerTy() && !FieldTy->isFloatingPointTy() && 24904cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner !FieldTy->isVectorTy()) 24914cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner SrcField = new BitCastInst(SrcField, 24924cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner PointerType::getUnqual(FieldIntTy), 24934cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner "", LI); 24944cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner SrcField = new LoadInst(SrcField, "sroa.load.elt", LI); 249529e641761e81bd000bdc4ccfae479c6dda18e402Chris Lattner 24964cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // If SrcField is a fp or vector of the right size but that isn't an 24974cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // integer type, bitcast to an integer so we can shift it. 24984cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (SrcField->getType() != FieldIntTy) 24994cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner SrcField = new BitCastInst(SrcField, FieldIntTy, "", LI); 250029e641761e81bd000bdc4ccfae479c6dda18e402Chris Lattner 25014cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Zero extend the field to be the same size as the final alloca so that 25024cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // we can shift and insert it. 25034cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (SrcField->getType() != ResultVal->getType()) 25044cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner SrcField = new ZExtInst(SrcField, ResultVal->getType(), "", LI); 25056974302e3ff20746268721959efed807c7711bfcBob Wilson 25064cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Determine the number of bits to shift SrcField. 25074cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner uint64_t Shift; 25084cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (Layout) // Struct case. 25094cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Shift = Layout->getElementOffsetInBits(i); 25104cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner else // Array case. 25114cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Shift = i*ArrayEltBitOffset; 25126974302e3ff20746268721959efed807c7711bfcBob Wilson 25134cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (TD->isBigEndian()) 25144cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Shift = AllocaSizeBits-Shift-FieldIntTy->getBitWidth(); 25156974302e3ff20746268721959efed807c7711bfcBob Wilson 25164cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (Shift) { 25174cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner Value *ShiftVal = ConstantInt::get(SrcField->getType(), Shift); 25184cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner SrcField = BinaryOperator::CreateShl(SrcField, ShiftVal, "", LI); 25199b872db775797dea4b391a9347cfbd2ca9c558e2Chris Lattner } 25204cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner 25211495247f517c0ac3aeeb9e6c7c0205dd7849d332Chris Lattner // Don't create an 'or x, 0' on the first iteration. 25221495247f517c0ac3aeeb9e6c7c0205dd7849d332Chris Lattner if (!isa<Constant>(ResultVal) || 25231495247f517c0ac3aeeb9e6c7c0205dd7849d332Chris Lattner !cast<Constant>(ResultVal)->isNullValue()) 25241495247f517c0ac3aeeb9e6c7c0205dd7849d332Chris Lattner ResultVal = BinaryOperator::CreateOr(SrcField, ResultVal, "", LI); 25251495247f517c0ac3aeeb9e6c7c0205dd7849d332Chris Lattner else 25261495247f517c0ac3aeeb9e6c7c0205dd7849d332Chris Lattner ResultVal = SrcField; 25279b872db775797dea4b391a9347cfbd2ca9c558e2Chris Lattner } 25284b3dfbd220835cbba519162712c9cb6afaa44059Duncan Sands 25294cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Handle tail padding by truncating the result 25304cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (TD->getTypeSizeInBits(LI->getType()) != AllocaSizeBits) 25314cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner ResultVal = new TruncInst(ResultVal, LI->getType(), "", LI); 25324b3dfbd220835cbba519162712c9cb6afaa44059Duncan Sands 25334cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner LI->replaceAllUsesWith(ResultVal); 25344cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner DeadInsts.push_back(LI); 25354cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner} 25364cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner 25374cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// HasPadding - Return true if the specified type has any structure or 2538694a10e7d8410f24639971224ce0e282c8cd04cbBob Wilson/// alignment padding in between the elements that would be split apart 2539694a10e7d8410f24639971224ce0e282c8cd04cbBob Wilson/// by SROA; return false otherwise. 2540db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattnerstatic bool HasPadding(Type *Ty, const TargetData &TD) { 2541db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner if (ArrayType *ATy = dyn_cast<ArrayType>(Ty)) { 2542694a10e7d8410f24639971224ce0e282c8cd04cbBob Wilson Ty = ATy->getElementType(); 2543694a10e7d8410f24639971224ce0e282c8cd04cbBob Wilson return TD.getTypeSizeInBits(Ty) != TD.getTypeAllocSizeInBits(Ty); 2544694a10e7d8410f24639971224ce0e282c8cd04cbBob Wilson } 25454cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner 2546694a10e7d8410f24639971224ce0e282c8cd04cbBob Wilson // SROA currently handles only Arrays and Structs. 2547db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner StructType *STy = cast<StructType>(Ty); 2548694a10e7d8410f24639971224ce0e282c8cd04cbBob Wilson const StructLayout *SL = TD.getStructLayout(STy); 2549694a10e7d8410f24639971224ce0e282c8cd04cbBob Wilson unsigned PrevFieldBitOffset = 0; 2550694a10e7d8410f24639971224ce0e282c8cd04cbBob Wilson for (unsigned i = 0, e = STy->getNumElements(); i != e; ++i) { 2551694a10e7d8410f24639971224ce0e282c8cd04cbBob Wilson unsigned FieldBitOffset = SL->getElementOffsetInBits(i); 2552694a10e7d8410f24639971224ce0e282c8cd04cbBob Wilson 2553694a10e7d8410f24639971224ce0e282c8cd04cbBob Wilson // Check to see if there is any padding between this element and the 2554694a10e7d8410f24639971224ce0e282c8cd04cbBob Wilson // previous one. 2555694a10e7d8410f24639971224ce0e282c8cd04cbBob Wilson if (i) { 2556694a10e7d8410f24639971224ce0e282c8cd04cbBob Wilson unsigned PrevFieldEnd = 25574cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner PrevFieldBitOffset+TD.getTypeSizeInBits(STy->getElementType(i-1)); 2558694a10e7d8410f24639971224ce0e282c8cd04cbBob Wilson if (PrevFieldEnd < FieldBitOffset) 25594cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner return true; 25604cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner } 2561694a10e7d8410f24639971224ce0e282c8cd04cbBob Wilson PrevFieldBitOffset = FieldBitOffset; 25622e0d5f84325303fa95997cd66485811bd0a6ef70Chris Lattner } 2563694a10e7d8410f24639971224ce0e282c8cd04cbBob Wilson // Check for tail padding. 2564694a10e7d8410f24639971224ce0e282c8cd04cbBob Wilson if (unsigned EltCount = STy->getNumElements()) { 2565694a10e7d8410f24639971224ce0e282c8cd04cbBob Wilson unsigned PrevFieldEnd = PrevFieldBitOffset + 2566694a10e7d8410f24639971224ce0e282c8cd04cbBob Wilson TD.getTypeSizeInBits(STy->getElementType(EltCount-1)); 2567694a10e7d8410f24639971224ce0e282c8cd04cbBob Wilson if (PrevFieldEnd < SL->getSizeInBits()) 2568694a10e7d8410f24639971224ce0e282c8cd04cbBob Wilson return true; 2569694a10e7d8410f24639971224ce0e282c8cd04cbBob Wilson } 2570694a10e7d8410f24639971224ce0e282c8cd04cbBob Wilson return false; 25714cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner} 25724b3dfbd220835cbba519162712c9cb6afaa44059Duncan Sands 25734cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// isSafeStructAllocaToScalarRepl - Check to see if the specified allocation of 25744cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// an aggregate can be broken down into elements. Return 0 if not, 3 if safe, 25754cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner/// or 1 if safe after canonicalization has been performed. 25764cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattnerbool SROA::isSafeAllocaToScalarRepl(AllocaInst *AI) { 25774cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Loop over the use list of the alloca. We can only transform it if all of 25784cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // the users are safe to transform. 25796c95d24927b11fb76bc3e76ebe6a8198d74fc178Chris Lattner AllocaInfo Info(AI); 25806974302e3ff20746268721959efed807c7711bfcBob Wilson 25816c95d24927b11fb76bc3e76ebe6a8198d74fc178Chris Lattner isSafeForScalarRepl(AI, 0, Info); 25824cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (Info.isUnsafe) { 25834cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner DEBUG(dbgs() << "Cannot transform: " << *AI << '\n'); 25844cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner return false; 2585800de31776356910eb877e71df9f32b0a6215324Chris Lattner } 25866974302e3ff20746268721959efed807c7711bfcBob Wilson 25874cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // Okay, we know all the users are promotable. If the aggregate is a memcpy 25884cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // source and destination, we have to be careful. In particular, the memcpy 25894cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // could be moving around elements that live in structure padding of the LLVM 25904cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // types, but may actually be used. In these cases, we refuse to promote the 25914cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner // struct. 25924cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner if (Info.isMemCpySrc && Info.isMemCpyDst && 25934cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner HasPadding(AI->getAllocatedType(), *TD)) 25944cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner return false; 25954cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner 2596396a0567cf959d86a8a1ad185e54d84f5dacbacfChris Lattner // If the alloca never has an access to just *part* of it, but is accessed 2597396a0567cf959d86a8a1ad185e54d84f5dacbacfChris Lattner // via loads and stores, then we should use ConvertToScalarInfo to promote 25987e9b427c879ae32b72fd24aeaf011e87e5692fd7Chris Lattner // the alloca instead of promoting each piece at a time and inserting fission 25997e9b427c879ae32b72fd24aeaf011e87e5692fd7Chris Lattner // and fusion code. 26007e9b427c879ae32b72fd24aeaf011e87e5692fd7Chris Lattner if (!Info.hasSubelementAccess && Info.hasALoadOrStore) { 26017e9b427c879ae32b72fd24aeaf011e87e5692fd7Chris Lattner // If the struct/array just has one element, use basic SRoA. 2602db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner if (StructType *ST = dyn_cast<StructType>(AI->getAllocatedType())) { 26037e9b427c879ae32b72fd24aeaf011e87e5692fd7Chris Lattner if (ST->getNumElements() > 1) return false; 26047e9b427c879ae32b72fd24aeaf011e87e5692fd7Chris Lattner } else { 26057e9b427c879ae32b72fd24aeaf011e87e5692fd7Chris Lattner if (cast<ArrayType>(AI->getAllocatedType())->getNumElements() > 1) 26067e9b427c879ae32b72fd24aeaf011e87e5692fd7Chris Lattner return false; 26077e9b427c879ae32b72fd24aeaf011e87e5692fd7Chris Lattner } 26087e9b427c879ae32b72fd24aeaf011e87e5692fd7Chris Lattner } 2609a94d6e87c4c49f2e81b01d66d8bfb591277f8f96Nadav Rotem 26104cc576bc5ea27951f3bb15ccefbe483293bf8eafChris Lattner return true; 2611800de31776356910eb877e71df9f32b0a6215324Chris Lattner} 2612