17a90b68e5c85fe11a4ccc386be9c5fcddd4a8b61Chris Lattner//===- GlobalOpt.cpp - Optimize Global Variables --------------------------===// 2fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman// 3079236d1c9909365ffd0ef06831523c87335bb4aChris Lattner// The LLVM Compiler Infrastructure 4079236d1c9909365ffd0ef06831523c87335bb4aChris Lattner// 54ee451de366474b9c228b4e5fa573795a715216dChris Lattner// This file is distributed under the University of Illinois Open Source 64ee451de366474b9c228b4e5fa573795a715216dChris Lattner// License. See LICENSE.TXT for details. 7fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman// 8079236d1c9909365ffd0ef06831523c87335bb4aChris Lattner//===----------------------------------------------------------------------===// 9079236d1c9909365ffd0ef06831523c87335bb4aChris Lattner// 107a90b68e5c85fe11a4ccc386be9c5fcddd4a8b61Chris Lattner// This pass transforms simple global variables that never have their address 117a90b68e5c85fe11a4ccc386be9c5fcddd4a8b61Chris Lattner// taken. If obviously true, it marks read/write globals as constant, deletes 127a90b68e5c85fe11a4ccc386be9c5fcddd4a8b61Chris Lattner// variables only stored to, etc. 13079236d1c9909365ffd0ef06831523c87335bb4aChris Lattner// 14079236d1c9909365ffd0ef06831523c87335bb4aChris Lattner//===----------------------------------------------------------------------===// 15079236d1c9909365ffd0ef06831523c87335bb4aChris Lattner 167a90b68e5c85fe11a4ccc386be9c5fcddd4a8b61Chris Lattner#define DEBUG_TYPE "globalopt" 17079236d1c9909365ffd0ef06831523c87335bb4aChris Lattner#include "llvm/Transforms/IPO.h" 18fb217adf92cbfd045614a652be63c710ce6a263dChris Lattner#include "llvm/CallingConv.h" 19079236d1c9909365ffd0ef06831523c87335bb4aChris Lattner#include "llvm/Constants.h" 207a90b68e5c85fe11a4ccc386be9c5fcddd4a8b61Chris Lattner#include "llvm/DerivedTypes.h" 217d90a2738e889efc5ff6e64c015c3b5cf5324affChris Lattner#include "llvm/Instructions.h" 2235c81b0b120f87373584f2e238e4d77f9d2ae88fChris Lattner#include "llvm/IntrinsicInst.h" 23079236d1c9909365ffd0ef06831523c87335bb4aChris Lattner#include "llvm/Module.h" 24562b84b3aea359d1f918184e355da82bf05eb290Jay Foad#include "llvm/Operator.h" 25079236d1c9909365ffd0ef06831523c87335bb4aChris Lattner#include "llvm/Pass.h" 2679066fa6acce02c97c714a5a6e151ed8a249721cChris Lattner#include "llvm/Analysis/ConstantFolding.h" 27f006b183e2d2bebcf6968d1dd7350397c95b0325Victor Hernandez#include "llvm/Analysis/MemoryBuiltins.h" 2830ba5690cf7a6f4db8913463d03f239f82d17440Chris Lattner#include "llvm/Target/TargetData.h" 2900737bdb488cc7157ca5f7a40d6cd8467ad09a79Chad Rosier#include "llvm/Target/TargetLibraryInfo.h" 30548448a317b39ec8446f3c82f44d01f938b921b2Duncan Sands#include "llvm/Support/CallSite.h" 3179066fa6acce02c97c714a5a6e151ed8a249721cChris Lattner#include "llvm/Support/Debug.h" 32c25e7581b9b8088910da31702d4ca21c4734c6d7Torok Edwin#include "llvm/Support/ErrorHandling.h" 33941db495b8233a3753ce72a84021f677073ff4eaChris Lattner#include "llvm/Support/GetElementPtrTypeIterator.h" 34998182b3802d2be8d081ca484b5d4fd5e1188950Chris Lattner#include "llvm/Support/MathExtras.h" 35ce63ffb52f249b62cdf2d250c128007b13f27e71Daniel Dunbar#include "llvm/Support/raw_ostream.h" 365a6bb6ae78fb42bedd8987ccd611abd0a548edbfChris Lattner#include "llvm/ADT/DenseMap.h" 37816861803fe4f5e17f565f00e70989ab24d7ec45Chris Lattner#include "llvm/ADT/SmallPtrSet.h" 3855eb1c47de30a6b4e8707b6392e878e32a6583e9Chris Lattner#include "llvm/ADT/SmallVector.h" 39551ccae044b0ff658fe629dd67edd5ffe75d10e8Reid Spencer#include "llvm/ADT/Statistic.h" 40bce4afe83968bf6504aaf0791d4c49f971d58c52Chris Lattner#include "llvm/ADT/STLExtras.h" 41e47ba74b07b2a6015239bcbabba09750580aecedChris Lattner#include <algorithm> 42079236d1c9909365ffd0ef06831523c87335bb4aChris Lattnerusing namespace llvm; 43079236d1c9909365ffd0ef06831523c87335bb4aChris Lattner 4486453c52ba02e743d29c08456e51006500041456Chris LattnerSTATISTIC(NumMarked , "Number of globals marked constant"); 45c4440e3e307fb696146c08c127c53300a982fe82Rafael EspindolaSTATISTIC(NumUnnamed , "Number of globals marked unnamed_addr"); 4686453c52ba02e743d29c08456e51006500041456Chris LattnerSTATISTIC(NumSRA , "Number of aggregate globals broken into scalars"); 4786453c52ba02e743d29c08456e51006500041456Chris LattnerSTATISTIC(NumHeapSRA , "Number of heap objects SRA'd"); 4886453c52ba02e743d29c08456e51006500041456Chris LattnerSTATISTIC(NumSubstitute,"Number of globals with initializers stored into them"); 4986453c52ba02e743d29c08456e51006500041456Chris LattnerSTATISTIC(NumDeleted , "Number of globals deleted"); 5086453c52ba02e743d29c08456e51006500041456Chris LattnerSTATISTIC(NumFnDeleted , "Number of functions deleted"); 5186453c52ba02e743d29c08456e51006500041456Chris LattnerSTATISTIC(NumGlobUses , "Number of global uses devirtualized"); 5286453c52ba02e743d29c08456e51006500041456Chris LattnerSTATISTIC(NumLocalized , "Number of globals localized"); 5386453c52ba02e743d29c08456e51006500041456Chris LattnerSTATISTIC(NumShrunkToBool , "Number of global vars shrunk to booleans"); 5486453c52ba02e743d29c08456e51006500041456Chris LattnerSTATISTIC(NumFastCallFns , "Number of functions converted to fastcc"); 5586453c52ba02e743d29c08456e51006500041456Chris LattnerSTATISTIC(NumCtorsEvaluated, "Number of static ctors evaluated"); 563d5378ff8e015e6ede4fd3d33c3e05a1dfec5b99Duncan SandsSTATISTIC(NumNestRemoved , "Number of nest attributes removed"); 574782b305c2ccc2b2e5a4cad65d7ffd15395d0727Duncan SandsSTATISTIC(NumAliasesResolved, "Number of global aliases resolved"); 584782b305c2ccc2b2e5a4cad65d7ffd15395d0727Duncan SandsSTATISTIC(NumAliasesRemoved, "Number of global aliases eliminated"); 59a201c4c2e604a519665ca55dc49e913628444ddbAnders CarlssonSTATISTIC(NumCXXDtorsRemoved, "Number of global C++ destructors removed"); 60079236d1c9909365ffd0ef06831523c87335bb4aChris Lattner 6186453c52ba02e743d29c08456e51006500041456Chris Lattnernamespace { 62c4440e3e307fb696146c08c127c53300a982fe82Rafael Espindola struct GlobalStatus; 636726b6d75a8b679068a58cb954ba97cf9d1690baNick Lewycky struct GlobalOpt : public ModulePass { 6430ba5690cf7a6f4db8913463d03f239f82d17440Chris Lattner virtual void getAnalysisUsage(AnalysisUsage &AU) const { 6500737bdb488cc7157ca5f7a40d6cd8467ad09a79Chad Rosier AU.addRequired<TargetLibraryInfo>(); 6630ba5690cf7a6f4db8913463d03f239f82d17440Chris Lattner } 67ecd94c804a563f2a86572dcf1d2e81f397e19daaNick Lewycky static char ID; // Pass identification, replacement for typeid 68081c34b725980f995be9080eaec24cd3dfaaf065Owen Anderson GlobalOpt() : ModulePass(ID) { 69081c34b725980f995be9080eaec24cd3dfaaf065Owen Anderson initializeGlobalOptPass(*PassRegistry::getPassRegistry()); 70081c34b725980f995be9080eaec24cd3dfaaf065Owen Anderson } 71fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman 72b12914bfc0f76a7a48357162d5f4c39a1343e69bChris Lattner bool runOnModule(Module &M); 7330ba5690cf7a6f4db8913463d03f239f82d17440Chris Lattner 7430ba5690cf7a6f4db8913463d03f239f82d17440Chris Lattner private: 75b1ab4580478c90375abec5e2b6e89dc1a15fa98bChris Lattner GlobalVariable *FindGlobalCtors(Module &M); 76b1ab4580478c90375abec5e2b6e89dc1a15fa98bChris Lattner bool OptimizeFunctions(Module &M); 77b1ab4580478c90375abec5e2b6e89dc1a15fa98bChris Lattner bool OptimizeGlobalVars(Module &M); 78fc5940d2a09a795e683ae86b237d6f55fb3551d4Duncan Sands bool OptimizeGlobalAliases(Module &M); 79b1ab4580478c90375abec5e2b6e89dc1a15fa98bChris Lattner bool OptimizeGlobalCtorsList(GlobalVariable *&GCL); 80c4440e3e307fb696146c08c127c53300a982fe82Rafael Espindola bool ProcessGlobal(GlobalVariable *GV,Module::global_iterator &GVI); 81c4440e3e307fb696146c08c127c53300a982fe82Rafael Espindola bool ProcessInternalGlobal(GlobalVariable *GV,Module::global_iterator &GVI, 82c4440e3e307fb696146c08c127c53300a982fe82Rafael Espindola const SmallPtrSet<const PHINode*, 16> &PHIUsers, 83c4440e3e307fb696146c08c127c53300a982fe82Rafael Espindola const GlobalStatus &GS); 84a201c4c2e604a519665ca55dc49e913628444ddbAnders Carlsson bool OptimizeEmptyGlobalCXXDtors(Function *CXAAtExitFn); 856a577f82ba56a4da48e984702240a01c3ba7e941Nick Lewycky 866a577f82ba56a4da48e984702240a01c3ba7e941Nick Lewycky TargetData *TD; 876a577f82ba56a4da48e984702240a01c3ba7e941Nick Lewycky TargetLibraryInfo *TLI; 88079236d1c9909365ffd0ef06831523c87335bb4aChris Lattner }; 899ce300013d5c5b9e2c7e26626ddbc8f3a42bdb88Chris Lattner} 909ce300013d5c5b9e2c7e26626ddbc8f3a42bdb88Chris Lattner 91844731a7f1909f55935e3514c9e713a62d67662eDan Gohmanchar GlobalOpt::ID = 0; 9200737bdb488cc7157ca5f7a40d6cd8467ad09a79Chad RosierINITIALIZE_PASS_BEGIN(GlobalOpt, "globalopt", 9300737bdb488cc7157ca5f7a40d6cd8467ad09a79Chad Rosier "Global Variable Optimizer", false, false) 9400737bdb488cc7157ca5f7a40d6cd8467ad09a79Chad RosierINITIALIZE_PASS_DEPENDENCY(TargetLibraryInfo) 9500737bdb488cc7157ca5f7a40d6cd8467ad09a79Chad RosierINITIALIZE_PASS_END(GlobalOpt, "globalopt", 96ce665bd2e2b581ab0858d1afe359192bac96b868Owen Anderson "Global Variable Optimizer", false, false) 97844731a7f1909f55935e3514c9e713a62d67662eDan Gohman 987a90b68e5c85fe11a4ccc386be9c5fcddd4a8b61Chris LattnerModulePass *llvm::createGlobalOptimizerPass() { return new GlobalOpt(); } 997a90b68e5c85fe11a4ccc386be9c5fcddd4a8b61Chris Lattner 100844731a7f1909f55935e3514c9e713a62d67662eDan Gohmannamespace { 101844731a7f1909f55935e3514c9e713a62d67662eDan Gohman 1027a90b68e5c85fe11a4ccc386be9c5fcddd4a8b61Chris Lattner/// GlobalStatus - As we analyze each global, keep track of some information 1037a90b68e5c85fe11a4ccc386be9c5fcddd4a8b61Chris Lattner/// about it. If we find out that the address of the global is taken, none of 104cf4d2a569972b5b4f0978e88fa775870dabcfed0Chris Lattner/// this info will be accurate. 1056726b6d75a8b679068a58cb954ba97cf9d1690baNick Lewyckystruct GlobalStatus { 106c4440e3e307fb696146c08c127c53300a982fe82Rafael Espindola /// isCompared - True if the global's address is used in a comparison. 107c4440e3e307fb696146c08c127c53300a982fe82Rafael Espindola bool isCompared; 108c4440e3e307fb696146c08c127c53300a982fe82Rafael Espindola 109cf4d2a569972b5b4f0978e88fa775870dabcfed0Chris Lattner /// isLoaded - True if the global is ever loaded. If the global isn't ever 110cf4d2a569972b5b4f0978e88fa775870dabcfed0Chris Lattner /// loaded it can be deleted. 1117a90b68e5c85fe11a4ccc386be9c5fcddd4a8b61Chris Lattner bool isLoaded; 112cf4d2a569972b5b4f0978e88fa775870dabcfed0Chris Lattner 113cf4d2a569972b5b4f0978e88fa775870dabcfed0Chris Lattner /// StoredType - Keep track of what stores to the global look like. 114cf4d2a569972b5b4f0978e88fa775870dabcfed0Chris Lattner /// 1157a90b68e5c85fe11a4ccc386be9c5fcddd4a8b61Chris Lattner enum StoredType { 116cf4d2a569972b5b4f0978e88fa775870dabcfed0Chris Lattner /// NotStored - There is no store to this global. It can thus be marked 117cf4d2a569972b5b4f0978e88fa775870dabcfed0Chris Lattner /// constant. 118cf4d2a569972b5b4f0978e88fa775870dabcfed0Chris Lattner NotStored, 119cf4d2a569972b5b4f0978e88fa775870dabcfed0Chris Lattner 120cf4d2a569972b5b4f0978e88fa775870dabcfed0Chris Lattner /// isInitializerStored - This global is stored to, but the only thing 121cf4d2a569972b5b4f0978e88fa775870dabcfed0Chris Lattner /// stored is the constant it was initialized with. This is only tracked 122cf4d2a569972b5b4f0978e88fa775870dabcfed0Chris Lattner /// for scalar globals. 123cf4d2a569972b5b4f0978e88fa775870dabcfed0Chris Lattner isInitializerStored, 124cf4d2a569972b5b4f0978e88fa775870dabcfed0Chris Lattner 125cf4d2a569972b5b4f0978e88fa775870dabcfed0Chris Lattner /// isStoredOnce - This global is stored to, but only its initializer and 126cf4d2a569972b5b4f0978e88fa775870dabcfed0Chris Lattner /// one other value is ever stored to it. If this global isStoredOnce, we 127cf4d2a569972b5b4f0978e88fa775870dabcfed0Chris Lattner /// track the value stored to it in StoredOnceValue below. This is only 128cf4d2a569972b5b4f0978e88fa775870dabcfed0Chris Lattner /// tracked for scalar globals. 129cf4d2a569972b5b4f0978e88fa775870dabcfed0Chris Lattner isStoredOnce, 130cf4d2a569972b5b4f0978e88fa775870dabcfed0Chris Lattner 131cf4d2a569972b5b4f0978e88fa775870dabcfed0Chris Lattner /// isStored - This global is stored to by multiple values or something else 132cf4d2a569972b5b4f0978e88fa775870dabcfed0Chris Lattner /// that we cannot track. 133cf4d2a569972b5b4f0978e88fa775870dabcfed0Chris Lattner isStored 1347a90b68e5c85fe11a4ccc386be9c5fcddd4a8b61Chris Lattner } StoredType; 135cf4d2a569972b5b4f0978e88fa775870dabcfed0Chris Lattner 136cf4d2a569972b5b4f0978e88fa775870dabcfed0Chris Lattner /// StoredOnceValue - If only one value (besides the initializer constant) is 137cf4d2a569972b5b4f0978e88fa775870dabcfed0Chris Lattner /// ever stored to this global, keep track of what value it is. 138cf4d2a569972b5b4f0978e88fa775870dabcfed0Chris Lattner Value *StoredOnceValue; 139cf4d2a569972b5b4f0978e88fa775870dabcfed0Chris Lattner 14025de4e5c21b8ef1bbf6d625de548ca3508c58947Chris Lattner /// AccessingFunction/HasMultipleAccessingFunctions - These start out 14125de4e5c21b8ef1bbf6d625de548ca3508c58947Chris Lattner /// null/false. When the first accessing function is noticed, it is recorded. 14225de4e5c21b8ef1bbf6d625de548ca3508c58947Chris Lattner /// When a second different accessing function is noticed, 14325de4e5c21b8ef1bbf6d625de548ca3508c58947Chris Lattner /// HasMultipleAccessingFunctions is set to true. 144c8b82ccbcf3b2e2384d2c0b5176e7b0b40b7f82fGabor Greif const Function *AccessingFunction; 145f64ea9d1221f52c47fed2ea86a74946c05f224adAlkis Evlogimenos bool HasMultipleAccessingFunctions; 146f64ea9d1221f52c47fed2ea86a74946c05f224adAlkis Evlogimenos 14725de4e5c21b8ef1bbf6d625de548ca3508c58947Chris Lattner /// HasNonInstructionUser - Set to true if this global has a user that is not 14825de4e5c21b8ef1bbf6d625de548ca3508c58947Chris Lattner /// an instruction (e.g. a constant expr or GV initializer). 149553ca5262361e520f98a72d1a109d6b10d1918eeChris Lattner bool HasNonInstructionUser; 150553ca5262361e520f98a72d1a109d6b10d1918eeChris Lattner 15125de4e5c21b8ef1bbf6d625de548ca3508c58947Chris Lattner /// HasPHIUser - Set to true if this global has a user that is a PHI node. 15225de4e5c21b8ef1bbf6d625de548ca3508c58947Chris Lattner bool HasPHIUser; 1539d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 154fad4d40f3792b0d9e101c40738e1f691131007d2Nick Lewycky /// AtomicOrdering - Set to the strongest atomic ordering requirement. 155fad4d40f3792b0d9e101c40738e1f691131007d2Nick Lewycky AtomicOrdering Ordering; 156fad4d40f3792b0d9e101c40738e1f691131007d2Nick Lewycky 157c4440e3e307fb696146c08c127c53300a982fe82Rafael Espindola GlobalStatus() : isCompared(false), isLoaded(false), StoredType(NotStored), 158c4440e3e307fb696146c08c127c53300a982fe82Rafael Espindola StoredOnceValue(0), AccessingFunction(0), 159fad4d40f3792b0d9e101c40738e1f691131007d2Nick Lewycky HasMultipleAccessingFunctions(false), 160fad4d40f3792b0d9e101c40738e1f691131007d2Nick Lewycky HasNonInstructionUser(false), HasPHIUser(false), 161fad4d40f3792b0d9e101c40738e1f691131007d2Nick Lewycky Ordering(NotAtomic) {} 1627a90b68e5c85fe11a4ccc386be9c5fcddd4a8b61Chris Lattner}; 1637a90b68e5c85fe11a4ccc386be9c5fcddd4a8b61Chris Lattner 164844731a7f1909f55935e3514c9e713a62d67662eDan Gohman} 165a4be1dc0a192175bbc561a633c0b7197853e6a74Chris Lattner 166fad4d40f3792b0d9e101c40738e1f691131007d2Nick Lewycky/// StrongerOrdering - Return the stronger of the two ordering. If the two 167fad4d40f3792b0d9e101c40738e1f691131007d2Nick Lewycky/// orderings are acquire and release, then return AcquireRelease. 168fad4d40f3792b0d9e101c40738e1f691131007d2Nick Lewycky/// 169fad4d40f3792b0d9e101c40738e1f691131007d2Nick Lewyckystatic AtomicOrdering StrongerOrdering(AtomicOrdering X, AtomicOrdering Y) { 170fad4d40f3792b0d9e101c40738e1f691131007d2Nick Lewycky if (X == Acquire && Y == Release) return AcquireRelease; 171fad4d40f3792b0d9e101c40738e1f691131007d2Nick Lewycky if (Y == Acquire && X == Release) return AcquireRelease; 172fad4d40f3792b0d9e101c40738e1f691131007d2Nick Lewycky return (AtomicOrdering)std::max(X, Y); 173fad4d40f3792b0d9e101c40738e1f691131007d2Nick Lewycky} 174fad4d40f3792b0d9e101c40738e1f691131007d2Nick Lewycky 175bc384a1feb08141691ef994a7d11a506e89c5a62Nick Lewycky/// SafeToDestroyConstant - It is safe to destroy a constant iff it is only used 176bc384a1feb08141691ef994a7d11a506e89c5a62Nick Lewycky/// by constants itself. Note that constants cannot be cyclic, so this test is 177bc384a1feb08141691ef994a7d11a506e89c5a62Nick Lewycky/// pretty easy to implement recursively. 178bc384a1feb08141691ef994a7d11a506e89c5a62Nick Lewycky/// 179c8b82ccbcf3b2e2384d2c0b5176e7b0b40b7f82fGabor Greifstatic bool SafeToDestroyConstant(const Constant *C) { 180a4be1dc0a192175bbc561a633c0b7197853e6a74Chris Lattner if (isa<GlobalValue>(C)) return false; 181a4be1dc0a192175bbc561a633c0b7197853e6a74Chris Lattner 182272369149209bad11f2b2f9020362f77fae60579Gabor Greif for (Value::const_use_iterator UI = C->use_begin(), E = C->use_end(); UI != E; 183272369149209bad11f2b2f9020362f77fae60579Gabor Greif ++UI) 184c8b82ccbcf3b2e2384d2c0b5176e7b0b40b7f82fGabor Greif if (const Constant *CU = dyn_cast<Constant>(*UI)) { 185e3acf159d968b5a9db350203d8160a4d3c2d1a43Jay Foad if (!SafeToDestroyConstant(CU)) return false; 186a4be1dc0a192175bbc561a633c0b7197853e6a74Chris Lattner } else 187a4be1dc0a192175bbc561a633c0b7197853e6a74Chris Lattner return false; 188a4be1dc0a192175bbc561a633c0b7197853e6a74Chris Lattner return true; 189a4be1dc0a192175bbc561a633c0b7197853e6a74Chris Lattner} 190a4be1dc0a192175bbc561a633c0b7197853e6a74Chris Lattner 191a4be1dc0a192175bbc561a633c0b7197853e6a74Chris Lattner 1927a90b68e5c85fe11a4ccc386be9c5fcddd4a8b61Chris Lattner/// AnalyzeGlobal - Look at all uses of the global and fill in the GlobalStatus 1937a90b68e5c85fe11a4ccc386be9c5fcddd4a8b61Chris Lattner/// structure. If the global has its address taken, return true to indicate we 1947a90b68e5c85fe11a4ccc386be9c5fcddd4a8b61Chris Lattner/// can't do anything with it. 195079236d1c9909365ffd0ef06831523c87335bb4aChris Lattner/// 196c8b82ccbcf3b2e2384d2c0b5176e7b0b40b7f82fGabor Greifstatic bool AnalyzeGlobal(const Value *V, GlobalStatus &GS, 197c8b82ccbcf3b2e2384d2c0b5176e7b0b40b7f82fGabor Greif SmallPtrSet<const PHINode*, 16> &PHIUsers) { 198272369149209bad11f2b2f9020362f77fae60579Gabor Greif for (Value::const_use_iterator UI = V->use_begin(), E = V->use_end(); UI != E; 199e664267ae7af018a5e3802667e5420f8e8282888Gabor Greif ++UI) { 200e664267ae7af018a5e3802667e5420f8e8282888Gabor Greif const User *U = *UI; 201e664267ae7af018a5e3802667e5420f8e8282888Gabor Greif if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(U)) { 202553ca5262361e520f98a72d1a109d6b10d1918eeChris Lattner GS.HasNonInstructionUser = true; 203d91ed10b7028c8470c8a9b7fa61a712d04ab07d9Chris Lattner 204d91ed10b7028c8470c8a9b7fa61a712d04ab07d9Chris Lattner // If the result of the constantexpr isn't pointer type, then we won't 205d91ed10b7028c8470c8a9b7fa61a712d04ab07d9Chris Lattner // know to expect it in various places. Just reject early. 206d91ed10b7028c8470c8a9b7fa61a712d04ab07d9Chris Lattner if (!isa<PointerType>(CE->getType())) return true; 207d91ed10b7028c8470c8a9b7fa61a712d04ab07d9Chris Lattner 2087a90b68e5c85fe11a4ccc386be9c5fcddd4a8b61Chris Lattner if (AnalyzeGlobal(CE, GS, PHIUsers)) return true; 209e664267ae7af018a5e3802667e5420f8e8282888Gabor Greif } else if (const Instruction *I = dyn_cast<Instruction>(U)) { 210f64ea9d1221f52c47fed2ea86a74946c05f224adAlkis Evlogimenos if (!GS.HasMultipleAccessingFunctions) { 211c8b82ccbcf3b2e2384d2c0b5176e7b0b40b7f82fGabor Greif const Function *F = I->getParent()->getParent(); 212f64ea9d1221f52c47fed2ea86a74946c05f224adAlkis Evlogimenos if (GS.AccessingFunction == 0) 213f64ea9d1221f52c47fed2ea86a74946c05f224adAlkis Evlogimenos GS.AccessingFunction = F; 214f64ea9d1221f52c47fed2ea86a74946c05f224adAlkis Evlogimenos else if (GS.AccessingFunction != F) 215f64ea9d1221f52c47fed2ea86a74946c05f224adAlkis Evlogimenos GS.HasMultipleAccessingFunctions = true; 216f64ea9d1221f52c47fed2ea86a74946c05f224adAlkis Evlogimenos } 217c8b82ccbcf3b2e2384d2c0b5176e7b0b40b7f82fGabor Greif if (const LoadInst *LI = dyn_cast<LoadInst>(I)) { 2187a90b68e5c85fe11a4ccc386be9c5fcddd4a8b61Chris Lattner GS.isLoaded = true; 219fad4d40f3792b0d9e101c40738e1f691131007d2Nick Lewycky // Don't hack on volatile loads. 220fad4d40f3792b0d9e101c40738e1f691131007d2Nick Lewycky if (LI->isVolatile()) return true; 221fad4d40f3792b0d9e101c40738e1f691131007d2Nick Lewycky GS.Ordering = StrongerOrdering(GS.Ordering, LI->getOrdering()); 222c8b82ccbcf3b2e2384d2c0b5176e7b0b40b7f82fGabor Greif } else if (const StoreInst *SI = dyn_cast<StoreInst>(I)) { 2233602549c3dbce144bdfc5b0db784c60880a3062fChris Lattner // Don't allow a store OF the address, only stores TO the address. 2243602549c3dbce144bdfc5b0db784c60880a3062fChris Lattner if (SI->getOperand(0) == V) return true; 2253602549c3dbce144bdfc5b0db784c60880a3062fChris Lattner 226fad4d40f3792b0d9e101c40738e1f691131007d2Nick Lewycky // Don't hack on volatile stores. 227fad4d40f3792b0d9e101c40738e1f691131007d2Nick Lewycky if (SI->isVolatile()) return true; 228fad4d40f3792b0d9e101c40738e1f691131007d2Nick Lewycky GS.Ordering = StrongerOrdering(GS.Ordering, SI->getOrdering()); 229c69d3c94425cbdcbfe4f758e07ba083d3377a382Chris Lattner 230cf4d2a569972b5b4f0978e88fa775870dabcfed0Chris Lattner // If this is a direct store to the global (i.e., the global is a scalar 231cf4d2a569972b5b4f0978e88fa775870dabcfed0Chris Lattner // value, not an aggregate), keep more specific information about 232cf4d2a569972b5b4f0978e88fa775870dabcfed0Chris Lattner // stores. 23307e6e56f57e8781a8d7bc601cc9034a3741d84c2Anton Korobeynikov if (GS.StoredType != GlobalStatus::isStored) { 234272369149209bad11f2b2f9020362f77fae60579Gabor Greif if (const GlobalVariable *GV = dyn_cast<GlobalVariable>( 235272369149209bad11f2b2f9020362f77fae60579Gabor Greif SI->getOperand(1))) { 236bd38edfe236944ebecbbf84ef9ea75d5412737b5Chris Lattner Value *StoredVal = SI->getOperand(0); 237bd38edfe236944ebecbbf84ef9ea75d5412737b5Chris Lattner if (StoredVal == GV->getInitializer()) { 238bd38edfe236944ebecbbf84ef9ea75d5412737b5Chris Lattner if (GS.StoredType < GlobalStatus::isInitializerStored) 239bd38edfe236944ebecbbf84ef9ea75d5412737b5Chris Lattner GS.StoredType = GlobalStatus::isInitializerStored; 240bd38edfe236944ebecbbf84ef9ea75d5412737b5Chris Lattner } else if (isa<LoadInst>(StoredVal) && 241bd38edfe236944ebecbbf84ef9ea75d5412737b5Chris Lattner cast<LoadInst>(StoredVal)->getOperand(0) == GV) { 242cf4d2a569972b5b4f0978e88fa775870dabcfed0Chris Lattner if (GS.StoredType < GlobalStatus::isInitializerStored) 243cf4d2a569972b5b4f0978e88fa775870dabcfed0Chris Lattner GS.StoredType = GlobalStatus::isInitializerStored; 244cf4d2a569972b5b4f0978e88fa775870dabcfed0Chris Lattner } else if (GS.StoredType < GlobalStatus::isStoredOnce) { 245cf4d2a569972b5b4f0978e88fa775870dabcfed0Chris Lattner GS.StoredType = GlobalStatus::isStoredOnce; 246bd38edfe236944ebecbbf84ef9ea75d5412737b5Chris Lattner GS.StoredOnceValue = StoredVal; 247cf4d2a569972b5b4f0978e88fa775870dabcfed0Chris Lattner } else if (GS.StoredType == GlobalStatus::isStoredOnce && 248bd38edfe236944ebecbbf84ef9ea75d5412737b5Chris Lattner GS.StoredOnceValue == StoredVal) { 249cf4d2a569972b5b4f0978e88fa775870dabcfed0Chris Lattner // noop. 250cf4d2a569972b5b4f0978e88fa775870dabcfed0Chris Lattner } else { 251cf4d2a569972b5b4f0978e88fa775870dabcfed0Chris Lattner GS.StoredType = GlobalStatus::isStored; 252cf4d2a569972b5b4f0978e88fa775870dabcfed0Chris Lattner } 253cf4d2a569972b5b4f0978e88fa775870dabcfed0Chris Lattner } else { 2547a90b68e5c85fe11a4ccc386be9c5fcddd4a8b61Chris Lattner GS.StoredType = GlobalStatus::isStored; 255cf4d2a569972b5b4f0978e88fa775870dabcfed0Chris Lattner } 25607e6e56f57e8781a8d7bc601cc9034a3741d84c2Anton Korobeynikov } 257b2fe7f183d54d7e93880c8a472e0145e13dce070Duncan Sands } else if (isa<BitCastInst>(I)) { 258b2fe7f183d54d7e93880c8a472e0145e13dce070Duncan Sands if (AnalyzeGlobal(I, GS, PHIUsers)) return true; 25935c81b0b120f87373584f2e238e4d77f9d2ae88fChris Lattner } else if (isa<GetElementPtrInst>(I)) { 2607a90b68e5c85fe11a4ccc386be9c5fcddd4a8b61Chris Lattner if (AnalyzeGlobal(I, GS, PHIUsers)) return true; 26135c81b0b120f87373584f2e238e4d77f9d2ae88fChris Lattner } else if (isa<SelectInst>(I)) { 2627a90b68e5c85fe11a4ccc386be9c5fcddd4a8b61Chris Lattner if (AnalyzeGlobal(I, GS, PHIUsers)) return true; 263c8b82ccbcf3b2e2384d2c0b5176e7b0b40b7f82fGabor Greif } else if (const PHINode *PN = dyn_cast<PHINode>(I)) { 2647a90b68e5c85fe11a4ccc386be9c5fcddd4a8b61Chris Lattner // PHI nodes we can check just like select or GEP instructions, but we 2657a90b68e5c85fe11a4ccc386be9c5fcddd4a8b61Chris Lattner // have to be careful about infinite recursion. 2665a6bb6ae78fb42bedd8987ccd611abd0a548edbfChris Lattner if (PHIUsers.insert(PN)) // Not already visited. 2677a90b68e5c85fe11a4ccc386be9c5fcddd4a8b61Chris Lattner if (AnalyzeGlobal(I, GS, PHIUsers)) return true; 26825de4e5c21b8ef1bbf6d625de548ca3508c58947Chris Lattner GS.HasPHIUser = true; 269e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer } else if (isa<CmpInst>(I)) { 270c4440e3e307fb696146c08c127c53300a982fe82Rafael Espindola GS.isCompared = true; 2711f237b00279ada1ccce35ab924a7f797d9dea25dNick Lewycky } else if (const MemTransferInst *MTI = dyn_cast<MemTransferInst>(I)) { 2721f237b00279ada1ccce35ab924a7f797d9dea25dNick Lewycky if (MTI->isVolatile()) return true; 2739e4f243de7c0a41ae02c93f7209ad97935e9853dGabor Greif if (MTI->getArgOperand(0) == V) 274551754c4958086cc6910da7c950f2875e212f5cfEric Christopher GS.StoredType = GlobalStatus::isStored; 2759e4f243de7c0a41ae02c93f7209ad97935e9853dGabor Greif if (MTI->getArgOperand(1) == V) 27635c81b0b120f87373584f2e238e4d77f9d2ae88fChris Lattner GS.isLoaded = true; 2771f237b00279ada1ccce35ab924a7f797d9dea25dNick Lewycky } else if (const MemSetInst *MSI = dyn_cast<MemSetInst>(I)) { 2781f237b00279ada1ccce35ab924a7f797d9dea25dNick Lewycky assert(MSI->getArgOperand(0) == V && "Memset only takes one pointer!"); 2791f237b00279ada1ccce35ab924a7f797d9dea25dNick Lewycky if (MSI->isVolatile()) return true; 28035c81b0b120f87373584f2e238e4d77f9d2ae88fChris Lattner GS.StoredType = GlobalStatus::isStored; 2817a90b68e5c85fe11a4ccc386be9c5fcddd4a8b61Chris Lattner } else { 2827a90b68e5c85fe11a4ccc386be9c5fcddd4a8b61Chris Lattner return true; // Any other non-load instruction might take address! 2839ce300013d5c5b9e2c7e26626ddbc8f3a42bdb88Chris Lattner } 284e664267ae7af018a5e3802667e5420f8e8282888Gabor Greif } else if (const Constant *C = dyn_cast<Constant>(U)) { 285553ca5262361e520f98a72d1a109d6b10d1918eeChris Lattner GS.HasNonInstructionUser = true; 286a4be1dc0a192175bbc561a633c0b7197853e6a74Chris Lattner // We might have a dead and dangling constant hanging off of here. 287e3acf159d968b5a9db350203d8160a4d3c2d1a43Jay Foad if (!SafeToDestroyConstant(C)) 288a4be1dc0a192175bbc561a633c0b7197853e6a74Chris Lattner return true; 289079236d1c9909365ffd0ef06831523c87335bb4aChris Lattner } else { 290553ca5262361e520f98a72d1a109d6b10d1918eeChris Lattner GS.HasNonInstructionUser = true; 291553ca5262361e520f98a72d1a109d6b10d1918eeChris Lattner // Otherwise must be some other user. 292079236d1c9909365ffd0ef06831523c87335bb4aChris Lattner return true; 293079236d1c9909365ffd0ef06831523c87335bb4aChris Lattner } 294e664267ae7af018a5e3802667e5420f8e8282888Gabor Greif } 295079236d1c9909365ffd0ef06831523c87335bb4aChris Lattner 296079236d1c9909365ffd0ef06831523c87335bb4aChris Lattner return false; 297079236d1c9909365ffd0ef06831523c87335bb4aChris Lattner} 298079236d1c9909365ffd0ef06831523c87335bb4aChris Lattner 2998899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky/// isLeakCheckerRoot - Is this global variable possibly used by a leak checker 3008899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky/// as a root? If so, we might not really want to eliminate the stores to it. 3018899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewyckystatic bool isLeakCheckerRoot(GlobalVariable *GV) { 3028899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky // A global variable is a root if it is a pointer, or could plausibly contain 3038899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky // a pointer. There are two challenges; one is that we could have a struct 3048899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky // the has an inner member which is a pointer. We recurse through the type to 3058899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky // detect these (up to a point). The other is that we may actually be a union 3068899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky // of a pointer and another type, and so our LLVM type is an integer which 3078899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky // gets converted into a pointer, or our type is an [i8 x #] with a pointer 3088899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky // potentially contained here. 3098899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky 3108899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky if (GV->hasPrivateLinkage()) 3118899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky return false; 3128899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky 3138899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky SmallVector<Type *, 4> Types; 3148899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky Types.push_back(cast<PointerType>(GV->getType())->getElementType()); 3158899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky 3168899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky unsigned Limit = 20; 3178899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky do { 3188899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky Type *Ty = Types.pop_back_val(); 3198899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky switch (Ty->getTypeID()) { 3208899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky default: break; 3218899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky case Type::PointerTyID: return true; 3228899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky case Type::ArrayTyID: 3238899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky case Type::VectorTyID: { 3248899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky SequentialType *STy = cast<SequentialType>(Ty); 3258899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky Types.push_back(STy->getElementType()); 3268899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky break; 3278899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky } 3288899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky case Type::StructTyID: { 3298899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky StructType *STy = cast<StructType>(Ty); 3308899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky if (STy->isOpaque()) return true; 3318899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky for (StructType::element_iterator I = STy->element_begin(), 3328899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky E = STy->element_end(); I != E; ++I) { 3338899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky Type *InnerTy = *I; 3348899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky if (isa<PointerType>(InnerTy)) return true; 3358899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky if (isa<CompositeType>(InnerTy)) 3368899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky Types.push_back(InnerTy); 3378899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky } 3388899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky break; 3398899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky } 3408899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky } 3418899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky if (--Limit == 0) return true; 3428899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky } while (!Types.empty()); 3438899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky return false; 3448899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky} 3458899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky 3468899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky/// Given a value that is stored to a global but never read, determine whether 3478899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky/// it's safe to remove the store and the chain of computation that feeds the 3488899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky/// store. 3498e0d1c03ca7fd86e6879b4e37d0d7f0e982feef6Benjamin Kramerstatic bool IsSafeComputationToRemove(Value *V, const TargetLibraryInfo *TLI) { 3508899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky do { 3518899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky if (isa<Constant>(V)) 3528899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky return true; 3538899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky if (!V->hasOneUse()) 3548899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky return false; 355b8cd66b5d78eaeba41ab372aaca5180dd54e4385Nick Lewycky if (isa<LoadInst>(V) || isa<InvokeInst>(V) || isa<Argument>(V) || 356b8cd66b5d78eaeba41ab372aaca5180dd54e4385Nick Lewycky isa<GlobalValue>(V)) 3578899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky return false; 3588e0d1c03ca7fd86e6879b4e37d0d7f0e982feef6Benjamin Kramer if (isAllocationFn(V, TLI)) 3598899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky return true; 3608899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky 3618899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky Instruction *I = cast<Instruction>(V); 3628899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky if (I->mayHaveSideEffects()) 3638899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky return false; 3648899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky if (GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(I)) { 3658899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky if (!GEP->hasAllConstantIndices()) 3668899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky return false; 3678899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky } else if (I->getNumOperands() != 1) { 3688899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky return false; 3698899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky } 3708899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky 3718899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky V = I->getOperand(0); 3728899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky } while (1); 3738899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky} 3748899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky 3758899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky/// CleanupPointerRootUsers - This GV is a pointer root. Loop over all users 3768899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky/// of the global and clean up any that obviously don't assign the global a 3778899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky/// value that isn't dynamically allocated. 3788899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky/// 3798e0d1c03ca7fd86e6879b4e37d0d7f0e982feef6Benjamin Kramerstatic bool CleanupPointerRootUsers(GlobalVariable *GV, 3808e0d1c03ca7fd86e6879b4e37d0d7f0e982feef6Benjamin Kramer const TargetLibraryInfo *TLI) { 3818899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky // A brief explanation of leak checkers. The goal is to find bugs where 3828899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky // pointers are forgotten, causing an accumulating growth in memory 3838899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky // usage over time. The common strategy for leak checkers is to whitelist the 3848899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky // memory pointed to by globals at exit. This is popular because it also 3858899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky // solves another problem where the main thread of a C++ program may shut down 3868899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky // before other threads that are still expecting to use those globals. To 3878899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky // handle that case, we expect the program may create a singleton and never 3888899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky // destroy it. 3898899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky 3908899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky bool Changed = false; 3918899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky 3928899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky // If Dead[n].first is the only use of a malloc result, we can delete its 3938899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky // chain of computation and the store to the global in Dead[n].second. 3948899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky SmallVector<std::pair<Instruction *, Instruction *>, 32> Dead; 3958899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky 3968899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky // Constants can't be pointers to dynamically allocated memory. 3978899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky for (Value::use_iterator UI = GV->use_begin(), E = GV->use_end(); 3988899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky UI != E;) { 3998899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky User *U = *UI++; 4008899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky if (StoreInst *SI = dyn_cast<StoreInst>(U)) { 4018899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky Value *V = SI->getValueOperand(); 4028899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky if (isa<Constant>(V)) { 4038899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky Changed = true; 4048899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky SI->eraseFromParent(); 4058899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky } else if (Instruction *I = dyn_cast<Instruction>(V)) { 4068899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky if (I->hasOneUse()) 4078899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky Dead.push_back(std::make_pair(I, SI)); 4088899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky } 4098899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky } else if (MemSetInst *MSI = dyn_cast<MemSetInst>(U)) { 4108899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky if (isa<Constant>(MSI->getValue())) { 4118899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky Changed = true; 4128899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky MSI->eraseFromParent(); 4138899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky } else if (Instruction *I = dyn_cast<Instruction>(MSI->getValue())) { 4148899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky if (I->hasOneUse()) 4158899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky Dead.push_back(std::make_pair(I, MSI)); 4168899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky } 4178899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky } else if (MemTransferInst *MTI = dyn_cast<MemTransferInst>(U)) { 4188899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky GlobalVariable *MemSrc = dyn_cast<GlobalVariable>(MTI->getSource()); 4198899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky if (MemSrc && MemSrc->isConstant()) { 4208899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky Changed = true; 4218899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky MTI->eraseFromParent(); 4228899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky } else if (Instruction *I = dyn_cast<Instruction>(MemSrc)) { 4238899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky if (I->hasOneUse()) 4248899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky Dead.push_back(std::make_pair(I, MTI)); 4258899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky } 4268899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky } else if (ConstantExpr *CE = dyn_cast<ConstantExpr>(U)) { 4278899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky if (CE->use_empty()) { 4288899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky CE->destroyConstant(); 4298899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky Changed = true; 4308899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky } 4318899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky } else if (Constant *C = dyn_cast<Constant>(U)) { 4328899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky if (SafeToDestroyConstant(C)) { 4338899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky C->destroyConstant(); 4348899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky // This could have invalidated UI, start over from scratch. 4358899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky Dead.clear(); 4368e0d1c03ca7fd86e6879b4e37d0d7f0e982feef6Benjamin Kramer CleanupPointerRootUsers(GV, TLI); 4378899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky return true; 4388899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky } 4398899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky } 4408899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky } 4418899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky 4428899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky for (int i = 0, e = Dead.size(); i != e; ++i) { 4438e0d1c03ca7fd86e6879b4e37d0d7f0e982feef6Benjamin Kramer if (IsSafeComputationToRemove(Dead[i].first, TLI)) { 4448899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky Dead[i].second->eraseFromParent(); 4458899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky Instruction *I = Dead[i].first; 4468899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky do { 4478e0d1c03ca7fd86e6879b4e37d0d7f0e982feef6Benjamin Kramer if (isAllocationFn(I, TLI)) 448952f5d562c40bc19147df4fbf3415069659236d1Nick Lewycky break; 4498899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky Instruction *J = dyn_cast<Instruction>(I->getOperand(0)); 4508899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky if (!J) 4518899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky break; 4528899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky I->eraseFromParent(); 4538899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky I = J; 454952f5d562c40bc19147df4fbf3415069659236d1Nick Lewycky } while (1); 4558899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky I->eraseFromParent(); 4568899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky } 4578899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky } 4588899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky 4598899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky return Changed; 4608899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky} 4618899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky 462e47ba74b07b2a6015239bcbabba09750580aecedChris Lattner/// CleanupConstantGlobalUsers - We just marked GV constant. Loop over all 463e47ba74b07b2a6015239bcbabba09750580aecedChris Lattner/// users of the global, cleaning up the obvious ones. This is largely just a 464031955d4623193b1c4163bd43db0eaaf6b08c27bChris Lattner/// quick scan over the use list to clean up the easy and obvious cruft. This 465031955d4623193b1c4163bd43db0eaaf6b08c27bChris Lattner/// returns true if it made a change. 4666a577f82ba56a4da48e984702240a01c3ba7e941Nick Lewyckystatic bool CleanupConstantGlobalUsers(Value *V, Constant *Init, 4676a577f82ba56a4da48e984702240a01c3ba7e941Nick Lewycky TargetData *TD, TargetLibraryInfo *TLI) { 468031955d4623193b1c4163bd43db0eaaf6b08c27bChris Lattner bool Changed = false; 4697a90b68e5c85fe11a4ccc386be9c5fcddd4a8b61Chris Lattner for (Value::use_iterator UI = V->use_begin(), E = V->use_end(); UI != E;) { 4707a90b68e5c85fe11a4ccc386be9c5fcddd4a8b61Chris Lattner User *U = *UI++; 471fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman 4727a90b68e5c85fe11a4ccc386be9c5fcddd4a8b61Chris Lattner if (LoadInst *LI = dyn_cast<LoadInst>(U)) { 47335c81b0b120f87373584f2e238e4d77f9d2ae88fChris Lattner if (Init) { 47435c81b0b120f87373584f2e238e4d77f9d2ae88fChris Lattner // Replace the load with the initializer. 47535c81b0b120f87373584f2e238e4d77f9d2ae88fChris Lattner LI->replaceAllUsesWith(Init); 47635c81b0b120f87373584f2e238e4d77f9d2ae88fChris Lattner LI->eraseFromParent(); 47735c81b0b120f87373584f2e238e4d77f9d2ae88fChris Lattner Changed = true; 47835c81b0b120f87373584f2e238e4d77f9d2ae88fChris Lattner } 4797a90b68e5c85fe11a4ccc386be9c5fcddd4a8b61Chris Lattner } else if (StoreInst *SI = dyn_cast<StoreInst>(U)) { 480e47ba74b07b2a6015239bcbabba09750580aecedChris Lattner // Store must be unreachable or storing Init into the global. 4817a7ed0274d01efb2e12a32fd5fee6aa9596b0b9aChris Lattner SI->eraseFromParent(); 482031955d4623193b1c4163bd43db0eaaf6b08c27bChris Lattner Changed = true; 4837a90b68e5c85fe11a4ccc386be9c5fcddd4a8b61Chris Lattner } else if (ConstantExpr *CE = dyn_cast<ConstantExpr>(U)) { 4847a90b68e5c85fe11a4ccc386be9c5fcddd4a8b61Chris Lattner if (CE->getOpcode() == Instruction::GetElementPtr) { 485aae4a1cd3f5d41d0b909a75b4f5699b20605db5eChris Lattner Constant *SubInit = 0; 486aae4a1cd3f5d41d0b909a75b4f5699b20605db5eChris Lattner if (Init) 487c6f69e94fa46f585b59bb9d7ace3224b0e638c95Dan Gohman SubInit = ConstantFoldLoadThroughGEPConstantExpr(Init, CE); 4886a577f82ba56a4da48e984702240a01c3ba7e941Nick Lewycky Changed |= CleanupConstantGlobalUsers(CE, SubInit, TD, TLI); 4899d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov } else if (CE->getOpcode() == Instruction::BitCast && 4901df9859c40492511b8aa4321eb76496005d3b75bDuncan Sands CE->getType()->isPointerTy()) { 49135c81b0b120f87373584f2e238e4d77f9d2ae88fChris Lattner // Pointer cast, delete any stores and memsets to the global. 4926a577f82ba56a4da48e984702240a01c3ba7e941Nick Lewycky Changed |= CleanupConstantGlobalUsers(CE, 0, TD, TLI); 4937a90b68e5c85fe11a4ccc386be9c5fcddd4a8b61Chris Lattner } 49435c81b0b120f87373584f2e238e4d77f9d2ae88fChris Lattner 49535c81b0b120f87373584f2e238e4d77f9d2ae88fChris Lattner if (CE->use_empty()) { 49635c81b0b120f87373584f2e238e4d77f9d2ae88fChris Lattner CE->destroyConstant(); 49735c81b0b120f87373584f2e238e4d77f9d2ae88fChris Lattner Changed = true; 498c4d81b0388dff9f38e1387bb223cc7b514c06d01Chris Lattner } 49935c81b0b120f87373584f2e238e4d77f9d2ae88fChris Lattner } else if (GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(U)) { 5007b52fe7272ec337a77b7cc96b14e27d15fec3c89Chris Lattner // Do not transform "gepinst (gep constexpr (GV))" here, because forming 5017b52fe7272ec337a77b7cc96b14e27d15fec3c89Chris Lattner // "gepconstexpr (gep constexpr (GV))" will cause the two gep's to fold 5027b52fe7272ec337a77b7cc96b14e27d15fec3c89Chris Lattner // and will invalidate our notion of what Init is. 50319450241e5ca3f679251c29f4926bb5f12ed535fChris Lattner Constant *SubInit = 0; 5047b52fe7272ec337a77b7cc96b14e27d15fec3c89Chris Lattner if (!isa<ConstantExpr>(GEP->getOperand(0))) { 5059d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov ConstantExpr *CE = 5066a577f82ba56a4da48e984702240a01c3ba7e941Nick Lewycky dyn_cast_or_null<ConstantExpr>(ConstantFoldInstruction(GEP, TD, TLI)); 5077b52fe7272ec337a77b7cc96b14e27d15fec3c89Chris Lattner if (Init && CE && CE->getOpcode() == Instruction::GetElementPtr) 508c6f69e94fa46f585b59bb9d7ace3224b0e638c95Dan Gohman SubInit = ConstantFoldLoadThroughGEPConstantExpr(Init, CE); 509c1ea16ec4339a9746f436c6f2f5b08197f309343Benjamin Kramer 510c1ea16ec4339a9746f436c6f2f5b08197f309343Benjamin Kramer // If the initializer is an all-null value and we have an inbounds GEP, 511c1ea16ec4339a9746f436c6f2f5b08197f309343Benjamin Kramer // we already know what the result of any load from that GEP is. 512c1ea16ec4339a9746f436c6f2f5b08197f309343Benjamin Kramer // TODO: Handle splats. 513c1ea16ec4339a9746f436c6f2f5b08197f309343Benjamin Kramer if (Init && isa<ConstantAggregateZero>(Init) && GEP->isInBounds()) 514c1ea16ec4339a9746f436c6f2f5b08197f309343Benjamin Kramer SubInit = Constant::getNullValue(GEP->getType()->getElementType()); 5157b52fe7272ec337a77b7cc96b14e27d15fec3c89Chris Lattner } 5166a577f82ba56a4da48e984702240a01c3ba7e941Nick Lewycky Changed |= CleanupConstantGlobalUsers(GEP, SubInit, TD, TLI); 517c4d81b0388dff9f38e1387bb223cc7b514c06d01Chris Lattner 518031955d4623193b1c4163bd43db0eaaf6b08c27bChris Lattner if (GEP->use_empty()) { 5197a7ed0274d01efb2e12a32fd5fee6aa9596b0b9aChris Lattner GEP->eraseFromParent(); 520031955d4623193b1c4163bd43db0eaaf6b08c27bChris Lattner Changed = true; 521031955d4623193b1c4163bd43db0eaaf6b08c27bChris Lattner } 52235c81b0b120f87373584f2e238e4d77f9d2ae88fChris Lattner } else if (MemIntrinsic *MI = dyn_cast<MemIntrinsic>(U)) { // memset/cpy/mv 52335c81b0b120f87373584f2e238e4d77f9d2ae88fChris Lattner if (MI->getRawDest() == V) { 52435c81b0b120f87373584f2e238e4d77f9d2ae88fChris Lattner MI->eraseFromParent(); 52535c81b0b120f87373584f2e238e4d77f9d2ae88fChris Lattner Changed = true; 52635c81b0b120f87373584f2e238e4d77f9d2ae88fChris Lattner } 52735c81b0b120f87373584f2e238e4d77f9d2ae88fChris Lattner 528a4be1dc0a192175bbc561a633c0b7197853e6a74Chris Lattner } else if (Constant *C = dyn_cast<Constant>(U)) { 529a4be1dc0a192175bbc561a633c0b7197853e6a74Chris Lattner // If we have a chain of dead constantexprs or other things dangling from 530a4be1dc0a192175bbc561a633c0b7197853e6a74Chris Lattner // us, and if they are all dead, nuke them without remorse. 531e3acf159d968b5a9db350203d8160a4d3c2d1a43Jay Foad if (SafeToDestroyConstant(C)) { 532743cdf8edf21d96b3d155eb322578936aebc4876Devang Patel C->destroyConstant(); 53335c81b0b120f87373584f2e238e4d77f9d2ae88fChris Lattner // This could have invalidated UI, start over from scratch. 5346a577f82ba56a4da48e984702240a01c3ba7e941Nick Lewycky CleanupConstantGlobalUsers(V, Init, TD, TLI); 535031955d4623193b1c4163bd43db0eaaf6b08c27bChris Lattner return true; 536a4be1dc0a192175bbc561a633c0b7197853e6a74Chris Lattner } 537e47ba74b07b2a6015239bcbabba09750580aecedChris Lattner } 538e47ba74b07b2a6015239bcbabba09750580aecedChris Lattner } 539031955d4623193b1c4163bd43db0eaaf6b08c27bChris Lattner return Changed; 540e47ba74b07b2a6015239bcbabba09750580aecedChris Lattner} 541e47ba74b07b2a6015239bcbabba09750580aecedChris Lattner 542941db495b8233a3753ce72a84021f677073ff4eaChris Lattner/// isSafeSROAElementUse - Return true if the specified instruction is a safe 543941db495b8233a3753ce72a84021f677073ff4eaChris Lattner/// user of a derived expression from a global that we want to SROA. 544941db495b8233a3753ce72a84021f677073ff4eaChris Lattnerstatic bool isSafeSROAElementUse(Value *V) { 545941db495b8233a3753ce72a84021f677073ff4eaChris Lattner // We might have a dead and dangling constant hanging off of here. 546941db495b8233a3753ce72a84021f677073ff4eaChris Lattner if (Constant *C = dyn_cast<Constant>(V)) 547e3acf159d968b5a9db350203d8160a4d3c2d1a43Jay Foad return SafeToDestroyConstant(C); 5489d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 549941db495b8233a3753ce72a84021f677073ff4eaChris Lattner Instruction *I = dyn_cast<Instruction>(V); 550941db495b8233a3753ce72a84021f677073ff4eaChris Lattner if (!I) return false; 551941db495b8233a3753ce72a84021f677073ff4eaChris Lattner 552941db495b8233a3753ce72a84021f677073ff4eaChris Lattner // Loads are ok. 553941db495b8233a3753ce72a84021f677073ff4eaChris Lattner if (isa<LoadInst>(I)) return true; 554941db495b8233a3753ce72a84021f677073ff4eaChris Lattner 555941db495b8233a3753ce72a84021f677073ff4eaChris Lattner // Stores *to* the pointer are ok. 556941db495b8233a3753ce72a84021f677073ff4eaChris Lattner if (StoreInst *SI = dyn_cast<StoreInst>(I)) 557941db495b8233a3753ce72a84021f677073ff4eaChris Lattner return SI->getOperand(0) != V; 5589d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 559941db495b8233a3753ce72a84021f677073ff4eaChris Lattner // Otherwise, it must be a GEP. 560941db495b8233a3753ce72a84021f677073ff4eaChris Lattner GetElementPtrInst *GEPI = dyn_cast<GetElementPtrInst>(I); 561941db495b8233a3753ce72a84021f677073ff4eaChris Lattner if (GEPI == 0) return false; 5629d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 563941db495b8233a3753ce72a84021f677073ff4eaChris Lattner if (GEPI->getNumOperands() < 3 || !isa<Constant>(GEPI->getOperand(1)) || 564941db495b8233a3753ce72a84021f677073ff4eaChris Lattner !cast<Constant>(GEPI->getOperand(1))->isNullValue()) 565941db495b8233a3753ce72a84021f677073ff4eaChris Lattner return false; 5669d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 567941db495b8233a3753ce72a84021f677073ff4eaChris Lattner for (Value::use_iterator I = GEPI->use_begin(), E = GEPI->use_end(); 568941db495b8233a3753ce72a84021f677073ff4eaChris Lattner I != E; ++I) 569941db495b8233a3753ce72a84021f677073ff4eaChris Lattner if (!isSafeSROAElementUse(*I)) 570941db495b8233a3753ce72a84021f677073ff4eaChris Lattner return false; 571941db495b8233a3753ce72a84021f677073ff4eaChris Lattner return true; 572941db495b8233a3753ce72a84021f677073ff4eaChris Lattner} 573727c21084d2f96c25b0ec1bc9a03cb88105a417cChris Lattner 574941db495b8233a3753ce72a84021f677073ff4eaChris Lattner 575941db495b8233a3753ce72a84021f677073ff4eaChris Lattner/// IsUserOfGlobalSafeForSRA - U is a direct user of the specified global value. 576941db495b8233a3753ce72a84021f677073ff4eaChris Lattner/// Look at it and its uses and decide whether it is safe to SROA this global. 577727c21084d2f96c25b0ec1bc9a03cb88105a417cChris Lattner/// 578941db495b8233a3753ce72a84021f677073ff4eaChris Lattnerstatic bool IsUserOfGlobalSafeForSRA(User *U, GlobalValue *GV) { 579941db495b8233a3753ce72a84021f677073ff4eaChris Lattner // The user of the global must be a GEP Inst or a ConstantExpr GEP. 5809d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov if (!isa<GetElementPtrInst>(U) && 5819d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov (!isa<ConstantExpr>(U) || 582941db495b8233a3753ce72a84021f677073ff4eaChris Lattner cast<ConstantExpr>(U)->getOpcode() != Instruction::GetElementPtr)) 583941db495b8233a3753ce72a84021f677073ff4eaChris Lattner return false; 5849d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 585941db495b8233a3753ce72a84021f677073ff4eaChris Lattner // Check to see if this ConstantExpr GEP is SRA'able. In particular, we 586941db495b8233a3753ce72a84021f677073ff4eaChris Lattner // don't like < 3 operand CE's, and we don't like non-constant integer 587941db495b8233a3753ce72a84021f677073ff4eaChris Lattner // indices. This enforces that all uses are 'gep GV, 0, C, ...' for some 588941db495b8233a3753ce72a84021f677073ff4eaChris Lattner // value of C. 589941db495b8233a3753ce72a84021f677073ff4eaChris Lattner if (U->getNumOperands() < 3 || !isa<Constant>(U->getOperand(1)) || 590941db495b8233a3753ce72a84021f677073ff4eaChris Lattner !cast<Constant>(U->getOperand(1))->isNullValue() || 591941db495b8233a3753ce72a84021f677073ff4eaChris Lattner !isa<ConstantInt>(U->getOperand(2))) 592941db495b8233a3753ce72a84021f677073ff4eaChris Lattner return false; 593727c21084d2f96c25b0ec1bc9a03cb88105a417cChris Lattner 594941db495b8233a3753ce72a84021f677073ff4eaChris Lattner gep_type_iterator GEPI = gep_type_begin(U), E = gep_type_end(U); 595941db495b8233a3753ce72a84021f677073ff4eaChris Lattner ++GEPI; // Skip over the pointer index. 5969d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 597941db495b8233a3753ce72a84021f677073ff4eaChris Lattner // If this is a use of an array allocation, do a bit more checking for sanity. 598db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner if (ArrayType *AT = dyn_cast<ArrayType>(*GEPI)) { 599941db495b8233a3753ce72a84021f677073ff4eaChris Lattner uint64_t NumElements = AT->getNumElements(); 600941db495b8233a3753ce72a84021f677073ff4eaChris Lattner ConstantInt *Idx = cast<ConstantInt>(U->getOperand(2)); 6019d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 602941db495b8233a3753ce72a84021f677073ff4eaChris Lattner // Check to make sure that index falls within the array. If not, 603941db495b8233a3753ce72a84021f677073ff4eaChris Lattner // something funny is going on, so we won't do the optimization. 604941db495b8233a3753ce72a84021f677073ff4eaChris Lattner // 605941db495b8233a3753ce72a84021f677073ff4eaChris Lattner if (Idx->getZExtValue() >= NumElements) 606941db495b8233a3753ce72a84021f677073ff4eaChris Lattner return false; 6079d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 608941db495b8233a3753ce72a84021f677073ff4eaChris Lattner // We cannot scalar repl this level of the array unless any array 609941db495b8233a3753ce72a84021f677073ff4eaChris Lattner // sub-indices are in-range constants. In particular, consider: 610941db495b8233a3753ce72a84021f677073ff4eaChris Lattner // A[0][i]. We cannot know that the user isn't doing invalid things like 611941db495b8233a3753ce72a84021f677073ff4eaChris Lattner // allowing i to index an out-of-range subscript that accesses A[1]. 612941db495b8233a3753ce72a84021f677073ff4eaChris Lattner // 613941db495b8233a3753ce72a84021f677073ff4eaChris Lattner // Scalar replacing *just* the outer index of the array is probably not 614941db495b8233a3753ce72a84021f677073ff4eaChris Lattner // going to be a win anyway, so just give up. 615941db495b8233a3753ce72a84021f677073ff4eaChris Lattner for (++GEPI; // Skip array index. 6166874a2ae033b7b5e1d0c10714e01d9c87480956aDan Gohman GEPI != E; 617941db495b8233a3753ce72a84021f677073ff4eaChris Lattner ++GEPI) { 618941db495b8233a3753ce72a84021f677073ff4eaChris Lattner uint64_t NumElements; 619db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner if (ArrayType *SubArrayTy = dyn_cast<ArrayType>(*GEPI)) 620941db495b8233a3753ce72a84021f677073ff4eaChris Lattner NumElements = SubArrayTy->getNumElements(); 621db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner else if (VectorType *SubVectorTy = dyn_cast<VectorType>(*GEPI)) 6226874a2ae033b7b5e1d0c10714e01d9c87480956aDan Gohman NumElements = SubVectorTy->getNumElements(); 6236874a2ae033b7b5e1d0c10714e01d9c87480956aDan Gohman else { 6241df9859c40492511b8aa4321eb76496005d3b75bDuncan Sands assert((*GEPI)->isStructTy() && 6256874a2ae033b7b5e1d0c10714e01d9c87480956aDan Gohman "Indexed GEP type is not array, vector, or struct!"); 6266874a2ae033b7b5e1d0c10714e01d9c87480956aDan Gohman continue; 6276874a2ae033b7b5e1d0c10714e01d9c87480956aDan Gohman } 6289d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 629941db495b8233a3753ce72a84021f677073ff4eaChris Lattner ConstantInt *IdxVal = dyn_cast<ConstantInt>(GEPI.getOperand()); 630941db495b8233a3753ce72a84021f677073ff4eaChris Lattner if (!IdxVal || IdxVal->getZExtValue() >= NumElements) 631727c21084d2f96c25b0ec1bc9a03cb88105a417cChris Lattner return false; 632727c21084d2f96c25b0ec1bc9a03cb88105a417cChris Lattner } 633727c21084d2f96c25b0ec1bc9a03cb88105a417cChris Lattner } 634941db495b8233a3753ce72a84021f677073ff4eaChris Lattner 635941db495b8233a3753ce72a84021f677073ff4eaChris Lattner for (Value::use_iterator I = U->use_begin(), E = U->use_end(); I != E; ++I) 636941db495b8233a3753ce72a84021f677073ff4eaChris Lattner if (!isSafeSROAElementUse(*I)) 637941db495b8233a3753ce72a84021f677073ff4eaChris Lattner return false; 638941db495b8233a3753ce72a84021f677073ff4eaChris Lattner return true; 639941db495b8233a3753ce72a84021f677073ff4eaChris Lattner} 640941db495b8233a3753ce72a84021f677073ff4eaChris Lattner 641941db495b8233a3753ce72a84021f677073ff4eaChris Lattner/// GlobalUsersSafeToSRA - Look at all uses of the global and decide whether it 642941db495b8233a3753ce72a84021f677073ff4eaChris Lattner/// is safe for us to perform this transformation. 643941db495b8233a3753ce72a84021f677073ff4eaChris Lattner/// 644941db495b8233a3753ce72a84021f677073ff4eaChris Lattnerstatic bool GlobalUsersSafeToSRA(GlobalValue *GV) { 645941db495b8233a3753ce72a84021f677073ff4eaChris Lattner for (Value::use_iterator UI = GV->use_begin(), E = GV->use_end(); 646941db495b8233a3753ce72a84021f677073ff4eaChris Lattner UI != E; ++UI) { 647941db495b8233a3753ce72a84021f677073ff4eaChris Lattner if (!IsUserOfGlobalSafeForSRA(*UI, GV)) 648941db495b8233a3753ce72a84021f677073ff4eaChris Lattner return false; 649941db495b8233a3753ce72a84021f677073ff4eaChris Lattner } 650727c21084d2f96c25b0ec1bc9a03cb88105a417cChris Lattner return true; 651727c21084d2f96c25b0ec1bc9a03cb88105a417cChris Lattner} 6529d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 653727c21084d2f96c25b0ec1bc9a03cb88105a417cChris Lattner 654670c889ac90e79fc6b1f9f18e78e536562d86f87Chris Lattner/// SRAGlobal - Perform scalar replacement of aggregates on the specified global 655670c889ac90e79fc6b1f9f18e78e536562d86f87Chris Lattner/// variable. This opens the door for other optimizations by exposing the 656670c889ac90e79fc6b1f9f18e78e536562d86f87Chris Lattner/// behavior of the program in a more fine-grained way. We have determined that 657670c889ac90e79fc6b1f9f18e78e536562d86f87Chris Lattner/// this transformation is safe already. We return the first global variable we 658670c889ac90e79fc6b1f9f18e78e536562d86f87Chris Lattner/// insert so that the caller can reprocess it. 6597b550ccfc5a3346c17e0390a59e2d6d19bc52705Chris Lattnerstatic GlobalVariable *SRAGlobal(GlobalVariable *GV, const TargetData &TD) { 660727c21084d2f96c25b0ec1bc9a03cb88105a417cChris Lattner // Make sure this global only has simple uses that we can SRA. 661941db495b8233a3753ce72a84021f677073ff4eaChris Lattner if (!GlobalUsersSafeToSRA(GV)) 662727c21084d2f96c25b0ec1bc9a03cb88105a417cChris Lattner return 0; 6639d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 664bb46f52027416598a662dc1c58f48d9d56b1a65bRafael Espindola assert(GV->hasLocalLinkage() && !GV->isConstant()); 665670c889ac90e79fc6b1f9f18e78e536562d86f87Chris Lattner Constant *Init = GV->getInitializer(); 666db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *Ty = Init->getType(); 667fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman 668670c889ac90e79fc6b1f9f18e78e536562d86f87Chris Lattner std::vector<GlobalVariable*> NewGlobals; 669670c889ac90e79fc6b1f9f18e78e536562d86f87Chris Lattner Module::GlobalListType &Globals = GV->getParent()->getGlobalList(); 670670c889ac90e79fc6b1f9f18e78e536562d86f87Chris Lattner 671998182b3802d2be8d081ca484b5d4fd5e1188950Chris Lattner // Get the alignment of the global, either explicit or target-specific. 672998182b3802d2be8d081ca484b5d4fd5e1188950Chris Lattner unsigned StartAlignment = GV->getAlignment(); 673998182b3802d2be8d081ca484b5d4fd5e1188950Chris Lattner if (StartAlignment == 0) 674998182b3802d2be8d081ca484b5d4fd5e1188950Chris Lattner StartAlignment = TD.getABITypeAlignment(GV->getType()); 6759d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 676db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner if (StructType *STy = dyn_cast<StructType>(Ty)) { 677670c889ac90e79fc6b1f9f18e78e536562d86f87Chris Lattner NewGlobals.reserve(STy->getNumElements()); 678998182b3802d2be8d081ca484b5d4fd5e1188950Chris Lattner const StructLayout &Layout = *TD.getStructLayout(STy); 679670c889ac90e79fc6b1f9f18e78e536562d86f87Chris Lattner for (unsigned i = 0, e = STy->getNumElements(); i != e; ++i) { 680a1f00f4d488eb5daff52faaf99c62ee652fd3b85Chris Lattner Constant *In = Init->getAggregateElement(i); 681670c889ac90e79fc6b1f9f18e78e536562d86f87Chris Lattner assert(In && "Couldn't get element of initializer?"); 6827b550ccfc5a3346c17e0390a59e2d6d19bc52705Chris Lattner GlobalVariable *NGV = new GlobalVariable(STy->getElementType(i), false, 683670c889ac90e79fc6b1f9f18e78e536562d86f87Chris Lattner GlobalVariable::InternalLinkage, 684fe09b2098ac483f6d6ce6ea4ab237a9539bdb6b9Daniel Dunbar In, GV->getName()+"."+Twine(i), 685ce718ff9f42c7da092eaa01dd0242e8d5ba84713Hans Wennborg GV->getThreadLocalMode(), 6863d29df3e8a203b167d8071ea6f805b21db18a5afOwen Anderson GV->getType()->getAddressSpace()); 687670c889ac90e79fc6b1f9f18e78e536562d86f87Chris Lattner Globals.insert(GV, NGV); 688670c889ac90e79fc6b1f9f18e78e536562d86f87Chris Lattner NewGlobals.push_back(NGV); 6899d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 690998182b3802d2be8d081ca484b5d4fd5e1188950Chris Lattner // Calculate the known alignment of the field. If the original aggregate 691998182b3802d2be8d081ca484b5d4fd5e1188950Chris Lattner // had 256 byte alignment for example, something might depend on that: 692998182b3802d2be8d081ca484b5d4fd5e1188950Chris Lattner // propagate info to each field. 693998182b3802d2be8d081ca484b5d4fd5e1188950Chris Lattner uint64_t FieldOffset = Layout.getElementOffset(i); 694998182b3802d2be8d081ca484b5d4fd5e1188950Chris Lattner unsigned NewAlign = (unsigned)MinAlign(StartAlignment, FieldOffset); 695998182b3802d2be8d081ca484b5d4fd5e1188950Chris Lattner if (NewAlign > TD.getABITypeAlignment(STy->getElementType(i))) 696998182b3802d2be8d081ca484b5d4fd5e1188950Chris Lattner NGV->setAlignment(NewAlign); 697670c889ac90e79fc6b1f9f18e78e536562d86f87Chris Lattner } 698db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner } else if (SequentialType *STy = dyn_cast<SequentialType>(Ty)) { 699670c889ac90e79fc6b1f9f18e78e536562d86f87Chris Lattner unsigned NumElements = 0; 700db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner if (ArrayType *ATy = dyn_cast<ArrayType>(STy)) 701670c889ac90e79fc6b1f9f18e78e536562d86f87Chris Lattner NumElements = ATy->getNumElements(); 702670c889ac90e79fc6b1f9f18e78e536562d86f87Chris Lattner else 703998182b3802d2be8d081ca484b5d4fd5e1188950Chris Lattner NumElements = cast<VectorType>(STy)->getNumElements(); 704670c889ac90e79fc6b1f9f18e78e536562d86f87Chris Lattner 7051f21ef1511ce003fc177121b980e783b83992f82Chris Lattner if (NumElements > 16 && GV->hasNUsesOrMore(16)) 706d514d8294d13e6a695ed324b415d3a9263313355Chris Lattner return 0; // It's not worth it. 707670c889ac90e79fc6b1f9f18e78e536562d86f87Chris Lattner NewGlobals.reserve(NumElements); 7089d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 709777d2306b36816a53bc1ae1244c0dc7d998ae691Duncan Sands uint64_t EltSize = TD.getTypeAllocSize(STy->getElementType()); 710998182b3802d2be8d081ca484b5d4fd5e1188950Chris Lattner unsigned EltAlign = TD.getABITypeAlignment(STy->getElementType()); 711670c889ac90e79fc6b1f9f18e78e536562d86f87Chris Lattner for (unsigned i = 0, e = NumElements; i != e; ++i) { 712a1f00f4d488eb5daff52faaf99c62ee652fd3b85Chris Lattner Constant *In = Init->getAggregateElement(i); 713670c889ac90e79fc6b1f9f18e78e536562d86f87Chris Lattner assert(In && "Couldn't get element of initializer?"); 714670c889ac90e79fc6b1f9f18e78e536562d86f87Chris Lattner 7157b550ccfc5a3346c17e0390a59e2d6d19bc52705Chris Lattner GlobalVariable *NGV = new GlobalVariable(STy->getElementType(), false, 716670c889ac90e79fc6b1f9f18e78e536562d86f87Chris Lattner GlobalVariable::InternalLinkage, 717fe09b2098ac483f6d6ce6ea4ab237a9539bdb6b9Daniel Dunbar In, GV->getName()+"."+Twine(i), 718ce718ff9f42c7da092eaa01dd0242e8d5ba84713Hans Wennborg GV->getThreadLocalMode(), 719e9b11b431308f4766b73cda93e38ec930c912122Owen Anderson GV->getType()->getAddressSpace()); 720670c889ac90e79fc6b1f9f18e78e536562d86f87Chris Lattner Globals.insert(GV, NGV); 721670c889ac90e79fc6b1f9f18e78e536562d86f87Chris Lattner NewGlobals.push_back(NGV); 7229d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 723998182b3802d2be8d081ca484b5d4fd5e1188950Chris Lattner // Calculate the known alignment of the field. If the original aggregate 724998182b3802d2be8d081ca484b5d4fd5e1188950Chris Lattner // had 256 byte alignment for example, something might depend on that: 725998182b3802d2be8d081ca484b5d4fd5e1188950Chris Lattner // propagate info to each field. 726998182b3802d2be8d081ca484b5d4fd5e1188950Chris Lattner unsigned NewAlign = (unsigned)MinAlign(StartAlignment, EltSize*i); 727998182b3802d2be8d081ca484b5d4fd5e1188950Chris Lattner if (NewAlign > EltAlign) 728998182b3802d2be8d081ca484b5d4fd5e1188950Chris Lattner NGV->setAlignment(NewAlign); 729670c889ac90e79fc6b1f9f18e78e536562d86f87Chris Lattner } 730670c889ac90e79fc6b1f9f18e78e536562d86f87Chris Lattner } 731670c889ac90e79fc6b1f9f18e78e536562d86f87Chris Lattner 732670c889ac90e79fc6b1f9f18e78e536562d86f87Chris Lattner if (NewGlobals.empty()) 733670c889ac90e79fc6b1f9f18e78e536562d86f87Chris Lattner return 0; 7349d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 7353215b0ee8248ca1e4bc2c7e2f5fd3ce120c3ee45David Greene DEBUG(dbgs() << "PERFORMING GLOBAL SRA ON: " << *GV); 73630ba5690cf7a6f4db8913463d03f239f82d17440Chris Lattner 7377b550ccfc5a3346c17e0390a59e2d6d19bc52705Chris Lattner Constant *NullInt =Constant::getNullValue(Type::getInt32Ty(GV->getContext())); 738670c889ac90e79fc6b1f9f18e78e536562d86f87Chris Lattner 739670c889ac90e79fc6b1f9f18e78e536562d86f87Chris Lattner // Loop over all of the uses of the global, replacing the constantexpr geps, 740670c889ac90e79fc6b1f9f18e78e536562d86f87Chris Lattner // with smaller constantexpr geps or direct references. 741670c889ac90e79fc6b1f9f18e78e536562d86f87Chris Lattner while (!GV->use_empty()) { 74230ba5690cf7a6f4db8913463d03f239f82d17440Chris Lattner User *GEP = GV->use_back(); 74330ba5690cf7a6f4db8913463d03f239f82d17440Chris Lattner assert(((isa<ConstantExpr>(GEP) && 74430ba5690cf7a6f4db8913463d03f239f82d17440Chris Lattner cast<ConstantExpr>(GEP)->getOpcode()==Instruction::GetElementPtr)|| 74530ba5690cf7a6f4db8913463d03f239f82d17440Chris Lattner isa<GetElementPtrInst>(GEP)) && "NonGEP CE's are not SRAable!"); 746fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman 747670c889ac90e79fc6b1f9f18e78e536562d86f87Chris Lattner // Ignore the 1th operand, which has to be zero or else the program is quite 748670c889ac90e79fc6b1f9f18e78e536562d86f87Chris Lattner // broken (undefined). Get the 2nd operand, which is the structure or array 749670c889ac90e79fc6b1f9f18e78e536562d86f87Chris Lattner // index. 750b83eb6447ba155342598f0fabe1f08f5baa9164aReid Spencer unsigned Val = cast<ConstantInt>(GEP->getOperand(2))->getZExtValue(); 751670c889ac90e79fc6b1f9f18e78e536562d86f87Chris Lattner if (Val >= NewGlobals.size()) Val = 0; // Out of bound array access. 752670c889ac90e79fc6b1f9f18e78e536562d86f87Chris Lattner 75330ba5690cf7a6f4db8913463d03f239f82d17440Chris Lattner Value *NewPtr = NewGlobals[Val]; 754670c889ac90e79fc6b1f9f18e78e536562d86f87Chris Lattner 755670c889ac90e79fc6b1f9f18e78e536562d86f87Chris Lattner // Form a shorter GEP if needed. 75607e6e56f57e8781a8d7bc601cc9034a3741d84c2Anton Korobeynikov if (GEP->getNumOperands() > 3) { 75730ba5690cf7a6f4db8913463d03f239f82d17440Chris Lattner if (ConstantExpr *CE = dyn_cast<ConstantExpr>(GEP)) { 75855eb1c47de30a6b4e8707b6392e878e32a6583e9Chris Lattner SmallVector<Constant*, 8> Idxs; 75930ba5690cf7a6f4db8913463d03f239f82d17440Chris Lattner Idxs.push_back(NullInt); 76030ba5690cf7a6f4db8913463d03f239f82d17440Chris Lattner for (unsigned i = 3, e = CE->getNumOperands(); i != e; ++i) 76130ba5690cf7a6f4db8913463d03f239f82d17440Chris Lattner Idxs.push_back(CE->getOperand(i)); 762dab3d29605a5c83db41b28176273ef55961120c1Jay Foad NewPtr = ConstantExpr::getGetElementPtr(cast<Constant>(NewPtr), Idxs); 76330ba5690cf7a6f4db8913463d03f239f82d17440Chris Lattner } else { 76430ba5690cf7a6f4db8913463d03f239f82d17440Chris Lattner GetElementPtrInst *GEPI = cast<GetElementPtrInst>(GEP); 765699d144a4b726e11d5e72e23ab9b7b665ca9341fChris Lattner SmallVector<Value*, 8> Idxs; 76630ba5690cf7a6f4db8913463d03f239f82d17440Chris Lattner Idxs.push_back(NullInt); 76730ba5690cf7a6f4db8913463d03f239f82d17440Chris Lattner for (unsigned i = 3, e = GEPI->getNumOperands(); i != e; ++i) 76830ba5690cf7a6f4db8913463d03f239f82d17440Chris Lattner Idxs.push_back(GEPI->getOperand(i)); 769a9203109f4ac95aa7e9624f2838e3d89623ec902Jay Foad NewPtr = GetElementPtrInst::Create(NewPtr, Idxs, 770fe09b2098ac483f6d6ce6ea4ab237a9539bdb6b9Daniel Dunbar GEPI->getName()+"."+Twine(Val),GEPI); 77130ba5690cf7a6f4db8913463d03f239f82d17440Chris Lattner } 77207e6e56f57e8781a8d7bc601cc9034a3741d84c2Anton Korobeynikov } 77330ba5690cf7a6f4db8913463d03f239f82d17440Chris Lattner GEP->replaceAllUsesWith(NewPtr); 77430ba5690cf7a6f4db8913463d03f239f82d17440Chris Lattner 77530ba5690cf7a6f4db8913463d03f239f82d17440Chris Lattner if (GetElementPtrInst *GEPI = dyn_cast<GetElementPtrInst>(GEP)) 7767a7ed0274d01efb2e12a32fd5fee6aa9596b0b9aChris Lattner GEPI->eraseFromParent(); 77730ba5690cf7a6f4db8913463d03f239f82d17440Chris Lattner else 77830ba5690cf7a6f4db8913463d03f239f82d17440Chris Lattner cast<ConstantExpr>(GEP)->destroyConstant(); 779670c889ac90e79fc6b1f9f18e78e536562d86f87Chris Lattner } 780670c889ac90e79fc6b1f9f18e78e536562d86f87Chris Lattner 781e40e2d1a71777289a8bfb9d77452754478722e55Chris Lattner // Delete the old global, now that it is dead. 782e40e2d1a71777289a8bfb9d77452754478722e55Chris Lattner Globals.erase(GV); 783670c889ac90e79fc6b1f9f18e78e536562d86f87Chris Lattner ++NumSRA; 78430ba5690cf7a6f4db8913463d03f239f82d17440Chris Lattner 78530ba5690cf7a6f4db8913463d03f239f82d17440Chris Lattner // Loop over the new globals array deleting any globals that are obviously 78630ba5690cf7a6f4db8913463d03f239f82d17440Chris Lattner // dead. This can arise due to scalarization of a structure or an array that 78730ba5690cf7a6f4db8913463d03f239f82d17440Chris Lattner // has elements that are dead. 78830ba5690cf7a6f4db8913463d03f239f82d17440Chris Lattner unsigned FirstGlobal = 0; 78930ba5690cf7a6f4db8913463d03f239f82d17440Chris Lattner for (unsigned i = 0, e = NewGlobals.size(); i != e; ++i) 79030ba5690cf7a6f4db8913463d03f239f82d17440Chris Lattner if (NewGlobals[i]->use_empty()) { 79130ba5690cf7a6f4db8913463d03f239f82d17440Chris Lattner Globals.erase(NewGlobals[i]); 79230ba5690cf7a6f4db8913463d03f239f82d17440Chris Lattner if (FirstGlobal == i) ++FirstGlobal; 79330ba5690cf7a6f4db8913463d03f239f82d17440Chris Lattner } 79430ba5690cf7a6f4db8913463d03f239f82d17440Chris Lattner 79530ba5690cf7a6f4db8913463d03f239f82d17440Chris Lattner return FirstGlobal != NewGlobals.size() ? NewGlobals[FirstGlobal] : 0; 796670c889ac90e79fc6b1f9f18e78e536562d86f87Chris Lattner} 797670c889ac90e79fc6b1f9f18e78e536562d86f87Chris Lattner 7989b34a6101908c36df659fe0b188713c949a32304Chris Lattner/// AllUsesOfValueWillTrapIfNull - Return true if all users of the specified 7999d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov/// value will trap if the value is dynamically null. PHIs keeps track of any 800816861803fe4f5e17f565f00e70989ab24d7ec45Chris Lattner/// phi nodes we've seen to avoid reprocessing them. 8016ce02b5939147784553c37d78e45a92dacee0037Gabor Greifstatic bool AllUsesOfValueWillTrapIfNull(const Value *V, 8026ce02b5939147784553c37d78e45a92dacee0037Gabor Greif SmallPtrSet<const PHINode*, 8> &PHIs) { 8036ce02b5939147784553c37d78e45a92dacee0037Gabor Greif for (Value::const_use_iterator UI = V->use_begin(), E = V->use_end(); UI != E; 804a01d6db569c7def7c5d1727fa1abedfc160b688cGabor Greif ++UI) { 8056ce02b5939147784553c37d78e45a92dacee0037Gabor Greif const User *U = *UI; 806a01d6db569c7def7c5d1727fa1abedfc160b688cGabor Greif 807a01d6db569c7def7c5d1727fa1abedfc160b688cGabor Greif if (isa<LoadInst>(U)) { 8089b34a6101908c36df659fe0b188713c949a32304Chris Lattner // Will trap. 8096ce02b5939147784553c37d78e45a92dacee0037Gabor Greif } else if (const StoreInst *SI = dyn_cast<StoreInst>(U)) { 8109b34a6101908c36df659fe0b188713c949a32304Chris Lattner if (SI->getOperand(0) == V) { 811a01d6db569c7def7c5d1727fa1abedfc160b688cGabor Greif //cerr << "NONTRAPPING USE: " << *U; 8129b34a6101908c36df659fe0b188713c949a32304Chris Lattner return false; // Storing the value. 8139b34a6101908c36df659fe0b188713c949a32304Chris Lattner } 8146ce02b5939147784553c37d78e45a92dacee0037Gabor Greif } else if (const CallInst *CI = dyn_cast<CallInst>(U)) { 815654c06f6457f80428e40810ad251c412462731e4Gabor Greif if (CI->getCalledValue() != V) { 816a01d6db569c7def7c5d1727fa1abedfc160b688cGabor Greif //cerr << "NONTRAPPING USE: " << *U; 8179b34a6101908c36df659fe0b188713c949a32304Chris Lattner return false; // Not calling the ptr 8189b34a6101908c36df659fe0b188713c949a32304Chris Lattner } 8196ce02b5939147784553c37d78e45a92dacee0037Gabor Greif } else if (const InvokeInst *II = dyn_cast<InvokeInst>(U)) { 820654c06f6457f80428e40810ad251c412462731e4Gabor Greif if (II->getCalledValue() != V) { 821a01d6db569c7def7c5d1727fa1abedfc160b688cGabor Greif //cerr << "NONTRAPPING USE: " << *U; 8229b34a6101908c36df659fe0b188713c949a32304Chris Lattner return false; // Not calling the ptr 8239b34a6101908c36df659fe0b188713c949a32304Chris Lattner } 8246ce02b5939147784553c37d78e45a92dacee0037Gabor Greif } else if (const BitCastInst *CI = dyn_cast<BitCastInst>(U)) { 825816861803fe4f5e17f565f00e70989ab24d7ec45Chris Lattner if (!AllUsesOfValueWillTrapIfNull(CI, PHIs)) return false; 8266ce02b5939147784553c37d78e45a92dacee0037Gabor Greif } else if (const GetElementPtrInst *GEPI = dyn_cast<GetElementPtrInst>(U)) { 827816861803fe4f5e17f565f00e70989ab24d7ec45Chris Lattner if (!AllUsesOfValueWillTrapIfNull(GEPI, PHIs)) return false; 8286ce02b5939147784553c37d78e45a92dacee0037Gabor Greif } else if (const PHINode *PN = dyn_cast<PHINode>(U)) { 829816861803fe4f5e17f565f00e70989ab24d7ec45Chris Lattner // If we've already seen this phi node, ignore it, it has already been 830816861803fe4f5e17f565f00e70989ab24d7ec45Chris Lattner // checked. 831b489d0f88a59cf620fad7a0a82037ad2cd3cad16Jakob Stoklund Olesen if (PHIs.insert(PN) && !AllUsesOfValueWillTrapIfNull(PN, PHIs)) 832b489d0f88a59cf620fad7a0a82037ad2cd3cad16Jakob Stoklund Olesen return false; 833a01d6db569c7def7c5d1727fa1abedfc160b688cGabor Greif } else if (isa<ICmpInst>(U) && 834e9ece2a7462c29f2c57c0b0e063f950514f41ab4Chris Lattner isa<ConstantPointerNull>(UI->getOperand(1))) { 835e7ee59b6a4ec6c7a360a77aac044a546b0012c37Nick Lewycky // Ignore icmp X, null 8369b34a6101908c36df659fe0b188713c949a32304Chris Lattner } else { 837a01d6db569c7def7c5d1727fa1abedfc160b688cGabor Greif //cerr << "NONTRAPPING USE: " << *U; 8389b34a6101908c36df659fe0b188713c949a32304Chris Lattner return false; 8399b34a6101908c36df659fe0b188713c949a32304Chris Lattner } 840a01d6db569c7def7c5d1727fa1abedfc160b688cGabor Greif } 8419b34a6101908c36df659fe0b188713c949a32304Chris Lattner return true; 8429b34a6101908c36df659fe0b188713c949a32304Chris Lattner} 8439b34a6101908c36df659fe0b188713c949a32304Chris Lattner 8449b34a6101908c36df659fe0b188713c949a32304Chris Lattner/// AllUsesOfLoadedValueWillTrapIfNull - Return true if all uses of any loads 845e9ece2a7462c29f2c57c0b0e063f950514f41ab4Chris Lattner/// from GV will trap if the loaded value is null. Note that this also permits 846e9ece2a7462c29f2c57c0b0e063f950514f41ab4Chris Lattner/// comparisons of the loaded value against null, as a special case. 8476ce02b5939147784553c37d78e45a92dacee0037Gabor Greifstatic bool AllUsesOfLoadedValueWillTrapIfNull(const GlobalVariable *GV) { 8486ce02b5939147784553c37d78e45a92dacee0037Gabor Greif for (Value::const_use_iterator UI = GV->use_begin(), E = GV->use_end(); 849a01d6db569c7def7c5d1727fa1abedfc160b688cGabor Greif UI != E; ++UI) { 8506ce02b5939147784553c37d78e45a92dacee0037Gabor Greif const User *U = *UI; 851a01d6db569c7def7c5d1727fa1abedfc160b688cGabor Greif 8526ce02b5939147784553c37d78e45a92dacee0037Gabor Greif if (const LoadInst *LI = dyn_cast<LoadInst>(U)) { 8536ce02b5939147784553c37d78e45a92dacee0037Gabor Greif SmallPtrSet<const PHINode*, 8> PHIs; 854816861803fe4f5e17f565f00e70989ab24d7ec45Chris Lattner if (!AllUsesOfValueWillTrapIfNull(LI, PHIs)) 8559b34a6101908c36df659fe0b188713c949a32304Chris Lattner return false; 856a01d6db569c7def7c5d1727fa1abedfc160b688cGabor Greif } else if (isa<StoreInst>(U)) { 8579b34a6101908c36df659fe0b188713c949a32304Chris Lattner // Ignore stores to the global. 8589b34a6101908c36df659fe0b188713c949a32304Chris Lattner } else { 8599b34a6101908c36df659fe0b188713c949a32304Chris Lattner // We don't know or understand this user, bail out. 860a01d6db569c7def7c5d1727fa1abedfc160b688cGabor Greif //cerr << "UNKNOWN USER OF GLOBAL!: " << *U; 8619b34a6101908c36df659fe0b188713c949a32304Chris Lattner return false; 8629b34a6101908c36df659fe0b188713c949a32304Chris Lattner } 863a01d6db569c7def7c5d1727fa1abedfc160b688cGabor Greif } 8649b34a6101908c36df659fe0b188713c949a32304Chris Lattner return true; 8659b34a6101908c36df659fe0b188713c949a32304Chris Lattner} 8669b34a6101908c36df659fe0b188713c949a32304Chris Lattner 8677b550ccfc5a3346c17e0390a59e2d6d19bc52705Chris Lattnerstatic bool OptimizeAwayTrappingUsesOfValue(Value *V, Constant *NewV) { 868708148e41f8f7c1e24c73cfd943645b13a1e05f9Chris Lattner bool Changed = false; 869708148e41f8f7c1e24c73cfd943645b13a1e05f9Chris Lattner for (Value::use_iterator UI = V->use_begin(), E = V->use_end(); UI != E; ) { 870708148e41f8f7c1e24c73cfd943645b13a1e05f9Chris Lattner Instruction *I = cast<Instruction>(*UI++); 871708148e41f8f7c1e24c73cfd943645b13a1e05f9Chris Lattner if (LoadInst *LI = dyn_cast<LoadInst>(I)) { 872708148e41f8f7c1e24c73cfd943645b13a1e05f9Chris Lattner LI->setOperand(0, NewV); 873708148e41f8f7c1e24c73cfd943645b13a1e05f9Chris Lattner Changed = true; 874708148e41f8f7c1e24c73cfd943645b13a1e05f9Chris Lattner } else if (StoreInst *SI = dyn_cast<StoreInst>(I)) { 875708148e41f8f7c1e24c73cfd943645b13a1e05f9Chris Lattner if (SI->getOperand(1) == V) { 876708148e41f8f7c1e24c73cfd943645b13a1e05f9Chris Lattner SI->setOperand(1, NewV); 877708148e41f8f7c1e24c73cfd943645b13a1e05f9Chris Lattner Changed = true; 878708148e41f8f7c1e24c73cfd943645b13a1e05f9Chris Lattner } 879708148e41f8f7c1e24c73cfd943645b13a1e05f9Chris Lattner } else if (isa<CallInst>(I) || isa<InvokeInst>(I)) { 880fa1f5c22c5186d1055343aae74224a6637b831b2Gabor Greif CallSite CS(I); 881fa1f5c22c5186d1055343aae74224a6637b831b2Gabor Greif if (CS.getCalledValue() == V) { 882708148e41f8f7c1e24c73cfd943645b13a1e05f9Chris Lattner // Calling through the pointer! Turn into a direct call, but be careful 883708148e41f8f7c1e24c73cfd943645b13a1e05f9Chris Lattner // that the pointer is not also being passed as an argument. 884fa1f5c22c5186d1055343aae74224a6637b831b2Gabor Greif CS.setCalledFunction(NewV); 885708148e41f8f7c1e24c73cfd943645b13a1e05f9Chris Lattner Changed = true; 886708148e41f8f7c1e24c73cfd943645b13a1e05f9Chris Lattner bool PassedAsArg = false; 887fa1f5c22c5186d1055343aae74224a6637b831b2Gabor Greif for (unsigned i = 0, e = CS.arg_size(); i != e; ++i) 888fa1f5c22c5186d1055343aae74224a6637b831b2Gabor Greif if (CS.getArgument(i) == V) { 889708148e41f8f7c1e24c73cfd943645b13a1e05f9Chris Lattner PassedAsArg = true; 890fa1f5c22c5186d1055343aae74224a6637b831b2Gabor Greif CS.setArgument(i, NewV); 891708148e41f8f7c1e24c73cfd943645b13a1e05f9Chris Lattner } 892708148e41f8f7c1e24c73cfd943645b13a1e05f9Chris Lattner 893708148e41f8f7c1e24c73cfd943645b13a1e05f9Chris Lattner if (PassedAsArg) { 894708148e41f8f7c1e24c73cfd943645b13a1e05f9Chris Lattner // Being passed as an argument also. Be careful to not invalidate UI! 895708148e41f8f7c1e24c73cfd943645b13a1e05f9Chris Lattner UI = V->use_begin(); 896708148e41f8f7c1e24c73cfd943645b13a1e05f9Chris Lattner } 897708148e41f8f7c1e24c73cfd943645b13a1e05f9Chris Lattner } 898708148e41f8f7c1e24c73cfd943645b13a1e05f9Chris Lattner } else if (CastInst *CI = dyn_cast<CastInst>(I)) { 899708148e41f8f7c1e24c73cfd943645b13a1e05f9Chris Lattner Changed |= OptimizeAwayTrappingUsesOfValue(CI, 900baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson ConstantExpr::getCast(CI->getOpcode(), 9017b550ccfc5a3346c17e0390a59e2d6d19bc52705Chris Lattner NewV, CI->getType())); 902708148e41f8f7c1e24c73cfd943645b13a1e05f9Chris Lattner if (CI->use_empty()) { 903708148e41f8f7c1e24c73cfd943645b13a1e05f9Chris Lattner Changed = true; 9047a7ed0274d01efb2e12a32fd5fee6aa9596b0b9aChris Lattner CI->eraseFromParent(); 905708148e41f8f7c1e24c73cfd943645b13a1e05f9Chris Lattner } 906708148e41f8f7c1e24c73cfd943645b13a1e05f9Chris Lattner } else if (GetElementPtrInst *GEPI = dyn_cast<GetElementPtrInst>(I)) { 907708148e41f8f7c1e24c73cfd943645b13a1e05f9Chris Lattner // Should handle GEP here. 90855eb1c47de30a6b4e8707b6392e878e32a6583e9Chris Lattner SmallVector<Constant*, 8> Idxs; 90955eb1c47de30a6b4e8707b6392e878e32a6583e9Chris Lattner Idxs.reserve(GEPI->getNumOperands()-1); 9105e46321d665d6b1f445aff70d8eabb4870a6cf0eGabor Greif for (User::op_iterator i = GEPI->op_begin() + 1, e = GEPI->op_end(); 9115e46321d665d6b1f445aff70d8eabb4870a6cf0eGabor Greif i != e; ++i) 9125e46321d665d6b1f445aff70d8eabb4870a6cf0eGabor Greif if (Constant *C = dyn_cast<Constant>(*i)) 91355eb1c47de30a6b4e8707b6392e878e32a6583e9Chris Lattner Idxs.push_back(C); 914708148e41f8f7c1e24c73cfd943645b13a1e05f9Chris Lattner else 915708148e41f8f7c1e24c73cfd943645b13a1e05f9Chris Lattner break; 91655eb1c47de30a6b4e8707b6392e878e32a6583e9Chris Lattner if (Idxs.size() == GEPI->getNumOperands()-1) 917708148e41f8f7c1e24c73cfd943645b13a1e05f9Chris Lattner Changed |= OptimizeAwayTrappingUsesOfValue(GEPI, 918dab3d29605a5c83db41b28176273ef55961120c1Jay Foad ConstantExpr::getGetElementPtr(NewV, Idxs)); 919708148e41f8f7c1e24c73cfd943645b13a1e05f9Chris Lattner if (GEPI->use_empty()) { 920708148e41f8f7c1e24c73cfd943645b13a1e05f9Chris Lattner Changed = true; 9217a7ed0274d01efb2e12a32fd5fee6aa9596b0b9aChris Lattner GEPI->eraseFromParent(); 922708148e41f8f7c1e24c73cfd943645b13a1e05f9Chris Lattner } 923708148e41f8f7c1e24c73cfd943645b13a1e05f9Chris Lattner } 924708148e41f8f7c1e24c73cfd943645b13a1e05f9Chris Lattner } 925708148e41f8f7c1e24c73cfd943645b13a1e05f9Chris Lattner 926708148e41f8f7c1e24c73cfd943645b13a1e05f9Chris Lattner return Changed; 927708148e41f8f7c1e24c73cfd943645b13a1e05f9Chris Lattner} 928708148e41f8f7c1e24c73cfd943645b13a1e05f9Chris Lattner 929708148e41f8f7c1e24c73cfd943645b13a1e05f9Chris Lattner 930708148e41f8f7c1e24c73cfd943645b13a1e05f9Chris Lattner/// OptimizeAwayTrappingUsesOfLoads - The specified global has only one non-null 931708148e41f8f7c1e24c73cfd943645b13a1e05f9Chris Lattner/// value stored into it. If there are uses of the loaded value that would trap 932708148e41f8f7c1e24c73cfd943645b13a1e05f9Chris Lattner/// if the loaded value is dynamically null, then we know that they cannot be 933708148e41f8f7c1e24c73cfd943645b13a1e05f9Chris Lattner/// reachable with a null optimize away the load. 9346a577f82ba56a4da48e984702240a01c3ba7e941Nick Lewyckystatic bool OptimizeAwayTrappingUsesOfLoads(GlobalVariable *GV, Constant *LV, 9356a577f82ba56a4da48e984702240a01c3ba7e941Nick Lewycky TargetData *TD, 9366a577f82ba56a4da48e984702240a01c3ba7e941Nick Lewycky TargetLibraryInfo *TLI) { 937708148e41f8f7c1e24c73cfd943645b13a1e05f9Chris Lattner bool Changed = false; 938708148e41f8f7c1e24c73cfd943645b13a1e05f9Chris Lattner 93992c6bd2c45f0002385300a8aa298fa34ef9bff64Chris Lattner // Keep track of whether we are able to remove all the uses of the global 94092c6bd2c45f0002385300a8aa298fa34ef9bff64Chris Lattner // other than the store that defines it. 94192c6bd2c45f0002385300a8aa298fa34ef9bff64Chris Lattner bool AllNonStoreUsesGone = true; 9429d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 943708148e41f8f7c1e24c73cfd943645b13a1e05f9Chris Lattner // Replace all uses of loads with uses of uses of the stored value. 94492c6bd2c45f0002385300a8aa298fa34ef9bff64Chris Lattner for (Value::use_iterator GUI = GV->use_begin(), E = GV->use_end(); GUI != E;){ 94592c6bd2c45f0002385300a8aa298fa34ef9bff64Chris Lattner User *GlobalUser = *GUI++; 94692c6bd2c45f0002385300a8aa298fa34ef9bff64Chris Lattner if (LoadInst *LI = dyn_cast<LoadInst>(GlobalUser)) { 9477b550ccfc5a3346c17e0390a59e2d6d19bc52705Chris Lattner Changed |= OptimizeAwayTrappingUsesOfValue(LI, LV); 94892c6bd2c45f0002385300a8aa298fa34ef9bff64Chris Lattner // If we were able to delete all uses of the loads 94992c6bd2c45f0002385300a8aa298fa34ef9bff64Chris Lattner if (LI->use_empty()) { 95092c6bd2c45f0002385300a8aa298fa34ef9bff64Chris Lattner LI->eraseFromParent(); 95192c6bd2c45f0002385300a8aa298fa34ef9bff64Chris Lattner Changed = true; 95292c6bd2c45f0002385300a8aa298fa34ef9bff64Chris Lattner } else { 95392c6bd2c45f0002385300a8aa298fa34ef9bff64Chris Lattner AllNonStoreUsesGone = false; 95492c6bd2c45f0002385300a8aa298fa34ef9bff64Chris Lattner } 95592c6bd2c45f0002385300a8aa298fa34ef9bff64Chris Lattner } else if (isa<StoreInst>(GlobalUser)) { 95692c6bd2c45f0002385300a8aa298fa34ef9bff64Chris Lattner // Ignore the store that stores "LV" to the global. 95792c6bd2c45f0002385300a8aa298fa34ef9bff64Chris Lattner assert(GlobalUser->getOperand(1) == GV && 95892c6bd2c45f0002385300a8aa298fa34ef9bff64Chris Lattner "Must be storing *to* the global"); 959708148e41f8f7c1e24c73cfd943645b13a1e05f9Chris Lattner } else { 96092c6bd2c45f0002385300a8aa298fa34ef9bff64Chris Lattner AllNonStoreUsesGone = false; 96192c6bd2c45f0002385300a8aa298fa34ef9bff64Chris Lattner 96292c6bd2c45f0002385300a8aa298fa34ef9bff64Chris Lattner // If we get here we could have other crazy uses that are transitively 96392c6bd2c45f0002385300a8aa298fa34ef9bff64Chris Lattner // loaded. 96492c6bd2c45f0002385300a8aa298fa34ef9bff64Chris Lattner assert((isa<PHINode>(GlobalUser) || isa<SelectInst>(GlobalUser) || 96598a42b2fc39f3fc46905fb98078cce4ce4e0a827Chris Lattner isa<ConstantExpr>(GlobalUser) || isa<CmpInst>(GlobalUser)) && 96698a42b2fc39f3fc46905fb98078cce4ce4e0a827Chris Lattner "Only expect load and stores!"); 967708148e41f8f7c1e24c73cfd943645b13a1e05f9Chris Lattner } 96892c6bd2c45f0002385300a8aa298fa34ef9bff64Chris Lattner } 969708148e41f8f7c1e24c73cfd943645b13a1e05f9Chris Lattner 970708148e41f8f7c1e24c73cfd943645b13a1e05f9Chris Lattner if (Changed) { 9713215b0ee8248ca1e4bc2c7e2f5fd3ce120c3ee45David Greene DEBUG(dbgs() << "OPTIMIZED LOADS FROM STORED ONCE POINTER: " << *GV); 972708148e41f8f7c1e24c73cfd943645b13a1e05f9Chris Lattner ++NumGlobUses; 973708148e41f8f7c1e24c73cfd943645b13a1e05f9Chris Lattner } 974708148e41f8f7c1e24c73cfd943645b13a1e05f9Chris Lattner 975708148e41f8f7c1e24c73cfd943645b13a1e05f9Chris Lattner // If we nuked all of the loads, then none of the stores are needed either, 976708148e41f8f7c1e24c73cfd943645b13a1e05f9Chris Lattner // nor is the global. 97792c6bd2c45f0002385300a8aa298fa34ef9bff64Chris Lattner if (AllNonStoreUsesGone) { 9788899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky if (isLeakCheckerRoot(GV)) { 9798e0d1c03ca7fd86e6879b4e37d0d7f0e982feef6Benjamin Kramer Changed |= CleanupPointerRootUsers(GV, TLI); 9808899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky } else { 9818899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky Changed = true; 9828899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky CleanupConstantGlobalUsers(GV, 0, TD, TLI); 9838899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky } 984708148e41f8f7c1e24c73cfd943645b13a1e05f9Chris Lattner if (GV->use_empty()) { 9858899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky DEBUG(dbgs() << " *** GLOBAL NOW DEAD!\n"); 9868899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky Changed = true; 9877a7ed0274d01efb2e12a32fd5fee6aa9596b0b9aChris Lattner GV->eraseFromParent(); 988708148e41f8f7c1e24c73cfd943645b13a1e05f9Chris Lattner ++NumDeleted; 989708148e41f8f7c1e24c73cfd943645b13a1e05f9Chris Lattner } 990708148e41f8f7c1e24c73cfd943645b13a1e05f9Chris Lattner } 991708148e41f8f7c1e24c73cfd943645b13a1e05f9Chris Lattner return Changed; 992708148e41f8f7c1e24c73cfd943645b13a1e05f9Chris Lattner} 993708148e41f8f7c1e24c73cfd943645b13a1e05f9Chris Lattner 99430ba5690cf7a6f4db8913463d03f239f82d17440Chris Lattner/// ConstantPropUsersOf - Walk the use list of V, constant folding all of the 99530ba5690cf7a6f4db8913463d03f239f82d17440Chris Lattner/// instructions that are foldable. 9966a577f82ba56a4da48e984702240a01c3ba7e941Nick Lewyckystatic void ConstantPropUsersOf(Value *V, 9976a577f82ba56a4da48e984702240a01c3ba7e941Nick Lewycky TargetData *TD, TargetLibraryInfo *TLI) { 99830ba5690cf7a6f4db8913463d03f239f82d17440Chris Lattner for (Value::use_iterator UI = V->use_begin(), E = V->use_end(); UI != E; ) 99930ba5690cf7a6f4db8913463d03f239f82d17440Chris Lattner if (Instruction *I = dyn_cast<Instruction>(*UI++)) 10006a577f82ba56a4da48e984702240a01c3ba7e941Nick Lewycky if (Constant *NewC = ConstantFoldInstruction(I, TD, TLI)) { 100130ba5690cf7a6f4db8913463d03f239f82d17440Chris Lattner I->replaceAllUsesWith(NewC); 100230ba5690cf7a6f4db8913463d03f239f82d17440Chris Lattner 1003d514d8294d13e6a695ed324b415d3a9263313355Chris Lattner // Advance UI to the next non-I use to avoid invalidating it! 1004d514d8294d13e6a695ed324b415d3a9263313355Chris Lattner // Instructions could multiply use V. 1005d514d8294d13e6a695ed324b415d3a9263313355Chris Lattner while (UI != E && *UI == I) 100630ba5690cf7a6f4db8913463d03f239f82d17440Chris Lattner ++UI; 1007d514d8294d13e6a695ed324b415d3a9263313355Chris Lattner I->eraseFromParent(); 100830ba5690cf7a6f4db8913463d03f239f82d17440Chris Lattner } 100930ba5690cf7a6f4db8913463d03f239f82d17440Chris Lattner} 101030ba5690cf7a6f4db8913463d03f239f82d17440Chris Lattner 101130ba5690cf7a6f4db8913463d03f239f82d17440Chris Lattner/// OptimizeGlobalAddressOfMalloc - This function takes the specified global 101230ba5690cf7a6f4db8913463d03f239f82d17440Chris Lattner/// variable, and transforms the program as if it always contained the result of 101330ba5690cf7a6f4db8913463d03f239f82d17440Chris Lattner/// the specified malloc. Because it is always the result of the specified 101430ba5690cf7a6f4db8913463d03f239f82d17440Chris Lattner/// malloc, there is no reason to actually DO the malloc. Instead, turn the 10156e8fbad67554e0a605af59d072b4129a8706681eChris Lattner/// malloc into a global, and any loads of GV as uses of the new global. 101630ba5690cf7a6f4db8913463d03f239f82d17440Chris Lattnerstatic GlobalVariable *OptimizeGlobalAddressOfMalloc(GlobalVariable *GV, 101783d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez CallInst *CI, 1018db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *AllocTy, 1019a687465bae9ce793444fef37eb790ac7722f6bc7Chris Lattner ConstantInt *NElements, 10206a577f82ba56a4da48e984702240a01c3ba7e941Nick Lewycky TargetData *TD, 10216a577f82ba56a4da48e984702240a01c3ba7e941Nick Lewycky TargetLibraryInfo *TLI) { 1022a687465bae9ce793444fef37eb790ac7722f6bc7Chris Lattner DEBUG(errs() << "PROMOTING GLOBAL: " << *GV << " CALL = " << *CI << '\n'); 10239d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 1024db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *GlobalType; 1025a687465bae9ce793444fef37eb790ac7722f6bc7Chris Lattner if (NElements->getZExtValue() == 1) 1026a687465bae9ce793444fef37eb790ac7722f6bc7Chris Lattner GlobalType = AllocTy; 1027a687465bae9ce793444fef37eb790ac7722f6bc7Chris Lattner else 1028a687465bae9ce793444fef37eb790ac7722f6bc7Chris Lattner // If we have an array allocation, the global variable is of an array. 1029a687465bae9ce793444fef37eb790ac7722f6bc7Chris Lattner GlobalType = ArrayType::get(AllocTy, NElements->getZExtValue()); 103083d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez 103183d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez // Create the new global variable. The contents of the malloc'd memory is 103283d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez // undefined, so initialize with an undef value. 10339d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov GlobalVariable *NewGV = new GlobalVariable(*GV->getParent(), 1034e9fd444dcd59f5b17bd30f919cb1b3a50519d3c1Chris Lattner GlobalType, false, 1035a687465bae9ce793444fef37eb790ac7722f6bc7Chris Lattner GlobalValue::InternalLinkage, 1036e9fd444dcd59f5b17bd30f919cb1b3a50519d3c1Chris Lattner UndefValue::get(GlobalType), 103783d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez GV->getName()+".body", 103883d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez GV, 1039ce718ff9f42c7da092eaa01dd0242e8d5ba84713Hans Wennborg GV->getThreadLocalMode()); 10409d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 1041a687465bae9ce793444fef37eb790ac7722f6bc7Chris Lattner // If there are bitcast users of the malloc (which is typical, usually we have 1042a687465bae9ce793444fef37eb790ac7722f6bc7Chris Lattner // a malloc + bitcast) then replace them with uses of the new global. Update 1043a687465bae9ce793444fef37eb790ac7722f6bc7Chris Lattner // other users to use the global as well. 1044a687465bae9ce793444fef37eb790ac7722f6bc7Chris Lattner BitCastInst *TheBC = 0; 1045a687465bae9ce793444fef37eb790ac7722f6bc7Chris Lattner while (!CI->use_empty()) { 1046a687465bae9ce793444fef37eb790ac7722f6bc7Chris Lattner Instruction *User = cast<Instruction>(CI->use_back()); 1047a687465bae9ce793444fef37eb790ac7722f6bc7Chris Lattner if (BitCastInst *BCI = dyn_cast<BitCastInst>(User)) { 1048a687465bae9ce793444fef37eb790ac7722f6bc7Chris Lattner if (BCI->getType() == NewGV->getType()) { 1049a687465bae9ce793444fef37eb790ac7722f6bc7Chris Lattner BCI->replaceAllUsesWith(NewGV); 1050a687465bae9ce793444fef37eb790ac7722f6bc7Chris Lattner BCI->eraseFromParent(); 1051a687465bae9ce793444fef37eb790ac7722f6bc7Chris Lattner } else { 1052a687465bae9ce793444fef37eb790ac7722f6bc7Chris Lattner BCI->setOperand(0, NewGV); 1053a687465bae9ce793444fef37eb790ac7722f6bc7Chris Lattner } 1054a687465bae9ce793444fef37eb790ac7722f6bc7Chris Lattner } else { 1055a687465bae9ce793444fef37eb790ac7722f6bc7Chris Lattner if (TheBC == 0) 1056a687465bae9ce793444fef37eb790ac7722f6bc7Chris Lattner TheBC = new BitCastInst(NewGV, CI->getType(), "newgv", CI); 1057a687465bae9ce793444fef37eb790ac7722f6bc7Chris Lattner User->replaceUsesOfWith(CI, TheBC); 1058a687465bae9ce793444fef37eb790ac7722f6bc7Chris Lattner } 1059a687465bae9ce793444fef37eb790ac7722f6bc7Chris Lattner } 10609d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 106183d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez Constant *RepValue = NewGV; 106283d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez if (NewGV->getType() != GV->getType()->getElementType()) 10639d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov RepValue = ConstantExpr::getBitCast(RepValue, 106483d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez GV->getType()->getElementType()); 106583d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez 106683d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez // If there is a comparison against null, we will insert a global bool to 106783d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez // keep track of whether the global was initialized yet or not. 106883d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez GlobalVariable *InitBool = 10697b550ccfc5a3346c17e0390a59e2d6d19bc52705Chris Lattner new GlobalVariable(Type::getInt1Ty(GV->getContext()), false, 107083d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez GlobalValue::InternalLinkage, 10717b550ccfc5a3346c17e0390a59e2d6d19bc52705Chris Lattner ConstantInt::getFalse(GV->getContext()), 1072ce718ff9f42c7da092eaa01dd0242e8d5ba84713Hans Wennborg GV->getName()+".init", GV->getThreadLocalMode()); 107383d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez bool InitBoolUsed = false; 107483d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez 107583d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez // Loop over all uses of GV, processing them in turn. 1076a687465bae9ce793444fef37eb790ac7722f6bc7Chris Lattner while (!GV->use_empty()) { 1077a687465bae9ce793444fef37eb790ac7722f6bc7Chris Lattner if (StoreInst *SI = dyn_cast<StoreInst>(GV->use_back())) { 107883d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez // The global is initialized when the store to it occurs. 1079fad4d40f3792b0d9e101c40738e1f691131007d2Nick Lewycky new StoreInst(ConstantInt::getTrue(GV->getContext()), InitBool, false, 0, 1080fad4d40f3792b0d9e101c40738e1f691131007d2Nick Lewycky SI->getOrdering(), SI->getSynchScope(), SI); 108183d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez SI->eraseFromParent(); 1082a687465bae9ce793444fef37eb790ac7722f6bc7Chris Lattner continue; 1083a687465bae9ce793444fef37eb790ac7722f6bc7Chris Lattner } 10849d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 1085a687465bae9ce793444fef37eb790ac7722f6bc7Chris Lattner LoadInst *LI = cast<LoadInst>(GV->use_back()); 1086a687465bae9ce793444fef37eb790ac7722f6bc7Chris Lattner while (!LI->use_empty()) { 1087a687465bae9ce793444fef37eb790ac7722f6bc7Chris Lattner Use &LoadUse = LI->use_begin().getUse(); 1088a687465bae9ce793444fef37eb790ac7722f6bc7Chris Lattner if (!isa<ICmpInst>(LoadUse.getUser())) { 1089a687465bae9ce793444fef37eb790ac7722f6bc7Chris Lattner LoadUse = RepValue; 1090a687465bae9ce793444fef37eb790ac7722f6bc7Chris Lattner continue; 1091a687465bae9ce793444fef37eb790ac7722f6bc7Chris Lattner } 10929d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 1093a687465bae9ce793444fef37eb790ac7722f6bc7Chris Lattner ICmpInst *ICI = cast<ICmpInst>(LoadUse.getUser()); 1094a687465bae9ce793444fef37eb790ac7722f6bc7Chris Lattner // Replace the cmp X, 0 with a use of the bool value. 1095fad4d40f3792b0d9e101c40738e1f691131007d2Nick Lewycky // Sink the load to where the compare was, if atomic rules allow us to. 1096fad4d40f3792b0d9e101c40738e1f691131007d2Nick Lewycky Value *LV = new LoadInst(InitBool, InitBool->getName()+".val", false, 0, 1097fad4d40f3792b0d9e101c40738e1f691131007d2Nick Lewycky LI->getOrdering(), LI->getSynchScope(), 1098fad4d40f3792b0d9e101c40738e1f691131007d2Nick Lewycky LI->isUnordered() ? (Instruction*)ICI : LI); 1099a687465bae9ce793444fef37eb790ac7722f6bc7Chris Lattner InitBoolUsed = true; 1100a687465bae9ce793444fef37eb790ac7722f6bc7Chris Lattner switch (ICI->getPredicate()) { 1101a687465bae9ce793444fef37eb790ac7722f6bc7Chris Lattner default: llvm_unreachable("Unknown ICmp Predicate!"); 1102a687465bae9ce793444fef37eb790ac7722f6bc7Chris Lattner case ICmpInst::ICMP_ULT: 1103a687465bae9ce793444fef37eb790ac7722f6bc7Chris Lattner case ICmpInst::ICMP_SLT: // X < null -> always false 1104a687465bae9ce793444fef37eb790ac7722f6bc7Chris Lattner LV = ConstantInt::getFalse(GV->getContext()); 1105a687465bae9ce793444fef37eb790ac7722f6bc7Chris Lattner break; 1106a687465bae9ce793444fef37eb790ac7722f6bc7Chris Lattner case ICmpInst::ICMP_ULE: 1107a687465bae9ce793444fef37eb790ac7722f6bc7Chris Lattner case ICmpInst::ICMP_SLE: 1108a687465bae9ce793444fef37eb790ac7722f6bc7Chris Lattner case ICmpInst::ICMP_EQ: 1109a687465bae9ce793444fef37eb790ac7722f6bc7Chris Lattner LV = BinaryOperator::CreateNot(LV, "notinit", ICI); 1110a687465bae9ce793444fef37eb790ac7722f6bc7Chris Lattner break; 1111a687465bae9ce793444fef37eb790ac7722f6bc7Chris Lattner case ICmpInst::ICMP_NE: 1112a687465bae9ce793444fef37eb790ac7722f6bc7Chris Lattner case ICmpInst::ICMP_UGE: 1113a687465bae9ce793444fef37eb790ac7722f6bc7Chris Lattner case ICmpInst::ICMP_SGE: 1114a687465bae9ce793444fef37eb790ac7722f6bc7Chris Lattner case ICmpInst::ICMP_UGT: 1115a687465bae9ce793444fef37eb790ac7722f6bc7Chris Lattner case ICmpInst::ICMP_SGT: 1116a687465bae9ce793444fef37eb790ac7722f6bc7Chris Lattner break; // no change. 1117a687465bae9ce793444fef37eb790ac7722f6bc7Chris Lattner } 1118a687465bae9ce793444fef37eb790ac7722f6bc7Chris Lattner ICI->replaceAllUsesWith(LV); 1119a687465bae9ce793444fef37eb790ac7722f6bc7Chris Lattner ICI->eraseFromParent(); 112083d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez } 1121a687465bae9ce793444fef37eb790ac7722f6bc7Chris Lattner LI->eraseFromParent(); 1122a687465bae9ce793444fef37eb790ac7722f6bc7Chris Lattner } 112383d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez 112483d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez // If the initialization boolean was used, insert it, otherwise delete it. 112583d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez if (!InitBoolUsed) { 112683d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez while (!InitBool->use_empty()) // Delete initializations 1127a687465bae9ce793444fef37eb790ac7722f6bc7Chris Lattner cast<StoreInst>(InitBool->use_back())->eraseFromParent(); 112883d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez delete InitBool; 112983d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez } else 113083d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez GV->getParent()->getGlobalList().insert(GV, InitBool); 113183d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez 1132a687465bae9ce793444fef37eb790ac7722f6bc7Chris Lattner // Now the GV is dead, nuke it and the malloc.. 113383d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez GV->eraseFromParent(); 113483d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez CI->eraseFromParent(); 113583d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez 113683d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez // To further other optimizations, loop over all users of NewGV and try to 113783d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez // constant prop them. This will promote GEP instructions with constant 113883d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez // indices into GEP constant-exprs, which will allow global-opt to hack on it. 11396a577f82ba56a4da48e984702240a01c3ba7e941Nick Lewycky ConstantPropUsersOf(NewGV, TD, TLI); 114083d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez if (RepValue != NewGV) 11416a577f82ba56a4da48e984702240a01c3ba7e941Nick Lewycky ConstantPropUsersOf(RepValue, TD, TLI); 114283d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez 114383d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez return NewGV; 114483d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez} 114583d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez 1146fa07e4fc302b1e274c292c2db4604e61d69458d5Chris Lattner/// ValueIsOnlyUsedLocallyOrStoredToOneGlobal - Scan the use-list of V checking 1147fa07e4fc302b1e274c292c2db4604e61d69458d5Chris Lattner/// to make sure that there are no complex uses of V. We permit simple things 1148fa07e4fc302b1e274c292c2db4604e61d69458d5Chris Lattner/// like dereferencing the pointer, but not storing through the address, unless 1149fa07e4fc302b1e274c292c2db4604e61d69458d5Chris Lattner/// it is to the specified global. 11500b520db74d75da91dbbc96ae7c939c49f1bc222dGabor Greifstatic bool ValueIsOnlyUsedLocallyOrStoredToOneGlobal(const Instruction *V, 11510b520db74d75da91dbbc96ae7c939c49f1bc222dGabor Greif const GlobalVariable *GV, 1152a01d6db569c7def7c5d1727fa1abedfc160b688cGabor Greif SmallPtrSet<const PHINode*, 8> &PHIs) { 11530b520db74d75da91dbbc96ae7c939c49f1bc222dGabor Greif for (Value::const_use_iterator UI = V->use_begin(), E = V->use_end(); 1154a01d6db569c7def7c5d1727fa1abedfc160b688cGabor Greif UI != E; ++UI) { 11550b520db74d75da91dbbc96ae7c939c49f1bc222dGabor Greif const Instruction *Inst = cast<Instruction>(*UI); 1156a01d6db569c7def7c5d1727fa1abedfc160b688cGabor Greif 115749b6d4ae9e3132525657880c45619f83e5c89c8fChris Lattner if (isa<LoadInst>(Inst) || isa<CmpInst>(Inst)) { 115849b6d4ae9e3132525657880c45619f83e5c89c8fChris Lattner continue; // Fine, ignore. 115949b6d4ae9e3132525657880c45619f83e5c89c8fChris Lattner } 11609d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 11610b520db74d75da91dbbc96ae7c939c49f1bc222dGabor Greif if (const StoreInst *SI = dyn_cast<StoreInst>(Inst)) { 1162fa07e4fc302b1e274c292c2db4604e61d69458d5Chris Lattner if (SI->getOperand(0) == V && SI->getOperand(1) != GV) 1163fa07e4fc302b1e274c292c2db4604e61d69458d5Chris Lattner return false; // Storing the pointer itself... bad. 116449b6d4ae9e3132525657880c45619f83e5c89c8fChris Lattner continue; // Otherwise, storing through it, or storing into GV... fine. 116549b6d4ae9e3132525657880c45619f83e5c89c8fChris Lattner } 11669d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 1167a2fb234b04eb632fb23aff72e56fd3962aa56e65Chris Lattner // Must index into the array and into the struct. 1168a2fb234b04eb632fb23aff72e56fd3962aa56e65Chris Lattner if (isa<GetElementPtrInst>(Inst) && Inst->getNumOperands() >= 3) { 116949b6d4ae9e3132525657880c45619f83e5c89c8fChris Lattner if (!ValueIsOnlyUsedLocallyOrStoredToOneGlobal(Inst, GV, PHIs)) 1170fa07e4fc302b1e274c292c2db4604e61d69458d5Chris Lattner return false; 117149b6d4ae9e3132525657880c45619f83e5c89c8fChris Lattner continue; 117249b6d4ae9e3132525657880c45619f83e5c89c8fChris Lattner } 11739d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 11740b520db74d75da91dbbc96ae7c939c49f1bc222dGabor Greif if (const PHINode *PN = dyn_cast<PHINode>(Inst)) { 1175c451f9c1670321256c22fc1a44a7cc62f7ad523bChris Lattner // PHIs are ok if all uses are ok. Don't infinitely recurse through PHI 1176c451f9c1670321256c22fc1a44a7cc62f7ad523bChris Lattner // cycles. 1177c451f9c1670321256c22fc1a44a7cc62f7ad523bChris Lattner if (PHIs.insert(PN)) 11785e6e494a977614568ed5582dacb548f8d466d398Chris Lattner if (!ValueIsOnlyUsedLocallyOrStoredToOneGlobal(PN, GV, PHIs)) 11795e6e494a977614568ed5582dacb548f8d466d398Chris Lattner return false; 118049b6d4ae9e3132525657880c45619f83e5c89c8fChris Lattner continue; 1181fa07e4fc302b1e274c292c2db4604e61d69458d5Chris Lattner } 11829d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 11830b520db74d75da91dbbc96ae7c939c49f1bc222dGabor Greif if (const BitCastInst *BCI = dyn_cast<BitCastInst>(Inst)) { 118449b6d4ae9e3132525657880c45619f83e5c89c8fChris Lattner if (!ValueIsOnlyUsedLocallyOrStoredToOneGlobal(BCI, GV, PHIs)) 118549b6d4ae9e3132525657880c45619f83e5c89c8fChris Lattner return false; 118649b6d4ae9e3132525657880c45619f83e5c89c8fChris Lattner continue; 118749b6d4ae9e3132525657880c45619f83e5c89c8fChris Lattner } 11889d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 118949b6d4ae9e3132525657880c45619f83e5c89c8fChris Lattner return false; 119049b6d4ae9e3132525657880c45619f83e5c89c8fChris Lattner } 1191fa07e4fc302b1e274c292c2db4604e61d69458d5Chris Lattner return true; 11928639503abe611a6655fc7ac78537770ce5983cb0Chris Lattner} 11938639503abe611a6655fc7ac78537770ce5983cb0Chris Lattner 11948639503abe611a6655fc7ac78537770ce5983cb0Chris Lattner/// ReplaceUsesOfMallocWithGlobal - The Alloc pointer is stored into GV 11958639503abe611a6655fc7ac78537770ce5983cb0Chris Lattner/// somewhere. Transform all uses of the allocation into loads from the 11968639503abe611a6655fc7ac78537770ce5983cb0Chris Lattner/// global and uses of the resultant pointer. Further, delete the store into 11979d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov/// GV. This assumes that these value pass the 11988639503abe611a6655fc7ac78537770ce5983cb0Chris Lattner/// 'ValueIsOnlyUsedLocallyOrStoredToOneGlobal' predicate. 11999d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkovstatic void ReplaceUsesOfMallocWithGlobal(Instruction *Alloc, 12008639503abe611a6655fc7ac78537770ce5983cb0Chris Lattner GlobalVariable *GV) { 12018639503abe611a6655fc7ac78537770ce5983cb0Chris Lattner while (!Alloc->use_empty()) { 1202a637a8b1e7ecc9ce06e0463b64be0721bf52255dChris Lattner Instruction *U = cast<Instruction>(*Alloc->use_begin()); 1203a637a8b1e7ecc9ce06e0463b64be0721bf52255dChris Lattner Instruction *InsertPt = U; 12048639503abe611a6655fc7ac78537770ce5983cb0Chris Lattner if (StoreInst *SI = dyn_cast<StoreInst>(U)) { 12058639503abe611a6655fc7ac78537770ce5983cb0Chris Lattner // If this is the store of the allocation into the global, remove it. 12068639503abe611a6655fc7ac78537770ce5983cb0Chris Lattner if (SI->getOperand(1) == GV) { 12078639503abe611a6655fc7ac78537770ce5983cb0Chris Lattner SI->eraseFromParent(); 12088639503abe611a6655fc7ac78537770ce5983cb0Chris Lattner continue; 12098639503abe611a6655fc7ac78537770ce5983cb0Chris Lattner } 1210a637a8b1e7ecc9ce06e0463b64be0721bf52255dChris Lattner } else if (PHINode *PN = dyn_cast<PHINode>(U)) { 1211a637a8b1e7ecc9ce06e0463b64be0721bf52255dChris Lattner // Insert the load in the corresponding predecessor, not right before the 1212a637a8b1e7ecc9ce06e0463b64be0721bf52255dChris Lattner // PHI. 1213a36791da41cf4f635e50077b290676b873836bdaGabor Greif InsertPt = PN->getIncomingBlock(Alloc->use_begin())->getTerminator(); 1214101f44e81f3bfae1b8ebefe74bef73883dac78acChris Lattner } else if (isa<BitCastInst>(U)) { 1215101f44e81f3bfae1b8ebefe74bef73883dac78acChris Lattner // Must be bitcast between the malloc and store to initialize the global. 1216101f44e81f3bfae1b8ebefe74bef73883dac78acChris Lattner ReplaceUsesOfMallocWithGlobal(U, GV); 1217101f44e81f3bfae1b8ebefe74bef73883dac78acChris Lattner U->eraseFromParent(); 1218101f44e81f3bfae1b8ebefe74bef73883dac78acChris Lattner continue; 1219101f44e81f3bfae1b8ebefe74bef73883dac78acChris Lattner } else if (GetElementPtrInst *GEPI = dyn_cast<GetElementPtrInst>(U)) { 1220101f44e81f3bfae1b8ebefe74bef73883dac78acChris Lattner // If this is a "GEP bitcast" and the user is a store to the global, then 1221101f44e81f3bfae1b8ebefe74bef73883dac78acChris Lattner // just process it as a bitcast. 1222101f44e81f3bfae1b8ebefe74bef73883dac78acChris Lattner if (GEPI->hasAllZeroIndices() && GEPI->hasOneUse()) 1223101f44e81f3bfae1b8ebefe74bef73883dac78acChris Lattner if (StoreInst *SI = dyn_cast<StoreInst>(GEPI->use_back())) 1224101f44e81f3bfae1b8ebefe74bef73883dac78acChris Lattner if (SI->getOperand(1) == GV) { 1225101f44e81f3bfae1b8ebefe74bef73883dac78acChris Lattner // Must be bitcast GEP between the malloc and store to initialize 1226101f44e81f3bfae1b8ebefe74bef73883dac78acChris Lattner // the global. 1227101f44e81f3bfae1b8ebefe74bef73883dac78acChris Lattner ReplaceUsesOfMallocWithGlobal(GEPI, GV); 1228101f44e81f3bfae1b8ebefe74bef73883dac78acChris Lattner GEPI->eraseFromParent(); 1229101f44e81f3bfae1b8ebefe74bef73883dac78acChris Lattner continue; 1230101f44e81f3bfae1b8ebefe74bef73883dac78acChris Lattner } 12318639503abe611a6655fc7ac78537770ce5983cb0Chris Lattner } 12329d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 12338639503abe611a6655fc7ac78537770ce5983cb0Chris Lattner // Insert a load from the global, and use it instead of the malloc. 1234a637a8b1e7ecc9ce06e0463b64be0721bf52255dChris Lattner Value *NL = new LoadInst(GV, GV->getName()+".val", InsertPt); 12358639503abe611a6655fc7ac78537770ce5983cb0Chris Lattner U->replaceUsesOfWith(Alloc, NL); 12368639503abe611a6655fc7ac78537770ce5983cb0Chris Lattner } 12378639503abe611a6655fc7ac78537770ce5983cb0Chris Lattner} 12388639503abe611a6655fc7ac78537770ce5983cb0Chris Lattner 123985d3d4f35de33c6d0d3800bd87619c00d06a98e2Chris Lattner/// LoadUsesSimpleEnoughForHeapSRA - Verify that all uses of V (a load, or a phi 124085d3d4f35de33c6d0d3800bd87619c00d06a98e2Chris Lattner/// of a load) are simple enough to perform heap SRA on. This permits GEP's 124185d3d4f35de33c6d0d3800bd87619c00d06a98e2Chris Lattner/// that index through the array and struct field, icmps of null, and PHIs. 1242c8b82ccbcf3b2e2384d2c0b5176e7b0b40b7f82fGabor Greifstatic bool LoadUsesSimpleEnoughForHeapSRA(const Value *V, 1243272369149209bad11f2b2f9020362f77fae60579Gabor Greif SmallPtrSet<const PHINode*, 32> &LoadUsingPHIs, 1244272369149209bad11f2b2f9020362f77fae60579Gabor Greif SmallPtrSet<const PHINode*, 32> &LoadUsingPHIsPerLoad) { 124585d3d4f35de33c6d0d3800bd87619c00d06a98e2Chris Lattner // We permit two users of the load: setcc comparing against the null 124685d3d4f35de33c6d0d3800bd87619c00d06a98e2Chris Lattner // pointer, and a getelementptr of a specific form. 1247272369149209bad11f2b2f9020362f77fae60579Gabor Greif for (Value::const_use_iterator UI = V->use_begin(), E = V->use_end(); UI != E; 1248272369149209bad11f2b2f9020362f77fae60579Gabor Greif ++UI) { 1249c8b82ccbcf3b2e2384d2c0b5176e7b0b40b7f82fGabor Greif const Instruction *User = cast<Instruction>(*UI); 12509d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 125185d3d4f35de33c6d0d3800bd87619c00d06a98e2Chris Lattner // Comparison against null is ok. 1252c8b82ccbcf3b2e2384d2c0b5176e7b0b40b7f82fGabor Greif if (const ICmpInst *ICI = dyn_cast<ICmpInst>(User)) { 125385d3d4f35de33c6d0d3800bd87619c00d06a98e2Chris Lattner if (!isa<ConstantPointerNull>(ICI->getOperand(1))) 125485d3d4f35de33c6d0d3800bd87619c00d06a98e2Chris Lattner return false; 125585d3d4f35de33c6d0d3800bd87619c00d06a98e2Chris Lattner continue; 125685d3d4f35de33c6d0d3800bd87619c00d06a98e2Chris Lattner } 12579d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 125885d3d4f35de33c6d0d3800bd87619c00d06a98e2Chris Lattner // getelementptr is also ok, but only a simple form. 1259c8b82ccbcf3b2e2384d2c0b5176e7b0b40b7f82fGabor Greif if (const GetElementPtrInst *GEPI = dyn_cast<GetElementPtrInst>(User)) { 126085d3d4f35de33c6d0d3800bd87619c00d06a98e2Chris Lattner // Must index into the array and into the struct. 126185d3d4f35de33c6d0d3800bd87619c00d06a98e2Chris Lattner if (GEPI->getNumOperands() < 3) 126285d3d4f35de33c6d0d3800bd87619c00d06a98e2Chris Lattner return false; 12639d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 126485d3d4f35de33c6d0d3800bd87619c00d06a98e2Chris Lattner // Otherwise the GEP is ok. 126585d3d4f35de33c6d0d3800bd87619c00d06a98e2Chris Lattner continue; 126685d3d4f35de33c6d0d3800bd87619c00d06a98e2Chris Lattner } 12679d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 1268c8b82ccbcf3b2e2384d2c0b5176e7b0b40b7f82fGabor Greif if (const PHINode *PN = dyn_cast<PHINode>(User)) { 12695d16396a33bfaa76da99c97c526a737af9618d05Evan Cheng if (!LoadUsingPHIsPerLoad.insert(PN)) 12705d16396a33bfaa76da99c97c526a737af9618d05Evan Cheng // This means some phi nodes are dependent on each other. 12715d16396a33bfaa76da99c97c526a737af9618d05Evan Cheng // Avoid infinite looping! 12725d16396a33bfaa76da99c97c526a737af9618d05Evan Cheng return false; 12735d16396a33bfaa76da99c97c526a737af9618d05Evan Cheng if (!LoadUsingPHIs.insert(PN)) 12745d16396a33bfaa76da99c97c526a737af9618d05Evan Cheng // If we have already analyzed this PHI, then it is safe. 127585d3d4f35de33c6d0d3800bd87619c00d06a98e2Chris Lattner continue; 12769d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 1277bce4afe83968bf6504aaf0791d4c49f971d58c52Chris Lattner // Make sure all uses of the PHI are simple enough to transform. 12785d16396a33bfaa76da99c97c526a737af9618d05Evan Cheng if (!LoadUsesSimpleEnoughForHeapSRA(PN, 12795d16396a33bfaa76da99c97c526a737af9618d05Evan Cheng LoadUsingPHIs, LoadUsingPHIsPerLoad)) 128085d3d4f35de33c6d0d3800bd87619c00d06a98e2Chris Lattner return false; 12819d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 128285d3d4f35de33c6d0d3800bd87619c00d06a98e2Chris Lattner continue; 12838639503abe611a6655fc7ac78537770ce5983cb0Chris Lattner } 12849d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 128585d3d4f35de33c6d0d3800bd87619c00d06a98e2Chris Lattner // Otherwise we don't know what this is, not ok. 128685d3d4f35de33c6d0d3800bd87619c00d06a98e2Chris Lattner return false; 128785d3d4f35de33c6d0d3800bd87619c00d06a98e2Chris Lattner } 12889d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 128985d3d4f35de33c6d0d3800bd87619c00d06a98e2Chris Lattner return true; 129085d3d4f35de33c6d0d3800bd87619c00d06a98e2Chris Lattner} 129185d3d4f35de33c6d0d3800bd87619c00d06a98e2Chris Lattner 129285d3d4f35de33c6d0d3800bd87619c00d06a98e2Chris Lattner 129385d3d4f35de33c6d0d3800bd87619c00d06a98e2Chris Lattner/// AllGlobalLoadUsesSimpleEnoughForHeapSRA - If all users of values loaded from 129485d3d4f35de33c6d0d3800bd87619c00d06a98e2Chris Lattner/// GV are simple enough to perform HeapSRA, return true. 1295c8b82ccbcf3b2e2384d2c0b5176e7b0b40b7f82fGabor Greifstatic bool AllGlobalLoadUsesSimpleEnoughForHeapSRA(const GlobalVariable *GV, 129683d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez Instruction *StoredVal) { 1297c8b82ccbcf3b2e2384d2c0b5176e7b0b40b7f82fGabor Greif SmallPtrSet<const PHINode*, 32> LoadUsingPHIs; 1298c8b82ccbcf3b2e2384d2c0b5176e7b0b40b7f82fGabor Greif SmallPtrSet<const PHINode*, 32> LoadUsingPHIsPerLoad; 1299272369149209bad11f2b2f9020362f77fae60579Gabor Greif for (Value::const_use_iterator UI = GV->use_begin(), E = GV->use_end(); 1300272369149209bad11f2b2f9020362f77fae60579Gabor Greif UI != E; ++UI) 1301c8b82ccbcf3b2e2384d2c0b5176e7b0b40b7f82fGabor Greif if (const LoadInst *LI = dyn_cast<LoadInst>(*UI)) { 13025d16396a33bfaa76da99c97c526a737af9618d05Evan Cheng if (!LoadUsesSimpleEnoughForHeapSRA(LI, LoadUsingPHIs, 13035d16396a33bfaa76da99c97c526a737af9618d05Evan Cheng LoadUsingPHIsPerLoad)) 1304bce4afe83968bf6504aaf0791d4c49f971d58c52Chris Lattner return false; 13055d16396a33bfaa76da99c97c526a737af9618d05Evan Cheng LoadUsingPHIsPerLoad.clear(); 13065d16396a33bfaa76da99c97c526a737af9618d05Evan Cheng } 13079d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 1308bce4afe83968bf6504aaf0791d4c49f971d58c52Chris Lattner // If we reach here, we know that all uses of the loads and transitive uses 1309bce4afe83968bf6504aaf0791d4c49f971d58c52Chris Lattner // (through PHI nodes) are simple enough to transform. However, we don't know 13109d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov // that all inputs the to the PHI nodes are in the same equivalence sets. 1311bce4afe83968bf6504aaf0791d4c49f971d58c52Chris Lattner // Check to verify that all operands of the PHIs are either PHIS that can be 1312bce4afe83968bf6504aaf0791d4c49f971d58c52Chris Lattner // transformed, loads from GV, or MI itself. 1313272369149209bad11f2b2f9020362f77fae60579Gabor Greif for (SmallPtrSet<const PHINode*, 32>::const_iterator I = LoadUsingPHIs.begin() 1314272369149209bad11f2b2f9020362f77fae60579Gabor Greif , E = LoadUsingPHIs.end(); I != E; ++I) { 1315c8b82ccbcf3b2e2384d2c0b5176e7b0b40b7f82fGabor Greif const PHINode *PN = *I; 1316bce4afe83968bf6504aaf0791d4c49f971d58c52Chris Lattner for (unsigned op = 0, e = PN->getNumIncomingValues(); op != e; ++op) { 1317bce4afe83968bf6504aaf0791d4c49f971d58c52Chris Lattner Value *InVal = PN->getIncomingValue(op); 13189d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 1319bce4afe83968bf6504aaf0791d4c49f971d58c52Chris Lattner // PHI of the stored value itself is ok. 132083d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez if (InVal == StoredVal) continue; 13219d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 1322c8b82ccbcf3b2e2384d2c0b5176e7b0b40b7f82fGabor Greif if (const PHINode *InPN = dyn_cast<PHINode>(InVal)) { 1323bce4afe83968bf6504aaf0791d4c49f971d58c52Chris Lattner // One of the PHIs in our set is (optimistically) ok. 1324bce4afe83968bf6504aaf0791d4c49f971d58c52Chris Lattner if (LoadUsingPHIs.count(InPN)) 1325bce4afe83968bf6504aaf0791d4c49f971d58c52Chris Lattner continue; 132685d3d4f35de33c6d0d3800bd87619c00d06a98e2Chris Lattner return false; 1327bce4afe83968bf6504aaf0791d4c49f971d58c52Chris Lattner } 13289d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 1329bce4afe83968bf6504aaf0791d4c49f971d58c52Chris Lattner // Load from GV is ok. 1330c8b82ccbcf3b2e2384d2c0b5176e7b0b40b7f82fGabor Greif if (const LoadInst *LI = dyn_cast<LoadInst>(InVal)) 1331bce4afe83968bf6504aaf0791d4c49f971d58c52Chris Lattner if (LI->getOperand(0) == GV) 1332bce4afe83968bf6504aaf0791d4c49f971d58c52Chris Lattner continue; 13339d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 1334bce4afe83968bf6504aaf0791d4c49f971d58c52Chris Lattner // UNDEF? NULL? 13359d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 1336bce4afe83968bf6504aaf0791d4c49f971d58c52Chris Lattner // Anything else is rejected. 1337bce4afe83968bf6504aaf0791d4c49f971d58c52Chris Lattner return false; 1338bce4afe83968bf6504aaf0791d4c49f971d58c52Chris Lattner } 1339bce4afe83968bf6504aaf0791d4c49f971d58c52Chris Lattner } 13409d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 13418639503abe611a6655fc7ac78537770ce5983cb0Chris Lattner return true; 13428639503abe611a6655fc7ac78537770ce5983cb0Chris Lattner} 13438639503abe611a6655fc7ac78537770ce5983cb0Chris Lattner 1344bce4afe83968bf6504aaf0791d4c49f971d58c52Chris Lattnerstatic Value *GetHeapSROAValue(Value *V, unsigned FieldNo, 1345bce4afe83968bf6504aaf0791d4c49f971d58c52Chris Lattner DenseMap<Value*, std::vector<Value*> > &InsertedScalarizedValues, 13467b550ccfc5a3346c17e0390a59e2d6d19bc52705Chris Lattner std::vector<std::pair<PHINode*, unsigned> > &PHIsToRewrite) { 1347bce4afe83968bf6504aaf0791d4c49f971d58c52Chris Lattner std::vector<Value*> &FieldVals = InsertedScalarizedValues[V]; 13489d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 1349bce4afe83968bf6504aaf0791d4c49f971d58c52Chris Lattner if (FieldNo >= FieldVals.size()) 1350bce4afe83968bf6504aaf0791d4c49f971d58c52Chris Lattner FieldVals.resize(FieldNo+1); 13519d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 1352bce4afe83968bf6504aaf0791d4c49f971d58c52Chris Lattner // If we already have this value, just reuse the previously scalarized 1353bce4afe83968bf6504aaf0791d4c49f971d58c52Chris Lattner // version. 1354bce4afe83968bf6504aaf0791d4c49f971d58c52Chris Lattner if (Value *FieldVal = FieldVals[FieldNo]) 1355bce4afe83968bf6504aaf0791d4c49f971d58c52Chris Lattner return FieldVal; 13569d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 1357bce4afe83968bf6504aaf0791d4c49f971d58c52Chris Lattner // Depending on what instruction this is, we have several cases. 1358bce4afe83968bf6504aaf0791d4c49f971d58c52Chris Lattner Value *Result; 1359bce4afe83968bf6504aaf0791d4c49f971d58c52Chris Lattner if (LoadInst *LI = dyn_cast<LoadInst>(V)) { 1360bce4afe83968bf6504aaf0791d4c49f971d58c52Chris Lattner // This is a scalarized version of the load from the global. Just create 1361bce4afe83968bf6504aaf0791d4c49f971d58c52Chris Lattner // a new Load of the scalarized global. 1362bce4afe83968bf6504aaf0791d4c49f971d58c52Chris Lattner Result = new LoadInst(GetHeapSROAValue(LI->getOperand(0), FieldNo, 1363bce4afe83968bf6504aaf0791d4c49f971d58c52Chris Lattner InsertedScalarizedValues, 13647b550ccfc5a3346c17e0390a59e2d6d19bc52705Chris Lattner PHIsToRewrite), 1365fe09b2098ac483f6d6ce6ea4ab237a9539bdb6b9Daniel Dunbar LI->getName()+".f"+Twine(FieldNo), LI); 1366bce4afe83968bf6504aaf0791d4c49f971d58c52Chris Lattner } else if (PHINode *PN = dyn_cast<PHINode>(V)) { 1367bce4afe83968bf6504aaf0791d4c49f971d58c52Chris Lattner // PN's type is pointer to struct. Make a new PHI of pointer to struct 1368bce4afe83968bf6504aaf0791d4c49f971d58c52Chris Lattner // field. 1369db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner StructType *ST = 1370bce4afe83968bf6504aaf0791d4c49f971d58c52Chris Lattner cast<StructType>(cast<PointerType>(PN->getType())->getElementType()); 13719d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 1372d8b4fb4aab4d6fedb2b14bed1b846451b17bde7cJay Foad PHINode *NewPN = 1373debcb01b0f0a15f568ca69e8f288fade4bfc7297Owen Anderson PHINode::Create(PointerType::getUnqual(ST->getElementType(FieldNo)), 13743ecfc861b4365f341c5c969b40e1afccde676e6fJay Foad PN->getNumIncomingValues(), 1375fe09b2098ac483f6d6ce6ea4ab237a9539bdb6b9Daniel Dunbar PN->getName()+".f"+Twine(FieldNo), PN); 1376d8b4fb4aab4d6fedb2b14bed1b846451b17bde7cJay Foad Result = NewPN; 1377bce4afe83968bf6504aaf0791d4c49f971d58c52Chris Lattner PHIsToRewrite.push_back(std::make_pair(PN, FieldNo)); 1378bce4afe83968bf6504aaf0791d4c49f971d58c52Chris Lattner } else { 1379c23197a26f34f559ea9797de51e187087c039c42Torok Edwin llvm_unreachable("Unknown usable value"); 1380bce4afe83968bf6504aaf0791d4c49f971d58c52Chris Lattner } 13819d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 1382bce4afe83968bf6504aaf0791d4c49f971d58c52Chris Lattner return FieldVals[FieldNo] = Result; 1383a637a8b1e7ecc9ce06e0463b64be0721bf52255dChris Lattner} 1384a637a8b1e7ecc9ce06e0463b64be0721bf52255dChris Lattner 1385330245e90bc3c74cebfbae47d67aaef8d74a73ddChris Lattner/// RewriteHeapSROALoadUser - Given a load instruction and a value derived from 1386330245e90bc3c74cebfbae47d67aaef8d74a73ddChris Lattner/// the load, rewrite the derived value to use the HeapSRoA'd load. 13879d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkovstatic void RewriteHeapSROALoadUser(Instruction *LoadUser, 1388bce4afe83968bf6504aaf0791d4c49f971d58c52Chris Lattner DenseMap<Value*, std::vector<Value*> > &InsertedScalarizedValues, 13897b550ccfc5a3346c17e0390a59e2d6d19bc52705Chris Lattner std::vector<std::pair<PHINode*, unsigned> > &PHIsToRewrite) { 1390330245e90bc3c74cebfbae47d67aaef8d74a73ddChris Lattner // If this is a comparison against null, handle it. 1391330245e90bc3c74cebfbae47d67aaef8d74a73ddChris Lattner if (ICmpInst *SCI = dyn_cast<ICmpInst>(LoadUser)) { 1392330245e90bc3c74cebfbae47d67aaef8d74a73ddChris Lattner assert(isa<ConstantPointerNull>(SCI->getOperand(1))); 1393330245e90bc3c74cebfbae47d67aaef8d74a73ddChris Lattner // If we have a setcc of the loaded pointer, we can use a setcc of any 1394330245e90bc3c74cebfbae47d67aaef8d74a73ddChris Lattner // field. 1395bce4afe83968bf6504aaf0791d4c49f971d58c52Chris Lattner Value *NPtr = GetHeapSROAValue(SCI->getOperand(0), 0, 13967b550ccfc5a3346c17e0390a59e2d6d19bc52705Chris Lattner InsertedScalarizedValues, PHIsToRewrite); 13979d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 1398333c40096561218bc3597cf153c0a3895274414cOwen Anderson Value *New = new ICmpInst(SCI, SCI->getPredicate(), NPtr, 13999d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov Constant::getNullValue(NPtr->getType()), 1400333c40096561218bc3597cf153c0a3895274414cOwen Anderson SCI->getName()); 1401330245e90bc3c74cebfbae47d67aaef8d74a73ddChris Lattner SCI->replaceAllUsesWith(New); 1402330245e90bc3c74cebfbae47d67aaef8d74a73ddChris Lattner SCI->eraseFromParent(); 1403330245e90bc3c74cebfbae47d67aaef8d74a73ddChris Lattner return; 1404330245e90bc3c74cebfbae47d67aaef8d74a73ddChris Lattner } 14059d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 1406bce4afe83968bf6504aaf0791d4c49f971d58c52Chris Lattner // Handle 'getelementptr Ptr, Idx, i32 FieldNo ...' 1407a637a8b1e7ecc9ce06e0463b64be0721bf52255dChris Lattner if (GetElementPtrInst *GEPI = dyn_cast<GetElementPtrInst>(LoadUser)) { 1408a637a8b1e7ecc9ce06e0463b64be0721bf52255dChris Lattner assert(GEPI->getNumOperands() >= 3 && isa<ConstantInt>(GEPI->getOperand(2)) 1409a637a8b1e7ecc9ce06e0463b64be0721bf52255dChris Lattner && "Unexpected GEPI!"); 14109d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 1411a637a8b1e7ecc9ce06e0463b64be0721bf52255dChris Lattner // Load the pointer for this field. 1412a637a8b1e7ecc9ce06e0463b64be0721bf52255dChris Lattner unsigned FieldNo = cast<ConstantInt>(GEPI->getOperand(2))->getZExtValue(); 1413bce4afe83968bf6504aaf0791d4c49f971d58c52Chris Lattner Value *NewPtr = GetHeapSROAValue(GEPI->getOperand(0), FieldNo, 14147b550ccfc5a3346c17e0390a59e2d6d19bc52705Chris Lattner InsertedScalarizedValues, PHIsToRewrite); 14159d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 1416a637a8b1e7ecc9ce06e0463b64be0721bf52255dChris Lattner // Create the new GEP idx vector. 1417a637a8b1e7ecc9ce06e0463b64be0721bf52255dChris Lattner SmallVector<Value*, 8> GEPIdx; 1418a637a8b1e7ecc9ce06e0463b64be0721bf52255dChris Lattner GEPIdx.push_back(GEPI->getOperand(1)); 1419a637a8b1e7ecc9ce06e0463b64be0721bf52255dChris Lattner GEPIdx.append(GEPI->op_begin()+3, GEPI->op_end()); 14209d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 1421a9203109f4ac95aa7e9624f2838e3d89623ec902Jay Foad Value *NGEPI = GetElementPtrInst::Create(NewPtr, GEPIdx, 1422051a950000e21935165db56695e35bade668193bGabor Greif GEPI->getName(), GEPI); 1423a637a8b1e7ecc9ce06e0463b64be0721bf52255dChris Lattner GEPI->replaceAllUsesWith(NGEPI); 1424a637a8b1e7ecc9ce06e0463b64be0721bf52255dChris Lattner GEPI->eraseFromParent(); 1425a637a8b1e7ecc9ce06e0463b64be0721bf52255dChris Lattner return; 1426a637a8b1e7ecc9ce06e0463b64be0721bf52255dChris Lattner } 1427bce4afe83968bf6504aaf0791d4c49f971d58c52Chris Lattner 1428bce4afe83968bf6504aaf0791d4c49f971d58c52Chris Lattner // Recursively transform the users of PHI nodes. This will lazily create the 1429bce4afe83968bf6504aaf0791d4c49f971d58c52Chris Lattner // PHIs that are needed for individual elements. Keep track of what PHIs we 1430bce4afe83968bf6504aaf0791d4c49f971d58c52Chris Lattner // see in InsertedScalarizedValues so that we don't get infinite loops (very 1431bce4afe83968bf6504aaf0791d4c49f971d58c52Chris Lattner // antisocial). If the PHI is already in InsertedScalarizedValues, it has 1432bce4afe83968bf6504aaf0791d4c49f971d58c52Chris Lattner // already been seen first by another load, so its uses have already been 1433bce4afe83968bf6504aaf0791d4c49f971d58c52Chris Lattner // processed. 1434a637a8b1e7ecc9ce06e0463b64be0721bf52255dChris Lattner PHINode *PN = cast<PHINode>(LoadUser); 1435c30a38f34bdfecb99ce49e3ffa479039c9bf0209Chris Lattner if (!InsertedScalarizedValues.insert(std::make_pair(PN, 1436c30a38f34bdfecb99ce49e3ffa479039c9bf0209Chris Lattner std::vector<Value*>())).second) 1437c30a38f34bdfecb99ce49e3ffa479039c9bf0209Chris Lattner return; 14389d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 1439bce4afe83968bf6504aaf0791d4c49f971d58c52Chris Lattner // If this is the first time we've seen this PHI, recursively process all 1440bce4afe83968bf6504aaf0791d4c49f971d58c52Chris Lattner // users. 1441f49a28cd0287351bce7a17dfffdbce4926763b5bChris Lattner for (Value::use_iterator UI = PN->use_begin(), E = PN->use_end(); UI != E; ) { 1442f49a28cd0287351bce7a17dfffdbce4926763b5bChris Lattner Instruction *User = cast<Instruction>(*UI++); 14437b550ccfc5a3346c17e0390a59e2d6d19bc52705Chris Lattner RewriteHeapSROALoadUser(User, InsertedScalarizedValues, PHIsToRewrite); 1444f49a28cd0287351bce7a17dfffdbce4926763b5bChris Lattner } 1445330245e90bc3c74cebfbae47d67aaef8d74a73ddChris Lattner} 1446330245e90bc3c74cebfbae47d67aaef8d74a73ddChris Lattner 14478639503abe611a6655fc7ac78537770ce5983cb0Chris Lattner/// RewriteUsesOfLoadForHeapSRoA - We are performing Heap SRoA on a global. Ptr 14488639503abe611a6655fc7ac78537770ce5983cb0Chris Lattner/// is a value loaded from the global. Eliminate all uses of Ptr, making them 14498639503abe611a6655fc7ac78537770ce5983cb0Chris Lattner/// use FieldGlobals instead. All uses of loaded values satisfy 145085d3d4f35de33c6d0d3800bd87619c00d06a98e2Chris Lattner/// AllGlobalLoadUsesSimpleEnoughForHeapSRA. 14519d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkovstatic void RewriteUsesOfLoadForHeapSRoA(LoadInst *Load, 1452bce4afe83968bf6504aaf0791d4c49f971d58c52Chris Lattner DenseMap<Value*, std::vector<Value*> > &InsertedScalarizedValues, 14537b550ccfc5a3346c17e0390a59e2d6d19bc52705Chris Lattner std::vector<std::pair<PHINode*, unsigned> > &PHIsToRewrite) { 1454bce4afe83968bf6504aaf0791d4c49f971d58c52Chris Lattner for (Value::use_iterator UI = Load->use_begin(), E = Load->use_end(); 1455f49a28cd0287351bce7a17dfffdbce4926763b5bChris Lattner UI != E; ) { 1456f49a28cd0287351bce7a17dfffdbce4926763b5bChris Lattner Instruction *User = cast<Instruction>(*UI++); 14577b550ccfc5a3346c17e0390a59e2d6d19bc52705Chris Lattner RewriteHeapSROALoadUser(User, InsertedScalarizedValues, PHIsToRewrite); 1458f49a28cd0287351bce7a17dfffdbce4926763b5bChris Lattner } 14599d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 1460bce4afe83968bf6504aaf0791d4c49f971d58c52Chris Lattner if (Load->use_empty()) { 1461bce4afe83968bf6504aaf0791d4c49f971d58c52Chris Lattner Load->eraseFromParent(); 1462bce4afe83968bf6504aaf0791d4c49f971d58c52Chris Lattner InsertedScalarizedValues.erase(Load); 1463bce4afe83968bf6504aaf0791d4c49f971d58c52Chris Lattner } 14648639503abe611a6655fc7ac78537770ce5983cb0Chris Lattner} 14658639503abe611a6655fc7ac78537770ce5983cb0Chris Lattner 146683d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez/// PerformHeapAllocSRoA - CI is an allocation of an array of structures. Break 146783d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez/// it up into multiple allocations of arrays of the fields. 14689d0b704e3ea418441001dac4d1a56c2c224cdbf5Victor Hernandezstatic GlobalVariable *PerformHeapAllocSRoA(GlobalVariable *GV, CallInst *CI, 14698e0d1c03ca7fd86e6879b4e37d0d7f0e982feef6Benjamin Kramer Value *NElems, TargetData *TD, 14708e0d1c03ca7fd86e6879b4e37d0d7f0e982feef6Benjamin Kramer const TargetLibraryInfo *TLI) { 14713215b0ee8248ca1e4bc2c7e2f5fd3ce120c3ee45David Greene DEBUG(dbgs() << "SROA HEAP ALLOC: " << *GV << " MALLOC = " << *CI << '\n'); 14728e0d1c03ca7fd86e6879b4e37d0d7f0e982feef6Benjamin Kramer Type *MAT = getMallocAllocatedType(CI, TLI); 1473db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner StructType *STy = cast<StructType>(MAT); 147483d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez 147583d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez // There is guaranteed to be at least one use of the malloc (storing 147683d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez // it into GV). If there are other uses, change them to be uses of 147783d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez // the global to simplify later code. This also deletes the store 147883d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez // into GV. 14799d0b704e3ea418441001dac4d1a56c2c224cdbf5Victor Hernandez ReplaceUsesOfMallocWithGlobal(CI, GV); 14809d0b704e3ea418441001dac4d1a56c2c224cdbf5Victor Hernandez 148183d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez // Okay, at this point, there are no users of the malloc. Insert N 148283d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez // new mallocs at the same place as CI, and N globals. 148383d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez std::vector<Value*> FieldGlobals; 148483d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez std::vector<Value*> FieldMallocs; 14859d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 148683d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez for (unsigned FieldNo = 0, e = STy->getNumElements(); FieldNo != e;++FieldNo){ 1487db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *FieldTy = STy->getElementType(FieldNo); 1488db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner PointerType *PFieldTy = PointerType::getUnqual(FieldTy); 14899d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 149083d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez GlobalVariable *NGV = 149183d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez new GlobalVariable(*GV->getParent(), 149283d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez PFieldTy, false, GlobalValue::InternalLinkage, 149383d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez Constant::getNullValue(PFieldTy), 149483d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez GV->getName() + ".f" + Twine(FieldNo), GV, 1495ce718ff9f42c7da092eaa01dd0242e8d5ba84713Hans Wennborg GV->getThreadLocalMode()); 149683d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez FieldGlobals.push_back(NGV); 14979d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 14989d0b704e3ea418441001dac4d1a56c2c224cdbf5Victor Hernandez unsigned TypeSize = TD->getTypeAllocSize(FieldTy); 1499db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner if (StructType *ST = dyn_cast<StructType>(FieldTy)) 15009d0b704e3ea418441001dac4d1a56c2c224cdbf5Victor Hernandez TypeSize = TD->getStructLayout(ST)->getSizeInBytes(); 1501db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *IntPtrTy = TD->getIntPtrType(CI->getContext()); 15029d0b704e3ea418441001dac4d1a56c2c224cdbf5Victor Hernandez Value *NMI = CallInst::CreateMalloc(CI, IntPtrTy, FieldTy, 15039d0b704e3ea418441001dac4d1a56c2c224cdbf5Victor Hernandez ConstantInt::get(IntPtrTy, TypeSize), 15045a30a8574cbcd3b385b1e8681c6a5c45856efb38Chris Lattner NElems, 0, 15059d0b704e3ea418441001dac4d1a56c2c224cdbf5Victor Hernandez CI->getName() + ".f" + Twine(FieldNo)); 15063f5e0b8114e8f446b42d5102805494801af38ecbChris Lattner FieldMallocs.push_back(NMI); 15079d0b704e3ea418441001dac4d1a56c2c224cdbf5Victor Hernandez new StoreInst(NMI, NGV, CI); 150883d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez } 15099d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 151083d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez // The tricky aspect of this transformation is handling the case when malloc 151183d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez // fails. In the original code, malloc failing would set the result pointer 151283d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez // of malloc to null. In this case, some mallocs could succeed and others 151383d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez // could fail. As such, we emit code that looks like this: 151483d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez // F0 = malloc(field0) 151583d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez // F1 = malloc(field1) 151683d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez // F2 = malloc(field2) 151783d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez // if (F0 == 0 || F1 == 0 || F2 == 0) { 151883d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez // if (F0) { free(F0); F0 = 0; } 151983d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez // if (F1) { free(F1); F1 = 0; } 152083d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez // if (F2) { free(F2); F2 = 0; } 152183d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez // } 15228e345a1c418608c49abb7c51a090bbb36f1273bcVictor Hernandez // The malloc can also fail if its argument is too large. 15239e4f243de7c0a41ae02c93f7209ad97935e9853dGabor Greif Constant *ConstantZero = ConstantInt::get(CI->getArgOperand(0)->getType(), 0); 15249e4f243de7c0a41ae02c93f7209ad97935e9853dGabor Greif Value *RunningOr = new ICmpInst(CI, ICmpInst::ICMP_SLT, CI->getArgOperand(0), 15258e345a1c418608c49abb7c51a090bbb36f1273bcVictor Hernandez ConstantZero, "isneg"); 152683d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez for (unsigned i = 0, e = FieldMallocs.size(); i != e; ++i) { 15279d0b704e3ea418441001dac4d1a56c2c224cdbf5Victor Hernandez Value *Cond = new ICmpInst(CI, ICmpInst::ICMP_EQ, FieldMallocs[i], 15289d0b704e3ea418441001dac4d1a56c2c224cdbf5Victor Hernandez Constant::getNullValue(FieldMallocs[i]->getType()), 15299d0b704e3ea418441001dac4d1a56c2c224cdbf5Victor Hernandez "isnull"); 15308e345a1c418608c49abb7c51a090bbb36f1273bcVictor Hernandez RunningOr = BinaryOperator::CreateOr(RunningOr, Cond, "tmp", CI); 153183d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez } 153283d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez 153383d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez // Split the basic block at the old malloc. 15349d0b704e3ea418441001dac4d1a56c2c224cdbf5Victor Hernandez BasicBlock *OrigBB = CI->getParent(); 15359d0b704e3ea418441001dac4d1a56c2c224cdbf5Victor Hernandez BasicBlock *ContBB = OrigBB->splitBasicBlock(CI, "malloc_cont"); 15369d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 153783d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez // Create the block to check the first condition. Put all these blocks at the 153883d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez // end of the function as they are unlikely to be executed. 15397b550ccfc5a3346c17e0390a59e2d6d19bc52705Chris Lattner BasicBlock *NullPtrBlock = BasicBlock::Create(OrigBB->getContext(), 15407b550ccfc5a3346c17e0390a59e2d6d19bc52705Chris Lattner "malloc_ret_null", 154183d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez OrigBB->getParent()); 15429d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 154383d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez // Remove the uncond branch from OrigBB to ContBB, turning it into a cond 154483d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez // branch on RunningOr. 154583d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez OrigBB->getTerminator()->eraseFromParent(); 154683d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez BranchInst::Create(NullPtrBlock, ContBB, RunningOr, OrigBB); 15479d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 154883d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez // Within the NullPtrBlock, we need to emit a comparison and branch for each 154983d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez // pointer, because some may be null while others are not. 155083d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez for (unsigned i = 0, e = FieldGlobals.size(); i != e; ++i) { 155183d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez Value *GVVal = new LoadInst(FieldGlobals[i], "tmp", NullPtrBlock); 15529d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov Value *Cmp = new ICmpInst(*NullPtrBlock, ICmpInst::ICMP_NE, GVVal, 1553a9390a4d5f5d568059a80970d22194b165d097a7Benjamin Kramer Constant::getNullValue(GVVal->getType())); 15547b550ccfc5a3346c17e0390a59e2d6d19bc52705Chris Lattner BasicBlock *FreeBlock = BasicBlock::Create(Cmp->getContext(), "free_it", 155583d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez OrigBB->getParent()); 15567b550ccfc5a3346c17e0390a59e2d6d19bc52705Chris Lattner BasicBlock *NextBlock = BasicBlock::Create(Cmp->getContext(), "next", 155783d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez OrigBB->getParent()); 155866284e063a1e46500acae48bdc0e4a00652021d1Victor Hernandez Instruction *BI = BranchInst::Create(FreeBlock, NextBlock, 155966284e063a1e46500acae48bdc0e4a00652021d1Victor Hernandez Cmp, NullPtrBlock); 156083d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez 156183d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez // Fill in FreeBlock. 156266284e063a1e46500acae48bdc0e4a00652021d1Victor Hernandez CallInst::CreateFree(GVVal, BI); 156383d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez new StoreInst(Constant::getNullValue(GVVal->getType()), FieldGlobals[i], 156483d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez FreeBlock); 156583d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez BranchInst::Create(NextBlock, FreeBlock); 15669d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 156783d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez NullPtrBlock = NextBlock; 156883d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez } 15699d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 157083d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez BranchInst::Create(ContBB, NullPtrBlock); 15719d0b704e3ea418441001dac4d1a56c2c224cdbf5Victor Hernandez 15729d0b704e3ea418441001dac4d1a56c2c224cdbf5Victor Hernandez // CI is no longer needed, remove it. 157383d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez CI->eraseFromParent(); 157483d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez 157583d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez /// InsertedScalarizedLoads - As we process loads, if we can't immediately 157683d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez /// update all uses of the load, keep track of what scalarized loads are 157783d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez /// inserted for a given load. 157883d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez DenseMap<Value*, std::vector<Value*> > InsertedScalarizedValues; 157983d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez InsertedScalarizedValues[GV] = FieldGlobals; 15809d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 158183d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez std::vector<std::pair<PHINode*, unsigned> > PHIsToRewrite; 15829d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 158383d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez // Okay, the malloc site is completely handled. All of the uses of GV are now 158483d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez // loads, and all uses of those loads are simple. Rewrite them to use loads 158583d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez // of the per-field globals instead. 158683d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez for (Value::use_iterator UI = GV->use_begin(), E = GV->use_end(); UI != E;) { 158783d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez Instruction *User = cast<Instruction>(*UI++); 15889d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 158983d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez if (LoadInst *LI = dyn_cast<LoadInst>(User)) { 15907b550ccfc5a3346c17e0390a59e2d6d19bc52705Chris Lattner RewriteUsesOfLoadForHeapSRoA(LI, InsertedScalarizedValues, PHIsToRewrite); 159183d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez continue; 159283d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez } 15939d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 159483d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez // Must be a store of null. 159583d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez StoreInst *SI = cast<StoreInst>(User); 159683d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez assert(isa<ConstantPointerNull>(SI->getOperand(0)) && 159783d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez "Unexpected heap-sra user!"); 15989d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 159983d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez // Insert a store of null into each global. 160083d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez for (unsigned i = 0, e = FieldGlobals.size(); i != e; ++i) { 1601db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner PointerType *PT = cast<PointerType>(FieldGlobals[i]->getType()); 160283d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez Constant *Null = Constant::getNullValue(PT->getElementType()); 160383d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez new StoreInst(Null, FieldGlobals[i], SI); 160483d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez } 160583d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez // Erase the original store. 160683d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez SI->eraseFromParent(); 160783d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez } 160883d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez 160983d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez // While we have PHIs that are interesting to rewrite, do it. 161083d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez while (!PHIsToRewrite.empty()) { 161183d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez PHINode *PN = PHIsToRewrite.back().first; 161283d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez unsigned FieldNo = PHIsToRewrite.back().second; 161383d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez PHIsToRewrite.pop_back(); 161483d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez PHINode *FieldPN = cast<PHINode>(InsertedScalarizedValues[PN][FieldNo]); 161583d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez assert(FieldPN->getNumIncomingValues() == 0 &&"Already processed this phi"); 161683d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez 161783d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez // Add all the incoming values. This can materialize more phis. 161883d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i) { 161983d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez Value *InVal = PN->getIncomingValue(i); 162083d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez InVal = GetHeapSROAValue(InVal, FieldNo, InsertedScalarizedValues, 16217b550ccfc5a3346c17e0390a59e2d6d19bc52705Chris Lattner PHIsToRewrite); 162283d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez FieldPN->addIncoming(InVal, PN->getIncomingBlock(i)); 162383d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez } 162483d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez } 16259d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 162683d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez // Drop all inter-phi links and any loads that made it this far. 162783d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez for (DenseMap<Value*, std::vector<Value*> >::iterator 162883d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez I = InsertedScalarizedValues.begin(), E = InsertedScalarizedValues.end(); 162983d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez I != E; ++I) { 163083d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez if (PHINode *PN = dyn_cast<PHINode>(I->first)) 163183d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez PN->dropAllReferences(); 163283d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez else if (LoadInst *LI = dyn_cast<LoadInst>(I->first)) 163383d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez LI->dropAllReferences(); 163483d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez } 16359d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 163683d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez // Delete all the phis and loads now that inter-references are dead. 163783d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez for (DenseMap<Value*, std::vector<Value*> >::iterator 163883d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez I = InsertedScalarizedValues.begin(), E = InsertedScalarizedValues.end(); 163983d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez I != E; ++I) { 164083d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez if (PHINode *PN = dyn_cast<PHINode>(I->first)) 164183d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez PN->eraseFromParent(); 164283d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez else if (LoadInst *LI = dyn_cast<LoadInst>(I->first)) 164383d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez LI->eraseFromParent(); 164483d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez } 16459d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 164683d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez // The old global is now dead, remove it. 164783d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez GV->eraseFromParent(); 164883d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez 164983d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez ++NumHeapSRA; 165083d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez return cast<GlobalVariable>(FieldGlobals[0]); 165183d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez} 165283d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez 1653e61d0a626e58bdba004a7aad9abecb3a9bd85256Chris Lattner/// TryToOptimizeStoreOfMallocToGlobal - This function is called when we see a 1654e61d0a626e58bdba004a7aad9abecb3a9bd85256Chris Lattner/// pointer global variable with a single value stored it that is a malloc or 1655e61d0a626e58bdba004a7aad9abecb3a9bd85256Chris Lattner/// cast of malloc. 1656e61d0a626e58bdba004a7aad9abecb3a9bd85256Chris Lattnerstatic bool TryToOptimizeStoreOfMallocToGlobal(GlobalVariable *GV, 165783d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez CallInst *CI, 1658db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *AllocTy, 1659fad4d40f3792b0d9e101c40738e1f691131007d2Nick Lewycky AtomicOrdering Ordering, 166083d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez Module::global_iterator &GVI, 16616a577f82ba56a4da48e984702240a01c3ba7e941Nick Lewycky TargetData *TD, 16626a577f82ba56a4da48e984702240a01c3ba7e941Nick Lewycky TargetLibraryInfo *TLI) { 166386cd445645803282db7eccda297e0c19e9e25b51Evan Cheng if (!TD) 166486cd445645803282db7eccda297e0c19e9e25b51Evan Cheng return false; 16659d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 166683d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez // If this is a malloc of an abstract type, don't touch it. 166783d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez if (!AllocTy->isSized()) 166883d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez return false; 166983d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez 167083d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez // We can't optimize this global unless all uses of it are *known* to be 167183d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez // of the malloc value, not of the null initializer value (consider a use 167283d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez // that compares the global's value against zero to see if the malloc has 167383d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez // been reached). To do this, we check to see if all uses of the global 167483d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez // would trap if the global were null: this proves that they must all 167583d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez // happen after the malloc. 167683d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez if (!AllUsesOfLoadedValueWillTrapIfNull(GV)) 167783d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez return false; 167883d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez 167983d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez // We can't optimize this if the malloc itself is used in a complex way, 168083d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez // for example, being stored into multiple globals. This allows the 1681bc384a1feb08141691ef994a7d11a506e89c5a62Nick Lewycky // malloc to be stored into the specified global, loaded icmp'd, and 168283d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez // GEP'd. These are all things we could transform to using the global 168383d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez // for. 168486cd445645803282db7eccda297e0c19e9e25b51Evan Cheng SmallPtrSet<const PHINode*, 8> PHIs; 168586cd445645803282db7eccda297e0c19e9e25b51Evan Cheng if (!ValueIsOnlyUsedLocallyOrStoredToOneGlobal(CI, GV, PHIs)) 168686cd445645803282db7eccda297e0c19e9e25b51Evan Cheng return false; 168783d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez 168883d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez // If we have a global that is only initialized with a fixed size malloc, 168983d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez // transform the program to use global memory instead of malloc'd memory. 169083d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez // This eliminates dynamic allocation, avoids an indirection accessing the 169183d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez // data, and exposes the resultant global to further GlobalOpt. 16928db42d2b1ce05e69b67f37c4e56a0f987a0c01d7Victor Hernandez // We cannot optimize the malloc if we cannot determine malloc array size. 16938e0d1c03ca7fd86e6879b4e37d0d7f0e982feef6Benjamin Kramer Value *NElems = getMallocArraySize(CI, TD, TLI, true); 169486cd445645803282db7eccda297e0c19e9e25b51Evan Cheng if (!NElems) 169586cd445645803282db7eccda297e0c19e9e25b51Evan Cheng return false; 169686cd445645803282db7eccda297e0c19e9e25b51Evan Cheng 169786cd445645803282db7eccda297e0c19e9e25b51Evan Cheng if (ConstantInt *NElements = dyn_cast<ConstantInt>(NElems)) 169886cd445645803282db7eccda297e0c19e9e25b51Evan Cheng // Restrict this transformation to only working on small allocations 169986cd445645803282db7eccda297e0c19e9e25b51Evan Cheng // (2048 bytes currently), as we don't want to introduce a 16M global or 170086cd445645803282db7eccda297e0c19e9e25b51Evan Cheng // something. 170186cd445645803282db7eccda297e0c19e9e25b51Evan Cheng if (NElements->getZExtValue() * TD->getTypeAllocSize(AllocTy) < 2048) { 17026a577f82ba56a4da48e984702240a01c3ba7e941Nick Lewycky GVI = OptimizeGlobalAddressOfMalloc(GV, CI, AllocTy, NElements, TD, TLI); 170386cd445645803282db7eccda297e0c19e9e25b51Evan Cheng return true; 170486cd445645803282db7eccda297e0c19e9e25b51Evan Cheng } 17059d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 170686cd445645803282db7eccda297e0c19e9e25b51Evan Cheng // If the allocation is an array of structures, consider transforming this 170786cd445645803282db7eccda297e0c19e9e25b51Evan Cheng // into multiple malloc'd arrays, one for each field. This is basically 170886cd445645803282db7eccda297e0c19e9e25b51Evan Cheng // SRoA for malloc'd memory. 170986cd445645803282db7eccda297e0c19e9e25b51Evan Cheng 1710fad4d40f3792b0d9e101c40738e1f691131007d2Nick Lewycky if (Ordering != NotAtomic) 1711fad4d40f3792b0d9e101c40738e1f691131007d2Nick Lewycky return false; 1712fad4d40f3792b0d9e101c40738e1f691131007d2Nick Lewycky 171386cd445645803282db7eccda297e0c19e9e25b51Evan Cheng // If this is an allocation of a fixed size array of structs, analyze as a 171486cd445645803282db7eccda297e0c19e9e25b51Evan Cheng // variable size array. malloc [100 x struct],1 -> malloc struct, 100 17159e4f243de7c0a41ae02c93f7209ad97935e9853dGabor Greif if (NElems == ConstantInt::get(CI->getArgOperand(0)->getType(), 1)) 1716db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner if (ArrayType *AT = dyn_cast<ArrayType>(AllocTy)) 171786cd445645803282db7eccda297e0c19e9e25b51Evan Cheng AllocTy = AT->getElementType(); 17189e4f243de7c0a41ae02c93f7209ad97935e9853dGabor Greif 1719db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner StructType *AllocSTy = dyn_cast<StructType>(AllocTy); 172086cd445645803282db7eccda297e0c19e9e25b51Evan Cheng if (!AllocSTy) 172186cd445645803282db7eccda297e0c19e9e25b51Evan Cheng return false; 172286cd445645803282db7eccda297e0c19e9e25b51Evan Cheng 172386cd445645803282db7eccda297e0c19e9e25b51Evan Cheng // This the structure has an unreasonable number of fields, leave it 172486cd445645803282db7eccda297e0c19e9e25b51Evan Cheng // alone. 172586cd445645803282db7eccda297e0c19e9e25b51Evan Cheng if (AllocSTy->getNumElements() <= 16 && AllocSTy->getNumElements() != 0 && 172686cd445645803282db7eccda297e0c19e9e25b51Evan Cheng AllGlobalLoadUsesSimpleEnoughForHeapSRA(GV, CI)) { 172786cd445645803282db7eccda297e0c19e9e25b51Evan Cheng 172886cd445645803282db7eccda297e0c19e9e25b51Evan Cheng // If this is a fixed size array, transform the Malloc to be an alloc of 172986cd445645803282db7eccda297e0c19e9e25b51Evan Cheng // structs. malloc [100 x struct],1 -> malloc struct, 100 17308e0d1c03ca7fd86e6879b4e37d0d7f0e982feef6Benjamin Kramer if (ArrayType *AT = dyn_cast<ArrayType>(getMallocAllocatedType(CI, TLI))) { 1731db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *IntPtrTy = TD->getIntPtrType(CI->getContext()); 173286cd445645803282db7eccda297e0c19e9e25b51Evan Cheng unsigned TypeSize = TD->getStructLayout(AllocSTy)->getSizeInBytes(); 173386cd445645803282db7eccda297e0c19e9e25b51Evan Cheng Value *AllocSize = ConstantInt::get(IntPtrTy, TypeSize); 173486cd445645803282db7eccda297e0c19e9e25b51Evan Cheng Value *NumElements = ConstantInt::get(IntPtrTy, AT->getNumElements()); 173586cd445645803282db7eccda297e0c19e9e25b51Evan Cheng Instruction *Malloc = CallInst::CreateMalloc(CI, IntPtrTy, AllocSTy, 173686cd445645803282db7eccda297e0c19e9e25b51Evan Cheng AllocSize, NumElements, 17375a30a8574cbcd3b385b1e8681c6a5c45856efb38Chris Lattner 0, CI->getName()); 173886cd445645803282db7eccda297e0c19e9e25b51Evan Cheng Instruction *Cast = new BitCastInst(Malloc, CI->getType(), "tmp", CI); 173986cd445645803282db7eccda297e0c19e9e25b51Evan Cheng CI->replaceAllUsesWith(Cast); 174086cd445645803282db7eccda297e0c19e9e25b51Evan Cheng CI->eraseFromParent(); 1741eb7c6865cd8d44a882aa7c3e10e1d976f333344fNuno Lopes if (BitCastInst *BCI = dyn_cast<BitCastInst>(Malloc)) 1742eb7c6865cd8d44a882aa7c3e10e1d976f333344fNuno Lopes CI = cast<CallInst>(BCI->getOperand(0)); 1743eb7c6865cd8d44a882aa7c3e10e1d976f333344fNuno Lopes else 1744cd88efe516510d3413c0e880217779e3eb56e956Nuno Lopes CI = cast<CallInst>(Malloc); 174583d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez } 17469d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 17478e0d1c03ca7fd86e6879b4e37d0d7f0e982feef6Benjamin Kramer GVI = PerformHeapAllocSRoA(GV, CI, getMallocArraySize(CI, TD, TLI, true), 17488e0d1c03ca7fd86e6879b4e37d0d7f0e982feef6Benjamin Kramer TD, TLI); 174986cd445645803282db7eccda297e0c19e9e25b51Evan Cheng return true; 175083d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez } 17519d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 175283d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez return false; 17539d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov} 175483d63919bd990ce00f62e18114504b9e4a5cb35eVictor Hernandez 17559b34a6101908c36df659fe0b188713c949a32304Chris Lattner// OptimizeOnceStoredGlobal - Try to optimize globals based on the knowledge 17569b34a6101908c36df659fe0b188713c949a32304Chris Lattner// that only one value (besides its initializer) is ever stored to the global. 175730ba5690cf7a6f4db8913463d03f239f82d17440Chris Lattnerstatic bool OptimizeOnceStoredGlobal(GlobalVariable *GV, Value *StoredOnceVal, 1758fad4d40f3792b0d9e101c40738e1f691131007d2Nick Lewycky AtomicOrdering Ordering, 17597f8897f22e88271cfa114998a4d6088e7c8e8e11Chris Lattner Module::global_iterator &GVI, 17606a577f82ba56a4da48e984702240a01c3ba7e941Nick Lewycky TargetData *TD, TargetLibraryInfo *TLI) { 1761344b41cfbd30980a2194c56db382b0537d087ea9Chris Lattner // Ignore no-op GEPs and bitcasts. 1762344b41cfbd30980a2194c56db382b0537d087ea9Chris Lattner StoredOnceVal = StoredOnceVal->stripPointerCasts(); 17639b34a6101908c36df659fe0b188713c949a32304Chris Lattner 1764708148e41f8f7c1e24c73cfd943645b13a1e05f9Chris Lattner // If we are dealing with a pointer global that is initialized to null and 1765708148e41f8f7c1e24c73cfd943645b13a1e05f9Chris Lattner // only has one (non-null) value stored into it, then we can optimize any 1766708148e41f8f7c1e24c73cfd943645b13a1e05f9Chris Lattner // users of the loaded value (often calls and loads) that would trap if the 1767708148e41f8f7c1e24c73cfd943645b13a1e05f9Chris Lattner // value was null. 17681df9859c40492511b8aa4321eb76496005d3b75bDuncan Sands if (GV->getInitializer()->getType()->isPointerTy() && 17699b34a6101908c36df659fe0b188713c949a32304Chris Lattner GV->getInitializer()->isNullValue()) { 1770708148e41f8f7c1e24c73cfd943645b13a1e05f9Chris Lattner if (Constant *SOVC = dyn_cast<Constant>(StoredOnceVal)) { 1771708148e41f8f7c1e24c73cfd943645b13a1e05f9Chris Lattner if (GV->getInitializer()->getType() != SOVC->getType()) 177298a42b2fc39f3fc46905fb98078cce4ce4e0a827Chris Lattner SOVC = ConstantExpr::getBitCast(SOVC, GV->getInitializer()->getType()); 1773fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman 1774708148e41f8f7c1e24c73cfd943645b13a1e05f9Chris Lattner // Optimize away any trapping uses of the loaded value. 17756a577f82ba56a4da48e984702240a01c3ba7e941Nick Lewycky if (OptimizeAwayTrappingUsesOfLoads(GV, SOVC, TD, TLI)) 17768be8012ba493f1b17967c4ad7863c5709bf34a75Chris Lattner return true; 17778e0d1c03ca7fd86e6879b4e37d0d7f0e982feef6Benjamin Kramer } else if (CallInst *CI = extractMallocCall(StoredOnceVal, TLI)) { 17788e0d1c03ca7fd86e6879b4e37d0d7f0e982feef6Benjamin Kramer Type *MallocType = getMallocAllocatedType(CI, TLI); 17796a577f82ba56a4da48e984702240a01c3ba7e941Nick Lewycky if (MallocType && 17806a577f82ba56a4da48e984702240a01c3ba7e941Nick Lewycky TryToOptimizeStoreOfMallocToGlobal(GV, CI, MallocType, Ordering, GVI, 17816a577f82ba56a4da48e984702240a01c3ba7e941Nick Lewycky TD, TLI)) 17829d0b704e3ea418441001dac4d1a56c2c224cdbf5Victor Hernandez return true; 1783708148e41f8f7c1e24c73cfd943645b13a1e05f9Chris Lattner } 17849b34a6101908c36df659fe0b188713c949a32304Chris Lattner } 178530ba5690cf7a6f4db8913463d03f239f82d17440Chris Lattner 17869b34a6101908c36df659fe0b188713c949a32304Chris Lattner return false; 17879b34a6101908c36df659fe0b188713c949a32304Chris Lattner} 1788a4be1dc0a192175bbc561a633c0b7197853e6a74Chris Lattner 178958e44f49ddd16825fbacc60d6146376ca17f47ebChris Lattner/// TryToShrinkGlobalToBoolean - At this point, we have learned that the only 179058e44f49ddd16825fbacc60d6146376ca17f47ebChris Lattner/// two values ever stored into GV are its initializer and OtherVal. See if we 179158e44f49ddd16825fbacc60d6146376ca17f47ebChris Lattner/// can shrink the global into a boolean and select between the two values 179258e44f49ddd16825fbacc60d6146376ca17f47ebChris Lattner/// whenever it is used. This exposes the values to other scalar optimizations. 17937b550ccfc5a3346c17e0390a59e2d6d19bc52705Chris Lattnerstatic bool TryToShrinkGlobalToBoolean(GlobalVariable *GV, Constant *OtherVal) { 1794db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *GVElType = GV->getType()->getElementType(); 17959d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 179658e44f49ddd16825fbacc60d6146376ca17f47ebChris Lattner // If GVElType is already i1, it is already shrunk. If the type of the GV is 17976f6923fd4fdab46c88503c71548e076dd7373b74Chris Lattner // an FP value, pointer or vector, don't do this optimization because a select 17986f6923fd4fdab46c88503c71548e076dd7373b74Chris Lattner // between them is very expensive and unlikely to lead to later 17996f6923fd4fdab46c88503c71548e076dd7373b74Chris Lattner // simplification. In these cases, we typically end up with "cond ? v1 : v2" 18006f6923fd4fdab46c88503c71548e076dd7373b74Chris Lattner // where v1 and v2 both require constant pool loads, a big loss. 18017b550ccfc5a3346c17e0390a59e2d6d19bc52705Chris Lattner if (GVElType == Type::getInt1Ty(GV->getContext()) || 1802b0bc6c361da9009e8414efde317d9bbff755f6c0Duncan Sands GVElType->isFloatingPointTy() || 18031df9859c40492511b8aa4321eb76496005d3b75bDuncan Sands GVElType->isPointerTy() || GVElType->isVectorTy()) 180458e44f49ddd16825fbacc60d6146376ca17f47ebChris Lattner return false; 1805aaaaa02a93d3815d4cde97071ed354acc64ec6f6Gabor Greif 180658e44f49ddd16825fbacc60d6146376ca17f47ebChris Lattner // Walk the use list of the global seeing if all the uses are load or store. 180758e44f49ddd16825fbacc60d6146376ca17f47ebChris Lattner // If there is anything else, bail out. 1808aaaaa02a93d3815d4cde97071ed354acc64ec6f6Gabor Greif for (Value::use_iterator I = GV->use_begin(), E = GV->use_end(); I != E; ++I){ 1809aaaaa02a93d3815d4cde97071ed354acc64ec6f6Gabor Greif User *U = *I; 1810aaaaa02a93d3815d4cde97071ed354acc64ec6f6Gabor Greif if (!isa<LoadInst>(U) && !isa<StoreInst>(U)) 181158e44f49ddd16825fbacc60d6146376ca17f47ebChris Lattner return false; 1812aaaaa02a93d3815d4cde97071ed354acc64ec6f6Gabor Greif } 1813aaaaa02a93d3815d4cde97071ed354acc64ec6f6Gabor Greif 18143215b0ee8248ca1e4bc2c7e2f5fd3ce120c3ee45David Greene DEBUG(dbgs() << " *** SHRINKING TO BOOL: " << *GV); 18159d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 181696a86b2993c03be1de934b2c4e10ed08dbacfe0aChris Lattner // Create the new global, initializing it to false. 18177b550ccfc5a3346c17e0390a59e2d6d19bc52705Chris Lattner GlobalVariable *NewGV = new GlobalVariable(Type::getInt1Ty(GV->getContext()), 18187b550ccfc5a3346c17e0390a59e2d6d19bc52705Chris Lattner false, 18199d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov GlobalValue::InternalLinkage, 18207b550ccfc5a3346c17e0390a59e2d6d19bc52705Chris Lattner ConstantInt::getFalse(GV->getContext()), 18210e670dfa277279463d7c8d8bba093c2b2160d9ffNick Lewycky GV->getName()+".b", 1822ce718ff9f42c7da092eaa01dd0242e8d5ba84713Hans Wennborg GV->getThreadLocalMode()); 182396a86b2993c03be1de934b2c4e10ed08dbacfe0aChris Lattner GV->getParent()->getGlobalList().insert(GV, NewGV); 182496a86b2993c03be1de934b2c4e10ed08dbacfe0aChris Lattner 182596a86b2993c03be1de934b2c4e10ed08dbacfe0aChris Lattner Constant *InitVal = GV->getInitializer(); 18267b550ccfc5a3346c17e0390a59e2d6d19bc52705Chris Lattner assert(InitVal->getType() != Type::getInt1Ty(GV->getContext()) && 18271d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson "No reason to shrink to bool!"); 182896a86b2993c03be1de934b2c4e10ed08dbacfe0aChris Lattner 182996a86b2993c03be1de934b2c4e10ed08dbacfe0aChris Lattner // If initialized to zero and storing one into the global, we can use a cast 183096a86b2993c03be1de934b2c4e10ed08dbacfe0aChris Lattner // instead of a select to synthesize the desired value. 183196a86b2993c03be1de934b2c4e10ed08dbacfe0aChris Lattner bool IsOneZero = false; 183296a86b2993c03be1de934b2c4e10ed08dbacfe0aChris Lattner if (ConstantInt *CI = dyn_cast<ConstantInt>(OtherVal)) 1833cae5754619433aed7be74abbf1c0551a82d369cbReid Spencer IsOneZero = InitVal->isNullValue() && CI->isOne(); 183496a86b2993c03be1de934b2c4e10ed08dbacfe0aChris Lattner 183596a86b2993c03be1de934b2c4e10ed08dbacfe0aChris Lattner while (!GV->use_empty()) { 1836771281f1806ba3299fb515f59bd2f726a6a7a77eDevang Patel Instruction *UI = cast<Instruction>(GV->use_back()); 1837771281f1806ba3299fb515f59bd2f726a6a7a77eDevang Patel if (StoreInst *SI = dyn_cast<StoreInst>(UI)) { 183896a86b2993c03be1de934b2c4e10ed08dbacfe0aChris Lattner // Change the store into a boolean store. 183996a86b2993c03be1de934b2c4e10ed08dbacfe0aChris Lattner bool StoringOther = SI->getOperand(0) == OtherVal; 184096a86b2993c03be1de934b2c4e10ed08dbacfe0aChris Lattner // Only do this if we weren't storing a loaded value. 184138c2556d0c02f7aca08732225ae1c97975f55aa0Chris Lattner Value *StoreVal; 184296a86b2993c03be1de934b2c4e10ed08dbacfe0aChris Lattner if (StoringOther || SI->getOperand(0) == InitVal) 18437b550ccfc5a3346c17e0390a59e2d6d19bc52705Chris Lattner StoreVal = ConstantInt::get(Type::getInt1Ty(GV->getContext()), 18447b550ccfc5a3346c17e0390a59e2d6d19bc52705Chris Lattner StoringOther); 184538c2556d0c02f7aca08732225ae1c97975f55aa0Chris Lattner else { 184638c2556d0c02f7aca08732225ae1c97975f55aa0Chris Lattner // Otherwise, we are storing a previously loaded copy. To do this, 184738c2556d0c02f7aca08732225ae1c97975f55aa0Chris Lattner // change the copy from copying the original value to just copying the 184838c2556d0c02f7aca08732225ae1c97975f55aa0Chris Lattner // bool. 184938c2556d0c02f7aca08732225ae1c97975f55aa0Chris Lattner Instruction *StoredVal = cast<Instruction>(SI->getOperand(0)); 185038c2556d0c02f7aca08732225ae1c97975f55aa0Chris Lattner 18519e4f243de7c0a41ae02c93f7209ad97935e9853dGabor Greif // If we've already replaced the input, StoredVal will be a cast or 185238c2556d0c02f7aca08732225ae1c97975f55aa0Chris Lattner // select instruction. If not, it will be a load of the original 185338c2556d0c02f7aca08732225ae1c97975f55aa0Chris Lattner // global. 185438c2556d0c02f7aca08732225ae1c97975f55aa0Chris Lattner if (LoadInst *LI = dyn_cast<LoadInst>(StoredVal)) { 185538c2556d0c02f7aca08732225ae1c97975f55aa0Chris Lattner assert(LI->getOperand(0) == GV && "Not a copy!"); 185638c2556d0c02f7aca08732225ae1c97975f55aa0Chris Lattner // Insert a new load, to preserve the saved value. 1857fad4d40f3792b0d9e101c40738e1f691131007d2Nick Lewycky StoreVal = new LoadInst(NewGV, LI->getName()+".b", false, 0, 1858fad4d40f3792b0d9e101c40738e1f691131007d2Nick Lewycky LI->getOrdering(), LI->getSynchScope(), LI); 185938c2556d0c02f7aca08732225ae1c97975f55aa0Chris Lattner } else { 186038c2556d0c02f7aca08732225ae1c97975f55aa0Chris Lattner assert((isa<CastInst>(StoredVal) || isa<SelectInst>(StoredVal)) && 186138c2556d0c02f7aca08732225ae1c97975f55aa0Chris Lattner "This is not a form that we understand!"); 186238c2556d0c02f7aca08732225ae1c97975f55aa0Chris Lattner StoreVal = StoredVal->getOperand(0); 186338c2556d0c02f7aca08732225ae1c97975f55aa0Chris Lattner assert(isa<LoadInst>(StoreVal) && "Not a load of NewGV!"); 186438c2556d0c02f7aca08732225ae1c97975f55aa0Chris Lattner } 186538c2556d0c02f7aca08732225ae1c97975f55aa0Chris Lattner } 1866fad4d40f3792b0d9e101c40738e1f691131007d2Nick Lewycky new StoreInst(StoreVal, NewGV, false, 0, 1867fad4d40f3792b0d9e101c40738e1f691131007d2Nick Lewycky SI->getOrdering(), SI->getSynchScope(), SI); 1868771281f1806ba3299fb515f59bd2f726a6a7a77eDevang Patel } else { 186996a86b2993c03be1de934b2c4e10ed08dbacfe0aChris Lattner // Change the load into a load of bool then a select. 1870771281f1806ba3299fb515f59bd2f726a6a7a77eDevang Patel LoadInst *LI = cast<LoadInst>(UI); 1871fad4d40f3792b0d9e101c40738e1f691131007d2Nick Lewycky LoadInst *NLI = new LoadInst(NewGV, LI->getName()+".b", false, 0, 1872fad4d40f3792b0d9e101c40738e1f691131007d2Nick Lewycky LI->getOrdering(), LI->getSynchScope(), LI); 187396a86b2993c03be1de934b2c4e10ed08dbacfe0aChris Lattner Value *NSI; 187496a86b2993c03be1de934b2c4e10ed08dbacfe0aChris Lattner if (IsOneZero) 1875046800a7125cd497613efc0e1ea15cb595666585Chris Lattner NSI = new ZExtInst(NLI, LI->getType(), "", LI); 1876fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman else 1877051a950000e21935165db56695e35bade668193bGabor Greif NSI = SelectInst::Create(NLI, OtherVal, InitVal, "", LI); 1878046800a7125cd497613efc0e1ea15cb595666585Chris Lattner NSI->takeName(LI); 187996a86b2993c03be1de934b2c4e10ed08dbacfe0aChris Lattner LI->replaceAllUsesWith(NSI); 1880771281f1806ba3299fb515f59bd2f726a6a7a77eDevang Patel } 1881771281f1806ba3299fb515f59bd2f726a6a7a77eDevang Patel UI->eraseFromParent(); 188296a86b2993c03be1de934b2c4e10ed08dbacfe0aChris Lattner } 188396a86b2993c03be1de934b2c4e10ed08dbacfe0aChris Lattner 188496a86b2993c03be1de934b2c4e10ed08dbacfe0aChris Lattner GV->eraseFromParent(); 188558e44f49ddd16825fbacc60d6146376ca17f47ebChris Lattner return true; 188696a86b2993c03be1de934b2c4e10ed08dbacfe0aChris Lattner} 188796a86b2993c03be1de934b2c4e10ed08dbacfe0aChris Lattner 188896a86b2993c03be1de934b2c4e10ed08dbacfe0aChris Lattner 1889db292a6f7ffe410913255f65e195004327e2e0ceNick Lewycky/// ProcessGlobal - Analyze the specified global variable and optimize it if 1890db292a6f7ffe410913255f65e195004327e2e0ceNick Lewycky/// possible. If we make a change, return true. 1891c4440e3e307fb696146c08c127c53300a982fe82Rafael Espindolabool GlobalOpt::ProcessGlobal(GlobalVariable *GV, 1892c4440e3e307fb696146c08c127c53300a982fe82Rafael Espindola Module::global_iterator &GVI) { 18930397729d3b8da4208660a163d18296b1a3bd32b8Rafael Espindola if (!GV->isDiscardableIfUnused()) 1894c4440e3e307fb696146c08c127c53300a982fe82Rafael Espindola return false; 1895c4440e3e307fb696146c08c127c53300a982fe82Rafael Espindola 1896c4440e3e307fb696146c08c127c53300a982fe82Rafael Espindola // Do more involved optimizations if the global is internal. 1897a4be1dc0a192175bbc561a633c0b7197853e6a74Chris Lattner GV->removeDeadConstantUsers(); 1898a4be1dc0a192175bbc561a633c0b7197853e6a74Chris Lattner 1899a4be1dc0a192175bbc561a633c0b7197853e6a74Chris Lattner if (GV->use_empty()) { 19003215b0ee8248ca1e4bc2c7e2f5fd3ce120c3ee45David Greene DEBUG(dbgs() << "GLOBAL DEAD: " << *GV); 19017a7ed0274d01efb2e12a32fd5fee6aa9596b0b9aChris Lattner GV->eraseFromParent(); 1902a4be1dc0a192175bbc561a633c0b7197853e6a74Chris Lattner ++NumDeleted; 1903a4be1dc0a192175bbc561a633c0b7197853e6a74Chris Lattner return true; 1904a4be1dc0a192175bbc561a633c0b7197853e6a74Chris Lattner } 1905a4be1dc0a192175bbc561a633c0b7197853e6a74Chris Lattner 19062f135d4c14d26d00deaa72fd0f36731968161e5eRafael Espindola if (!GV->hasLocalLinkage()) 19072f135d4c14d26d00deaa72fd0f36731968161e5eRafael Espindola return false; 19082f135d4c14d26d00deaa72fd0f36731968161e5eRafael Espindola 1909c4440e3e307fb696146c08c127c53300a982fe82Rafael Espindola SmallPtrSet<const PHINode*, 16> PHIUsers; 1910c4440e3e307fb696146c08c127c53300a982fe82Rafael Espindola GlobalStatus GS; 1911c4440e3e307fb696146c08c127c53300a982fe82Rafael Espindola 1912daad56a8e3ac99c517d766130ac4ac03b578d180Rafael Espindola if (AnalyzeGlobal(GV, GS, PHIUsers)) 1913daad56a8e3ac99c517d766130ac4ac03b578d180Rafael Espindola return false; 19149d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 1915c4440e3e307fb696146c08c127c53300a982fe82Rafael Espindola if (!GS.isCompared && !GV->hasUnnamedAddr()) { 1916c4440e3e307fb696146c08c127c53300a982fe82Rafael Espindola GV->setUnnamedAddr(true); 1917c4440e3e307fb696146c08c127c53300a982fe82Rafael Espindola NumUnnamed++; 1918c4440e3e307fb696146c08c127c53300a982fe82Rafael Espindola } 1919c4440e3e307fb696146c08c127c53300a982fe82Rafael Espindola 1920c4440e3e307fb696146c08c127c53300a982fe82Rafael Espindola if (GV->isConstant() || !GV->hasInitializer()) 1921c4440e3e307fb696146c08c127c53300a982fe82Rafael Espindola return false; 1922c4440e3e307fb696146c08c127c53300a982fe82Rafael Espindola 1923c4440e3e307fb696146c08c127c53300a982fe82Rafael Espindola return ProcessInternalGlobal(GV, GVI, PHIUsers, GS); 1924c4440e3e307fb696146c08c127c53300a982fe82Rafael Espindola} 1925c4440e3e307fb696146c08c127c53300a982fe82Rafael Espindola 1926c4440e3e307fb696146c08c127c53300a982fe82Rafael Espindola/// ProcessInternalGlobal - Analyze the specified global variable and optimize 1927c4440e3e307fb696146c08c127c53300a982fe82Rafael Espindola/// it if possible. If we make a change, return true. 1928c4440e3e307fb696146c08c127c53300a982fe82Rafael Espindolabool GlobalOpt::ProcessInternalGlobal(GlobalVariable *GV, 1929c4440e3e307fb696146c08c127c53300a982fe82Rafael Espindola Module::global_iterator &GVI, 1930db292a6f7ffe410913255f65e195004327e2e0ceNick Lewycky const SmallPtrSet<const PHINode*, 16> &PHIUsers, 1931c4440e3e307fb696146c08c127c53300a982fe82Rafael Espindola const GlobalStatus &GS) { 1932daad56a8e3ac99c517d766130ac4ac03b578d180Rafael Espindola // If this is a first class global and has only one accessing function 1933daad56a8e3ac99c517d766130ac4ac03b578d180Rafael Espindola // and this function is main (which we know is not recursive we can make 1934daad56a8e3ac99c517d766130ac4ac03b578d180Rafael Espindola // this global a local variable) we replace the global with a local alloca 1935daad56a8e3ac99c517d766130ac4ac03b578d180Rafael Espindola // in this function. 1936daad56a8e3ac99c517d766130ac4ac03b578d180Rafael Espindola // 1937daad56a8e3ac99c517d766130ac4ac03b578d180Rafael Espindola // NOTE: It doesn't make sense to promote non single-value types since we 1938daad56a8e3ac99c517d766130ac4ac03b578d180Rafael Espindola // are just replacing static memory to stack memory. 1939daad56a8e3ac99c517d766130ac4ac03b578d180Rafael Espindola // 1940daad56a8e3ac99c517d766130ac4ac03b578d180Rafael Espindola // If the global is in different address space, don't bring it to stack. 1941daad56a8e3ac99c517d766130ac4ac03b578d180Rafael Espindola if (!GS.HasMultipleAccessingFunctions && 1942daad56a8e3ac99c517d766130ac4ac03b578d180Rafael Espindola GS.AccessingFunction && !GS.HasNonInstructionUser && 1943daad56a8e3ac99c517d766130ac4ac03b578d180Rafael Espindola GV->getType()->getElementType()->isSingleValueType() && 1944daad56a8e3ac99c517d766130ac4ac03b578d180Rafael Espindola GS.AccessingFunction->getName() == "main" && 1945daad56a8e3ac99c517d766130ac4ac03b578d180Rafael Espindola GS.AccessingFunction->hasExternalLinkage() && 1946daad56a8e3ac99c517d766130ac4ac03b578d180Rafael Espindola GV->getType()->getAddressSpace() == 0) { 1947daad56a8e3ac99c517d766130ac4ac03b578d180Rafael Espindola DEBUG(dbgs() << "LOCALIZING GLOBAL: " << *GV); 1948bc384a1feb08141691ef994a7d11a506e89c5a62Nick Lewycky Instruction &FirstI = const_cast<Instruction&>(*GS.AccessingFunction 1949daad56a8e3ac99c517d766130ac4ac03b578d180Rafael Espindola ->getEntryBlock().begin()); 1950bc384a1feb08141691ef994a7d11a506e89c5a62Nick Lewycky Type *ElemTy = GV->getType()->getElementType(); 1951daad56a8e3ac99c517d766130ac4ac03b578d180Rafael Espindola // FIXME: Pass Global's alignment when globals have alignment 1952bc384a1feb08141691ef994a7d11a506e89c5a62Nick Lewycky AllocaInst *Alloca = new AllocaInst(ElemTy, NULL, GV->getName(), &FirstI); 1953daad56a8e3ac99c517d766130ac4ac03b578d180Rafael Espindola if (!isa<UndefValue>(GV->getInitializer())) 1954daad56a8e3ac99c517d766130ac4ac03b578d180Rafael Espindola new StoreInst(GV->getInitializer(), Alloca, &FirstI); 1955daad56a8e3ac99c517d766130ac4ac03b578d180Rafael Espindola 1956daad56a8e3ac99c517d766130ac4ac03b578d180Rafael Espindola GV->replaceAllUsesWith(Alloca); 1957daad56a8e3ac99c517d766130ac4ac03b578d180Rafael Espindola GV->eraseFromParent(); 1958daad56a8e3ac99c517d766130ac4ac03b578d180Rafael Espindola ++NumLocalized; 1959daad56a8e3ac99c517d766130ac4ac03b578d180Rafael Espindola return true; 1960daad56a8e3ac99c517d766130ac4ac03b578d180Rafael Espindola } 1961930f475604bcd8835197df0dac0c63235f8f1bb3Chris Lattner 1962daad56a8e3ac99c517d766130ac4ac03b578d180Rafael Espindola // If the global is never loaded (but may be stored to), it is dead. 1963daad56a8e3ac99c517d766130ac4ac03b578d180Rafael Espindola // Delete it now. 1964daad56a8e3ac99c517d766130ac4ac03b578d180Rafael Espindola if (!GS.isLoaded) { 1965daad56a8e3ac99c517d766130ac4ac03b578d180Rafael Espindola DEBUG(dbgs() << "GLOBAL NEVER LOADED: " << *GV); 1966930f475604bcd8835197df0dac0c63235f8f1bb3Chris Lattner 19678899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky bool Changed; 19688899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky if (isLeakCheckerRoot(GV)) { 19698899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky // Delete any constant stores to the global. 19708e0d1c03ca7fd86e6879b4e37d0d7f0e982feef6Benjamin Kramer Changed = CleanupPointerRootUsers(GV, TLI); 19718899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky } else { 19728899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky // Delete any stores we can find to the global. We may not be able to 19738899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky // make it completely dead though. 19748899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky Changed = CleanupConstantGlobalUsers(GV, GV->getInitializer(), TD, TLI); 19758899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky } 1976daad56a8e3ac99c517d766130ac4ac03b578d180Rafael Espindola 1977daad56a8e3ac99c517d766130ac4ac03b578d180Rafael Espindola // If the global is dead now, delete it. 1978daad56a8e3ac99c517d766130ac4ac03b578d180Rafael Espindola if (GV->use_empty()) { 1979daad56a8e3ac99c517d766130ac4ac03b578d180Rafael Espindola GV->eraseFromParent(); 1980daad56a8e3ac99c517d766130ac4ac03b578d180Rafael Espindola ++NumDeleted; 1981daad56a8e3ac99c517d766130ac4ac03b578d180Rafael Espindola Changed = true; 1982daad56a8e3ac99c517d766130ac4ac03b578d180Rafael Espindola } 1983daad56a8e3ac99c517d766130ac4ac03b578d180Rafael Espindola return Changed; 1984daad56a8e3ac99c517d766130ac4ac03b578d180Rafael Espindola 1985daad56a8e3ac99c517d766130ac4ac03b578d180Rafael Espindola } else if (GS.StoredType <= GlobalStatus::isInitializerStored) { 1986daad56a8e3ac99c517d766130ac4ac03b578d180Rafael Espindola DEBUG(dbgs() << "MARKING CONSTANT: " << *GV); 1987daad56a8e3ac99c517d766130ac4ac03b578d180Rafael Espindola GV->setConstant(true); 1988fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman 1989daad56a8e3ac99c517d766130ac4ac03b578d180Rafael Espindola // Clean up any obviously simplifiable users now. 19906a577f82ba56a4da48e984702240a01c3ba7e941Nick Lewycky CleanupConstantGlobalUsers(GV, GV->getInitializer(), TD, TLI); 1991fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman 1992daad56a8e3ac99c517d766130ac4ac03b578d180Rafael Espindola // If the global is dead now, just nuke it. 1993daad56a8e3ac99c517d766130ac4ac03b578d180Rafael Espindola if (GV->use_empty()) { 1994daad56a8e3ac99c517d766130ac4ac03b578d180Rafael Espindola DEBUG(dbgs() << " *** Marking constant allowed us to simplify " 1995daad56a8e3ac99c517d766130ac4ac03b578d180Rafael Espindola << "all users and delete global!\n"); 1996daad56a8e3ac99c517d766130ac4ac03b578d180Rafael Espindola GV->eraseFromParent(); 1997daad56a8e3ac99c517d766130ac4ac03b578d180Rafael Espindola ++NumDeleted; 1998daad56a8e3ac99c517d766130ac4ac03b578d180Rafael Espindola } 1999fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman 2000daad56a8e3ac99c517d766130ac4ac03b578d180Rafael Espindola ++NumMarked; 2001daad56a8e3ac99c517d766130ac4ac03b578d180Rafael Espindola return true; 2002daad56a8e3ac99c517d766130ac4ac03b578d180Rafael Espindola } else if (!GV->getInitializer()->getType()->isSingleValueType()) { 2003daad56a8e3ac99c517d766130ac4ac03b578d180Rafael Espindola if (TargetData *TD = getAnalysisIfAvailable<TargetData>()) 2004daad56a8e3ac99c517d766130ac4ac03b578d180Rafael Espindola if (GlobalVariable *FirstNewGV = SRAGlobal(GV, *TD)) { 2005daad56a8e3ac99c517d766130ac4ac03b578d180Rafael Espindola GVI = FirstNewGV; // Don't skip the newly produced globals! 2006daad56a8e3ac99c517d766130ac4ac03b578d180Rafael Espindola return true; 2007daad56a8e3ac99c517d766130ac4ac03b578d180Rafael Espindola } 2008daad56a8e3ac99c517d766130ac4ac03b578d180Rafael Espindola } else if (GS.StoredType == GlobalStatus::isStoredOnce) { 2009daad56a8e3ac99c517d766130ac4ac03b578d180Rafael Espindola // If the initial value for the global was an undef value, and if only 2010daad56a8e3ac99c517d766130ac4ac03b578d180Rafael Espindola // one other value was stored into it, we can just change the 2011daad56a8e3ac99c517d766130ac4ac03b578d180Rafael Espindola // initializer to be the stored value, then delete all stores to the 2012daad56a8e3ac99c517d766130ac4ac03b578d180Rafael Espindola // global. This allows us to mark it constant. 2013daad56a8e3ac99c517d766130ac4ac03b578d180Rafael Espindola if (Constant *SOVConstant = dyn_cast<Constant>(GS.StoredOnceValue)) 2014daad56a8e3ac99c517d766130ac4ac03b578d180Rafael Espindola if (isa<UndefValue>(GV->getInitializer())) { 2015daad56a8e3ac99c517d766130ac4ac03b578d180Rafael Espindola // Change the initial value here. 2016daad56a8e3ac99c517d766130ac4ac03b578d180Rafael Espindola GV->setInitializer(SOVConstant); 2017daad56a8e3ac99c517d766130ac4ac03b578d180Rafael Espindola 2018daad56a8e3ac99c517d766130ac4ac03b578d180Rafael Espindola // Clean up any obviously simplifiable users now. 20196a577f82ba56a4da48e984702240a01c3ba7e941Nick Lewycky CleanupConstantGlobalUsers(GV, GV->getInitializer(), TD, TLI); 2020daad56a8e3ac99c517d766130ac4ac03b578d180Rafael Espindola 2021daad56a8e3ac99c517d766130ac4ac03b578d180Rafael Espindola if (GV->use_empty()) { 2022daad56a8e3ac99c517d766130ac4ac03b578d180Rafael Espindola DEBUG(dbgs() << " *** Substituting initializer allowed us to " 20238899d5c6fb3cf118c5c73eade290b6ebb2b3b850Nick Lewycky << "simplify all users and delete global!\n"); 2024daad56a8e3ac99c517d766130ac4ac03b578d180Rafael Espindola GV->eraseFromParent(); 2025daad56a8e3ac99c517d766130ac4ac03b578d180Rafael Espindola ++NumDeleted; 2026daad56a8e3ac99c517d766130ac4ac03b578d180Rafael Espindola } else { 2027daad56a8e3ac99c517d766130ac4ac03b578d180Rafael Espindola GVI = GV; 2028daad56a8e3ac99c517d766130ac4ac03b578d180Rafael Espindola } 2029daad56a8e3ac99c517d766130ac4ac03b578d180Rafael Espindola ++NumSubstitute; 2030daad56a8e3ac99c517d766130ac4ac03b578d180Rafael Espindola return true; 2031a4be1dc0a192175bbc561a633c0b7197853e6a74Chris Lattner } 2032fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman 2033daad56a8e3ac99c517d766130ac4ac03b578d180Rafael Espindola // Try to optimize globals based on the knowledge that only one value 2034daad56a8e3ac99c517d766130ac4ac03b578d180Rafael Espindola // (besides its initializer) is ever stored to the global. 2035fad4d40f3792b0d9e101c40738e1f691131007d2Nick Lewycky if (OptimizeOnceStoredGlobal(GV, GS.StoredOnceValue, GS.Ordering, GVI, 20366a577f82ba56a4da48e984702240a01c3ba7e941Nick Lewycky TD, TLI)) 2037a4be1dc0a192175bbc561a633c0b7197853e6a74Chris Lattner return true; 20387a7ed0274d01efb2e12a32fd5fee6aa9596b0b9aChris Lattner 2039daad56a8e3ac99c517d766130ac4ac03b578d180Rafael Espindola // Otherwise, if the global was not a boolean, we can shrink it to be a 2040daad56a8e3ac99c517d766130ac4ac03b578d180Rafael Espindola // boolean. 2041daad56a8e3ac99c517d766130ac4ac03b578d180Rafael Espindola if (Constant *SOVConstant = dyn_cast<Constant>(GS.StoredOnceValue)) 2042daad56a8e3ac99c517d766130ac4ac03b578d180Rafael Espindola if (TryToShrinkGlobalToBoolean(GV, SOVConstant)) { 2043daad56a8e3ac99c517d766130ac4ac03b578d180Rafael Espindola ++NumShrunkToBool; 20449b34a6101908c36df659fe0b188713c949a32304Chris Lattner return true; 2045daad56a8e3ac99c517d766130ac4ac03b578d180Rafael Espindola } 2046a4be1dc0a192175bbc561a633c0b7197853e6a74Chris Lattner } 2047daad56a8e3ac99c517d766130ac4ac03b578d180Rafael Espindola 2048a4be1dc0a192175bbc561a633c0b7197853e6a74Chris Lattner return false; 2049a4be1dc0a192175bbc561a633c0b7197853e6a74Chris Lattner} 2050a4be1dc0a192175bbc561a633c0b7197853e6a74Chris Lattner 2051fb217adf92cbfd045614a652be63c710ce6a263dChris Lattner/// ChangeCalleesToFastCall - Walk all of the direct calls of the specified 2052fb217adf92cbfd045614a652be63c710ce6a263dChris Lattner/// function, changing them to FastCC. 2053fb217adf92cbfd045614a652be63c710ce6a263dChris Lattnerstatic void ChangeCalleesToFastCall(Function *F) { 2054fb217adf92cbfd045614a652be63c710ce6a263dChris Lattner for (Value::use_iterator UI = F->use_begin(), E = F->use_end(); UI != E;++UI){ 2055b7454fd9df0b477e3daf2fce6e1d5e1b241562dfJay Foad if (isa<BlockAddress>(*UI)) 2056b7454fd9df0b477e3daf2fce6e1d5e1b241562dfJay Foad continue; 2057548448a317b39ec8446f3c82f44d01f938b921b2Duncan Sands CallSite User(cast<Instruction>(*UI)); 2058548448a317b39ec8446f3c82f44d01f938b921b2Duncan Sands User.setCallingConv(CallingConv::Fast); 2059fb217adf92cbfd045614a652be63c710ce6a263dChris Lattner } 2060fb217adf92cbfd045614a652be63c710ce6a263dChris Lattner} 2061a4be1dc0a192175bbc561a633c0b7197853e6a74Chris Lattner 20620598866c052147c31b808391f58434ce3dbfb838Devang Patelstatic AttrListPtr StripNest(const AttrListPtr &Attrs) { 206358d74910c6b82e622ecbb57d6644d48fec5a5c0fChris Lattner for (unsigned i = 0, e = Attrs.getNumSlots(); i != e; ++i) { 20640598866c052147c31b808391f58434ce3dbfb838Devang Patel if ((Attrs.getSlot(i).Attrs & Attribute::Nest) == 0) 2065548448a317b39ec8446f3c82f44d01f938b921b2Duncan Sands continue; 2066548448a317b39ec8446f3c82f44d01f938b921b2Duncan Sands 2067548448a317b39ec8446f3c82f44d01f938b921b2Duncan Sands // There can be only one. 20680598866c052147c31b808391f58434ce3dbfb838Devang Patel return Attrs.removeAttr(Attrs.getSlot(i).Index, Attribute::Nest); 20693d5378ff8e015e6ede4fd3d33c3e05a1dfec5b99Duncan Sands } 20703d5378ff8e015e6ede4fd3d33c3e05a1dfec5b99Duncan Sands 20713d5378ff8e015e6ede4fd3d33c3e05a1dfec5b99Duncan Sands return Attrs; 20723d5378ff8e015e6ede4fd3d33c3e05a1dfec5b99Duncan Sands} 20733d5378ff8e015e6ede4fd3d33c3e05a1dfec5b99Duncan Sands 20743d5378ff8e015e6ede4fd3d33c3e05a1dfec5b99Duncan Sandsstatic void RemoveNestAttribute(Function *F) { 20750598866c052147c31b808391f58434ce3dbfb838Devang Patel F->setAttributes(StripNest(F->getAttributes())); 20763d5378ff8e015e6ede4fd3d33c3e05a1dfec5b99Duncan Sands for (Value::use_iterator UI = F->use_begin(), E = F->use_end(); UI != E;++UI){ 2077b7454fd9df0b477e3daf2fce6e1d5e1b241562dfJay Foad if (isa<BlockAddress>(*UI)) 2078b7454fd9df0b477e3daf2fce6e1d5e1b241562dfJay Foad continue; 2079548448a317b39ec8446f3c82f44d01f938b921b2Duncan Sands CallSite User(cast<Instruction>(*UI)); 20800598866c052147c31b808391f58434ce3dbfb838Devang Patel User.setAttributes(StripNest(User.getAttributes())); 20813d5378ff8e015e6ede4fd3d33c3e05a1dfec5b99Duncan Sands } 20823d5378ff8e015e6ede4fd3d33c3e05a1dfec5b99Duncan Sands} 20833d5378ff8e015e6ede4fd3d33c3e05a1dfec5b99Duncan Sands 2084b1ab4580478c90375abec5e2b6e89dc1a15fa98bChris Lattnerbool GlobalOpt::OptimizeFunctions(Module &M) { 2085079236d1c9909365ffd0ef06831523c87335bb4aChris Lattner bool Changed = false; 2086b1ab4580478c90375abec5e2b6e89dc1a15fa98bChris Lattner // Optimize functions. 2087b1ab4580478c90375abec5e2b6e89dc1a15fa98bChris Lattner for (Module::iterator FI = M.begin(), E = M.end(); FI != E; ) { 2088b1ab4580478c90375abec5e2b6e89dc1a15fa98bChris Lattner Function *F = FI++; 2089fc5940d2a09a795e683ae86b237d6f55fb3551d4Duncan Sands // Functions without names cannot be referenced outside this module. 2090fc5940d2a09a795e683ae86b237d6f55fb3551d4Duncan Sands if (!F->hasName() && !F->isDeclaration()) 2091fc5940d2a09a795e683ae86b237d6f55fb3551d4Duncan Sands F->setLinkage(GlobalValue::InternalLinkage); 2092b1ab4580478c90375abec5e2b6e89dc1a15fa98bChris Lattner F->removeDeadConstantUsers(); 2093c66330504c3f433430a28cd7f7f981e555c51bceEli Friedman if (F->isDefTriviallyDead()) { 2094ec4c7b976645cc49ccfe8dc1c3bfc31ec5fedc62Chris Lattner F->eraseFromParent(); 2095b1ab4580478c90375abec5e2b6e89dc1a15fa98bChris Lattner Changed = true; 2096b1ab4580478c90375abec5e2b6e89dc1a15fa98bChris Lattner ++NumFnDeleted; 2097bb46f52027416598a662dc1c58f48d9d56b1a65bRafael Espindola } else if (F->hasLocalLinkage()) { 20983d5378ff8e015e6ede4fd3d33c3e05a1dfec5b99Duncan Sands if (F->getCallingConv() == CallingConv::C && !F->isVarArg() && 2099757068f3bad425fb126fe16ab7b8a82a636e6bbdJay Foad !F->hasAddressTaken()) { 21003d5378ff8e015e6ede4fd3d33c3e05a1dfec5b99Duncan Sands // If this function has C calling conventions, is not a varargs 21013d5378ff8e015e6ede4fd3d33c3e05a1dfec5b99Duncan Sands // function, and is only called directly, promote it to use the Fast 21023d5378ff8e015e6ede4fd3d33c3e05a1dfec5b99Duncan Sands // calling convention. 21033d5378ff8e015e6ede4fd3d33c3e05a1dfec5b99Duncan Sands F->setCallingConv(CallingConv::Fast); 21043d5378ff8e015e6ede4fd3d33c3e05a1dfec5b99Duncan Sands ChangeCalleesToFastCall(F); 21053d5378ff8e015e6ede4fd3d33c3e05a1dfec5b99Duncan Sands ++NumFastCallFns; 21063d5378ff8e015e6ede4fd3d33c3e05a1dfec5b99Duncan Sands Changed = true; 21073d5378ff8e015e6ede4fd3d33c3e05a1dfec5b99Duncan Sands } 21083d5378ff8e015e6ede4fd3d33c3e05a1dfec5b99Duncan Sands 21090598866c052147c31b808391f58434ce3dbfb838Devang Patel if (F->getAttributes().hasAttrSomewhere(Attribute::Nest) && 2110757068f3bad425fb126fe16ab7b8a82a636e6bbdJay Foad !F->hasAddressTaken()) { 21113d5378ff8e015e6ede4fd3d33c3e05a1dfec5b99Duncan Sands // The function is not used by a trampoline intrinsic, so it is safe 21123d5378ff8e015e6ede4fd3d33c3e05a1dfec5b99Duncan Sands // to remove the 'nest' attribute. 21133d5378ff8e015e6ede4fd3d33c3e05a1dfec5b99Duncan Sands RemoveNestAttribute(F); 21143d5378ff8e015e6ede4fd3d33c3e05a1dfec5b99Duncan Sands ++NumNestRemoved; 21153d5378ff8e015e6ede4fd3d33c3e05a1dfec5b99Duncan Sands Changed = true; 21163d5378ff8e015e6ede4fd3d33c3e05a1dfec5b99Duncan Sands } 2117b1ab4580478c90375abec5e2b6e89dc1a15fa98bChris Lattner } 2118b1ab4580478c90375abec5e2b6e89dc1a15fa98bChris Lattner } 2119b1ab4580478c90375abec5e2b6e89dc1a15fa98bChris Lattner return Changed; 2120b1ab4580478c90375abec5e2b6e89dc1a15fa98bChris Lattner} 21217a90b68e5c85fe11a4ccc386be9c5fcddd4a8b61Chris Lattner 2122b1ab4580478c90375abec5e2b6e89dc1a15fa98bChris Lattnerbool GlobalOpt::OptimizeGlobalVars(Module &M) { 2123b1ab4580478c90375abec5e2b6e89dc1a15fa98bChris Lattner bool Changed = false; 2124b1ab4580478c90375abec5e2b6e89dc1a15fa98bChris Lattner for (Module::global_iterator GVI = M.global_begin(), E = M.global_end(); 2125b1ab4580478c90375abec5e2b6e89dc1a15fa98bChris Lattner GVI != E; ) { 2126b1ab4580478c90375abec5e2b6e89dc1a15fa98bChris Lattner GlobalVariable *GV = GVI++; 2127fc5940d2a09a795e683ae86b237d6f55fb3551d4Duncan Sands // Global variables without names cannot be referenced outside this module. 2128fc5940d2a09a795e683ae86b237d6f55fb3551d4Duncan Sands if (!GV->hasName() && !GV->isDeclaration()) 2129fc5940d2a09a795e683ae86b237d6f55fb3551d4Duncan Sands GV->setLinkage(GlobalValue::InternalLinkage); 213001b97dd01eec1197d79fceb7229f5ec233994de3Dan Gohman // Simplify the initializer. 213101b97dd01eec1197d79fceb7229f5ec233994de3Dan Gohman if (GV->hasInitializer()) 213201b97dd01eec1197d79fceb7229f5ec233994de3Dan Gohman if (ConstantExpr *CE = dyn_cast<ConstantExpr>(GV->getInitializer())) { 2133aab8e28d5e470711d80276bbf717408c3ab966fdChad Rosier Constant *New = ConstantFoldConstantExpression(CE, TD, TLI); 213401b97dd01eec1197d79fceb7229f5ec233994de3Dan Gohman if (New && New != CE) 213501b97dd01eec1197d79fceb7229f5ec233994de3Dan Gohman GV->setInitializer(New); 213601b97dd01eec1197d79fceb7229f5ec233994de3Dan Gohman } 2137c4440e3e307fb696146c08c127c53300a982fe82Rafael Espindola 2138c4440e3e307fb696146c08c127c53300a982fe82Rafael Espindola Changed |= ProcessGlobal(GV, GVI); 2139b1ab4580478c90375abec5e2b6e89dc1a15fa98bChris Lattner } 2140b1ab4580478c90375abec5e2b6e89dc1a15fa98bChris Lattner return Changed; 2141b1ab4580478c90375abec5e2b6e89dc1a15fa98bChris Lattner} 2142b1ab4580478c90375abec5e2b6e89dc1a15fa98bChris Lattner 21432c44a80d991df258a45e2f5fa76d5ada9e99015cNick Lewycky/// FindGlobalCtors - Find the llvm.global_ctors list, verifying that all 2144b1ab4580478c90375abec5e2b6e89dc1a15fa98bChris Lattner/// initializers have an init priority of 65535. 2145b1ab4580478c90375abec5e2b6e89dc1a15fa98bChris LattnerGlobalVariable *GlobalOpt::FindGlobalCtors(Module &M) { 2146f51a6cc5bf123d5d71bc846767b34701c4dc6014Chris Lattner GlobalVariable *GV = M.getGlobalVariable("llvm.global_ctors"); 2147f51a6cc5bf123d5d71bc846767b34701c4dc6014Chris Lattner if (GV == 0) return 0; 2148f51a6cc5bf123d5d71bc846767b34701c4dc6014Chris Lattner 2149f51a6cc5bf123d5d71bc846767b34701c4dc6014Chris Lattner // Verify that the initializer is simple enough for us to handle. We are 2150f51a6cc5bf123d5d71bc846767b34701c4dc6014Chris Lattner // only allowed to optimize the initializer if it is unique. 2151f51a6cc5bf123d5d71bc846767b34701c4dc6014Chris Lattner if (!GV->hasUniqueInitializer()) return 0; 215218a2e50a9bfe4ecde57dc3913a7bd98b954ec81aEli Friedman 21535ea5c61589e62a1068746ddcc52c6aa39ec0f8b0Nick Lewycky if (isa<ConstantAggregateZero>(GV->getInitializer())) 21545ea5c61589e62a1068746ddcc52c6aa39ec0f8b0Nick Lewycky return GV; 21555ea5c61589e62a1068746ddcc52c6aa39ec0f8b0Nick Lewycky ConstantArray *CA = cast<ConstantArray>(GV->getInitializer()); 215618a2e50a9bfe4ecde57dc3913a7bd98b954ec81aEli Friedman 21575ea5c61589e62a1068746ddcc52c6aa39ec0f8b0Nick Lewycky for (User::op_iterator i = CA->op_begin(), e = CA->op_end(); i != e; ++i) { 21585ea5c61589e62a1068746ddcc52c6aa39ec0f8b0Nick Lewycky if (isa<ConstantAggregateZero>(*i)) 21595ea5c61589e62a1068746ddcc52c6aa39ec0f8b0Nick Lewycky continue; 21605ea5c61589e62a1068746ddcc52c6aa39ec0f8b0Nick Lewycky ConstantStruct *CS = cast<ConstantStruct>(*i); 2161f51a6cc5bf123d5d71bc846767b34701c4dc6014Chris Lattner if (isa<ConstantPointerNull>(CS->getOperand(1))) 2162f51a6cc5bf123d5d71bc846767b34701c4dc6014Chris Lattner continue; 21639d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 2164f51a6cc5bf123d5d71bc846767b34701c4dc6014Chris Lattner // Must have a function or null ptr. 2165f51a6cc5bf123d5d71bc846767b34701c4dc6014Chris Lattner if (!isa<Function>(CS->getOperand(1))) 2166f51a6cc5bf123d5d71bc846767b34701c4dc6014Chris Lattner return 0; 21679d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 2168f51a6cc5bf123d5d71bc846767b34701c4dc6014Chris Lattner // Init priority must be standard. 21692c44a80d991df258a45e2f5fa76d5ada9e99015cNick Lewycky ConstantInt *CI = cast<ConstantInt>(CS->getOperand(0)); 21702c44a80d991df258a45e2f5fa76d5ada9e99015cNick Lewycky if (CI->getZExtValue() != 65535) 2171f51a6cc5bf123d5d71bc846767b34701c4dc6014Chris Lattner return 0; 2172f51a6cc5bf123d5d71bc846767b34701c4dc6014Chris Lattner } 2173f51a6cc5bf123d5d71bc846767b34701c4dc6014Chris Lattner 2174f51a6cc5bf123d5d71bc846767b34701c4dc6014Chris Lattner return GV; 2175b1ab4580478c90375abec5e2b6e89dc1a15fa98bChris Lattner} 2176b1ab4580478c90375abec5e2b6e89dc1a15fa98bChris Lattner 2177db973e60ced33cfa0332462b1a2d5ae1ae15ad25Chris Lattner/// ParseGlobalCtors - Given a llvm.global_ctors list that we can understand, 2178db973e60ced33cfa0332462b1a2d5ae1ae15ad25Chris Lattner/// return a list of the functions and null terminator as a vector. 2179b1ab4580478c90375abec5e2b6e89dc1a15fa98bChris Lattnerstatic std::vector<Function*> ParseGlobalCtors(GlobalVariable *GV) { 21805ea5c61589e62a1068746ddcc52c6aa39ec0f8b0Nick Lewycky if (GV->getInitializer()->isNullValue()) 21815ea5c61589e62a1068746ddcc52c6aa39ec0f8b0Nick Lewycky return std::vector<Function*>(); 2182b1ab4580478c90375abec5e2b6e89dc1a15fa98bChris Lattner ConstantArray *CA = cast<ConstantArray>(GV->getInitializer()); 2183b1ab4580478c90375abec5e2b6e89dc1a15fa98bChris Lattner std::vector<Function*> Result; 2184b1ab4580478c90375abec5e2b6e89dc1a15fa98bChris Lattner Result.reserve(CA->getNumOperands()); 21855e46321d665d6b1f445aff70d8eabb4870a6cf0eGabor Greif for (User::op_iterator i = CA->op_begin(), e = CA->op_end(); i != e; ++i) { 21865e46321d665d6b1f445aff70d8eabb4870a6cf0eGabor Greif ConstantStruct *CS = cast<ConstantStruct>(*i); 2187b1ab4580478c90375abec5e2b6e89dc1a15fa98bChris Lattner Result.push_back(dyn_cast<Function>(CS->getOperand(1))); 2188b1ab4580478c90375abec5e2b6e89dc1a15fa98bChris Lattner } 2189b1ab4580478c90375abec5e2b6e89dc1a15fa98bChris Lattner return Result; 2190b1ab4580478c90375abec5e2b6e89dc1a15fa98bChris Lattner} 2191b1ab4580478c90375abec5e2b6e89dc1a15fa98bChris Lattner 2192db973e60ced33cfa0332462b1a2d5ae1ae15ad25Chris Lattner/// InstallGlobalCtors - Given a specified llvm.global_ctors list, install the 2193db973e60ced33cfa0332462b1a2d5ae1ae15ad25Chris Lattner/// specified array, returning the new global to use. 21949d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkovstatic GlobalVariable *InstallGlobalCtors(GlobalVariable *GCL, 21957b550ccfc5a3346c17e0390a59e2d6d19bc52705Chris Lattner const std::vector<Function*> &Ctors) { 2196db973e60ced33cfa0332462b1a2d5ae1ae15ad25Chris Lattner // If we made a change, reassemble the initializer list. 2197b065b06c12dba6001b8140df2744d0c856ef6ea1Chris Lattner Constant *CSVals[2]; 2198b065b06c12dba6001b8140df2744d0c856ef6ea1Chris Lattner CSVals[0] = ConstantInt::get(Type::getInt32Ty(GCL->getContext()), 65535); 2199b065b06c12dba6001b8140df2744d0c856ef6ea1Chris Lattner CSVals[1] = 0; 2200b065b06c12dba6001b8140df2744d0c856ef6ea1Chris Lattner 2201db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner StructType *StructTy = 2202b065b06c12dba6001b8140df2744d0c856ef6ea1Chris Lattner cast <StructType>( 2203b065b06c12dba6001b8140df2744d0c856ef6ea1Chris Lattner cast<ArrayType>(GCL->getType()->getElementType())->getElementType()); 22049d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 2205b1ab4580478c90375abec5e2b6e89dc1a15fa98bChris Lattner // Create the new init list. 2206b1ab4580478c90375abec5e2b6e89dc1a15fa98bChris Lattner std::vector<Constant*> CAList; 2207b1ab4580478c90375abec5e2b6e89dc1a15fa98bChris Lattner for (unsigned i = 0, e = Ctors.size(); i != e; ++i) { 220879c1101947101ff1585a38dc69d1f1079d44bb04Chris Lattner if (Ctors[i]) { 2209b1ab4580478c90375abec5e2b6e89dc1a15fa98bChris Lattner CSVals[1] = Ctors[i]; 221079c1101947101ff1585a38dc69d1f1079d44bb04Chris Lattner } else { 2211db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *FTy = FunctionType::get(Type::getVoidTy(GCL->getContext()), 22127b550ccfc5a3346c17e0390a59e2d6d19bc52705Chris Lattner false); 2213db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner PointerType *PFTy = PointerType::getUnqual(FTy); 2214a7235ea7245028a0723e8ab7fd011386b3900777Owen Anderson CSVals[1] = Constant::getNullValue(PFTy); 22157b550ccfc5a3346c17e0390a59e2d6d19bc52705Chris Lattner CSVals[0] = ConstantInt::get(Type::getInt32Ty(GCL->getContext()), 22165ea5c61589e62a1068746ddcc52c6aa39ec0f8b0Nick Lewycky 0x7fffffff); 2217b1ab4580478c90375abec5e2b6e89dc1a15fa98bChris Lattner } 2218b065b06c12dba6001b8140df2744d0c856ef6ea1Chris Lattner CAList.push_back(ConstantStruct::get(StructTy, CSVals)); 22197a90b68e5c85fe11a4ccc386be9c5fcddd4a8b61Chris Lattner } 22209d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 2221b1ab4580478c90375abec5e2b6e89dc1a15fa98bChris Lattner // Create the array initializer. 22229d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov Constant *CA = ConstantArray::get(ArrayType::get(StructTy, 2223c332fba8285e35a5a11463c34795af84f3960759Nick Lewycky CAList.size()), CAList); 22249d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 2225db973e60ced33cfa0332462b1a2d5ae1ae15ad25Chris Lattner // If we didn't change the number of elements, don't create a new GV. 2226db973e60ced33cfa0332462b1a2d5ae1ae15ad25Chris Lattner if (CA->getType() == GCL->getInitializer()->getType()) { 2227db973e60ced33cfa0332462b1a2d5ae1ae15ad25Chris Lattner GCL->setInitializer(CA); 2228db973e60ced33cfa0332462b1a2d5ae1ae15ad25Chris Lattner return GCL; 2229db973e60ced33cfa0332462b1a2d5ae1ae15ad25Chris Lattner } 22309d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 2231b1ab4580478c90375abec5e2b6e89dc1a15fa98bChris Lattner // Create the new global and insert it next to the existing list. 22327b550ccfc5a3346c17e0390a59e2d6d19bc52705Chris Lattner GlobalVariable *NGV = new GlobalVariable(CA->getType(), GCL->isConstant(), 2233c763552299165b88d34a7d4f2d76ff413cbc7f67Lauro Ramos Venancio GCL->getLinkage(), CA, "", 2234ce718ff9f42c7da092eaa01dd0242e8d5ba84713Hans Wennborg GCL->getThreadLocalMode()); 2235b1ab4580478c90375abec5e2b6e89dc1a15fa98bChris Lattner GCL->getParent()->getGlobalList().insert(GCL, NGV); 2236046800a7125cd497613efc0e1ea15cb595666585Chris Lattner NGV->takeName(GCL); 22379d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 2238b1ab4580478c90375abec5e2b6e89dc1a15fa98bChris Lattner // Nuke the old list, replacing any uses with the new one. 2239b1ab4580478c90375abec5e2b6e89dc1a15fa98bChris Lattner if (!GCL->use_empty()) { 2240b1ab4580478c90375abec5e2b6e89dc1a15fa98bChris Lattner Constant *V = NGV; 2241b1ab4580478c90375abec5e2b6e89dc1a15fa98bChris Lattner if (V->getType() != GCL->getType()) 2242baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson V = ConstantExpr::getBitCast(V, GCL->getType()); 2243b1ab4580478c90375abec5e2b6e89dc1a15fa98bChris Lattner GCL->replaceAllUsesWith(V); 2244b1ab4580478c90375abec5e2b6e89dc1a15fa98bChris Lattner } 2245b1ab4580478c90375abec5e2b6e89dc1a15fa98bChris Lattner GCL->eraseFromParent(); 22469d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 2247b1ab4580478c90375abec5e2b6e89dc1a15fa98bChris Lattner if (Ctors.size()) 2248db973e60ced33cfa0332462b1a2d5ae1ae15ad25Chris Lattner return NGV; 2249b1ab4580478c90375abec5e2b6e89dc1a15fa98bChris Lattner else 2250db973e60ced33cfa0332462b1a2d5ae1ae15ad25Chris Lattner return 0; 2251db973e60ced33cfa0332462b1a2d5ae1ae15ad25Chris Lattner} 225279c1101947101ff1585a38dc69d1f1079d44bb04Chris Lattner 225379c1101947101ff1585a38dc69d1f1079d44bb04Chris Lattner 22541945d58025203aec7883c11ac51b827d440f6916Chris Lattnerstatic inline bool 22551945d58025203aec7883c11ac51b827d440f6916Chris LattnerisSimpleEnoughValueToCommit(Constant *C, 2256fb54ad19e7ef1b4f7177a005332ca8aca9bdbcb1Eli Friedman SmallPtrSet<Constant*, 8> &SimpleConstants, 2257fb54ad19e7ef1b4f7177a005332ca8aca9bdbcb1Eli Friedman const TargetData *TD); 22581945d58025203aec7883c11ac51b827d440f6916Chris Lattner 22591945d58025203aec7883c11ac51b827d440f6916Chris Lattner 22601945d58025203aec7883c11ac51b827d440f6916Chris Lattner/// isSimpleEnoughValueToCommit - Return true if the specified constant can be 22611945d58025203aec7883c11ac51b827d440f6916Chris Lattner/// handled by the code generator. We don't want to generate something like: 22621945d58025203aec7883c11ac51b827d440f6916Chris Lattner/// void *X = &X/42; 22631945d58025203aec7883c11ac51b827d440f6916Chris Lattner/// because the code generator doesn't have a relocation that can handle that. 22641945d58025203aec7883c11ac51b827d440f6916Chris Lattner/// 22651945d58025203aec7883c11ac51b827d440f6916Chris Lattner/// This function should be called if C was not found (but just got inserted) 22661945d58025203aec7883c11ac51b827d440f6916Chris Lattner/// in SimpleConstants to avoid having to rescan the same constants all the 22671945d58025203aec7883c11ac51b827d440f6916Chris Lattner/// time. 22681945d58025203aec7883c11ac51b827d440f6916Chris Lattnerstatic bool isSimpleEnoughValueToCommitHelper(Constant *C, 2269fb54ad19e7ef1b4f7177a005332ca8aca9bdbcb1Eli Friedman SmallPtrSet<Constant*, 8> &SimpleConstants, 2270fb54ad19e7ef1b4f7177a005332ca8aca9bdbcb1Eli Friedman const TargetData *TD) { 22711945d58025203aec7883c11ac51b827d440f6916Chris Lattner // Simple integer, undef, constant aggregate zero, global addresses, etc are 22721945d58025203aec7883c11ac51b827d440f6916Chris Lattner // all supported. 22731945d58025203aec7883c11ac51b827d440f6916Chris Lattner if (C->getNumOperands() == 0 || isa<BlockAddress>(C) || 22741945d58025203aec7883c11ac51b827d440f6916Chris Lattner isa<GlobalValue>(C)) 22751945d58025203aec7883c11ac51b827d440f6916Chris Lattner return true; 22761945d58025203aec7883c11ac51b827d440f6916Chris Lattner 22771945d58025203aec7883c11ac51b827d440f6916Chris Lattner // Aggregate values are safe if all their elements are. 22781945d58025203aec7883c11ac51b827d440f6916Chris Lattner if (isa<ConstantArray>(C) || isa<ConstantStruct>(C) || 22791945d58025203aec7883c11ac51b827d440f6916Chris Lattner isa<ConstantVector>(C)) { 22801945d58025203aec7883c11ac51b827d440f6916Chris Lattner for (unsigned i = 0, e = C->getNumOperands(); i != e; ++i) { 22811945d58025203aec7883c11ac51b827d440f6916Chris Lattner Constant *Op = cast<Constant>(C->getOperand(i)); 2282fb54ad19e7ef1b4f7177a005332ca8aca9bdbcb1Eli Friedman if (!isSimpleEnoughValueToCommit(Op, SimpleConstants, TD)) 22831945d58025203aec7883c11ac51b827d440f6916Chris Lattner return false; 22841945d58025203aec7883c11ac51b827d440f6916Chris Lattner } 22851945d58025203aec7883c11ac51b827d440f6916Chris Lattner return true; 22861945d58025203aec7883c11ac51b827d440f6916Chris Lattner } 22871945d58025203aec7883c11ac51b827d440f6916Chris Lattner 22881945d58025203aec7883c11ac51b827d440f6916Chris Lattner // We don't know exactly what relocations are allowed in constant expressions, 22891945d58025203aec7883c11ac51b827d440f6916Chris Lattner // so we allow &global+constantoffset, which is safe and uniformly supported 22901945d58025203aec7883c11ac51b827d440f6916Chris Lattner // across targets. 22911945d58025203aec7883c11ac51b827d440f6916Chris Lattner ConstantExpr *CE = cast<ConstantExpr>(C); 22921945d58025203aec7883c11ac51b827d440f6916Chris Lattner switch (CE->getOpcode()) { 22931945d58025203aec7883c11ac51b827d440f6916Chris Lattner case Instruction::BitCast: 2294fb54ad19e7ef1b4f7177a005332ca8aca9bdbcb1Eli Friedman // Bitcast is fine if the casted value is fine. 2295fb54ad19e7ef1b4f7177a005332ca8aca9bdbcb1Eli Friedman return isSimpleEnoughValueToCommit(CE->getOperand(0), SimpleConstants, TD); 2296fb54ad19e7ef1b4f7177a005332ca8aca9bdbcb1Eli Friedman 22971945d58025203aec7883c11ac51b827d440f6916Chris Lattner case Instruction::IntToPtr: 22981945d58025203aec7883c11ac51b827d440f6916Chris Lattner case Instruction::PtrToInt: 2299fb54ad19e7ef1b4f7177a005332ca8aca9bdbcb1Eli Friedman // int <=> ptr is fine if the int type is the same size as the 2300fb54ad19e7ef1b4f7177a005332ca8aca9bdbcb1Eli Friedman // pointer type. 2301fb54ad19e7ef1b4f7177a005332ca8aca9bdbcb1Eli Friedman if (!TD || TD->getTypeSizeInBits(CE->getType()) != 2302fb54ad19e7ef1b4f7177a005332ca8aca9bdbcb1Eli Friedman TD->getTypeSizeInBits(CE->getOperand(0)->getType())) 2303fb54ad19e7ef1b4f7177a005332ca8aca9bdbcb1Eli Friedman return false; 2304fb54ad19e7ef1b4f7177a005332ca8aca9bdbcb1Eli Friedman return isSimpleEnoughValueToCommit(CE->getOperand(0), SimpleConstants, TD); 23051945d58025203aec7883c11ac51b827d440f6916Chris Lattner 23061945d58025203aec7883c11ac51b827d440f6916Chris Lattner // GEP is fine if it is simple + constant offset. 23071945d58025203aec7883c11ac51b827d440f6916Chris Lattner case Instruction::GetElementPtr: 23081945d58025203aec7883c11ac51b827d440f6916Chris Lattner for (unsigned i = 1, e = CE->getNumOperands(); i != e; ++i) 23091945d58025203aec7883c11ac51b827d440f6916Chris Lattner if (!isa<ConstantInt>(CE->getOperand(i))) 23101945d58025203aec7883c11ac51b827d440f6916Chris Lattner return false; 2311fb54ad19e7ef1b4f7177a005332ca8aca9bdbcb1Eli Friedman return isSimpleEnoughValueToCommit(CE->getOperand(0), SimpleConstants, TD); 23121945d58025203aec7883c11ac51b827d440f6916Chris Lattner 23131945d58025203aec7883c11ac51b827d440f6916Chris Lattner case Instruction::Add: 23141945d58025203aec7883c11ac51b827d440f6916Chris Lattner // We allow simple+cst. 23151945d58025203aec7883c11ac51b827d440f6916Chris Lattner if (!isa<ConstantInt>(CE->getOperand(1))) 23161945d58025203aec7883c11ac51b827d440f6916Chris Lattner return false; 2317fb54ad19e7ef1b4f7177a005332ca8aca9bdbcb1Eli Friedman return isSimpleEnoughValueToCommit(CE->getOperand(0), SimpleConstants, TD); 23181945d58025203aec7883c11ac51b827d440f6916Chris Lattner } 23191945d58025203aec7883c11ac51b827d440f6916Chris Lattner return false; 23201945d58025203aec7883c11ac51b827d440f6916Chris Lattner} 23211945d58025203aec7883c11ac51b827d440f6916Chris Lattner 23221945d58025203aec7883c11ac51b827d440f6916Chris Lattnerstatic inline bool 23231945d58025203aec7883c11ac51b827d440f6916Chris LattnerisSimpleEnoughValueToCommit(Constant *C, 2324fb54ad19e7ef1b4f7177a005332ca8aca9bdbcb1Eli Friedman SmallPtrSet<Constant*, 8> &SimpleConstants, 2325fb54ad19e7ef1b4f7177a005332ca8aca9bdbcb1Eli Friedman const TargetData *TD) { 23261945d58025203aec7883c11ac51b827d440f6916Chris Lattner // If we already checked this constant, we win. 23271945d58025203aec7883c11ac51b827d440f6916Chris Lattner if (!SimpleConstants.insert(C)) return true; 23281945d58025203aec7883c11ac51b827d440f6916Chris Lattner // Check the constant. 2329fb54ad19e7ef1b4f7177a005332ca8aca9bdbcb1Eli Friedman return isSimpleEnoughValueToCommitHelper(C, SimpleConstants, TD); 23301945d58025203aec7883c11ac51b827d440f6916Chris Lattner} 23311945d58025203aec7883c11ac51b827d440f6916Chris Lattner 23321945d58025203aec7883c11ac51b827d440f6916Chris Lattner 233379c1101947101ff1585a38dc69d1f1079d44bb04Chris Lattner/// isSimpleEnoughPointerToCommit - Return true if this constant is simple 2334cff6b3772bd991119ff4882e06af29fbdb60e93fOwen Anderson/// enough for us to understand. In particular, if it is a cast to anything 2335cff6b3772bd991119ff4882e06af29fbdb60e93fOwen Anderson/// other than from one pointer type to another pointer type, we punt. 2336cff6b3772bd991119ff4882e06af29fbdb60e93fOwen Anderson/// We basically just support direct accesses to globals and GEP's of 233779c1101947101ff1585a38dc69d1f1079d44bb04Chris Lattner/// globals. This should be kept up to date with CommitValueTo. 23387b550ccfc5a3346c17e0390a59e2d6d19bc52705Chris Lattnerstatic bool isSimpleEnoughPointerToCommit(Constant *C) { 2339ce5de5b52768d0c3b9c0f6c4bc915a17e962202cDan Gohman // Conservatively, avoid aggregate types. This is because we don't 2340ce5de5b52768d0c3b9c0f6c4bc915a17e962202cDan Gohman // want to worry about them partially overlapping other stores. 2341ce5de5b52768d0c3b9c0f6c4bc915a17e962202cDan Gohman if (!cast<PointerType>(C->getType())->getElementType()->isSingleValueType()) 2342ce5de5b52768d0c3b9c0f6c4bc915a17e962202cDan Gohman return false; 2343ce5de5b52768d0c3b9c0f6c4bc915a17e962202cDan Gohman 2344fd54a898be08e8da12cb2e99dbb63015083940a3Dan Gohman if (GlobalVariable *GV = dyn_cast<GlobalVariable>(C)) 234599fca5de96d3435e8eb7c84e8366cee98ef5416aMikhail Glushenkov // Do not allow weak/*_odr/linkonce/dllimport/dllexport linkage or 2346fd54a898be08e8da12cb2e99dbb63015083940a3Dan Gohman // external globals. 234799fca5de96d3435e8eb7c84e8366cee98ef5416aMikhail Glushenkov return GV->hasUniqueInitializer(); 2348fd54a898be08e8da12cb2e99dbb63015083940a3Dan Gohman 2349e95a32ce40f8c189e939788a82fd54ca9280f973Owen Anderson if (ConstantExpr *CE = dyn_cast<ConstantExpr>(C)) { 2350798b4d5bb32d51f9fed87893f65ea571fd90b161Chris Lattner // Handle a constantexpr gep. 2351798b4d5bb32d51f9fed87893f65ea571fd90b161Chris Lattner if (CE->getOpcode() == Instruction::GetElementPtr && 2352c62482d4edecd416e6529e31427fa6fd8a9b7eceDan Gohman isa<GlobalVariable>(CE->getOperand(0)) && 2353c62482d4edecd416e6529e31427fa6fd8a9b7eceDan Gohman cast<GEPOperator>(CE)->isInBounds()) { 2354798b4d5bb32d51f9fed87893f65ea571fd90b161Chris Lattner GlobalVariable *GV = cast<GlobalVariable>(CE->getOperand(0)); 235599fca5de96d3435e8eb7c84e8366cee98ef5416aMikhail Glushenkov // Do not allow weak/*_odr/linkonce/dllimport/dllexport linkage or 2356fd54a898be08e8da12cb2e99dbb63015083940a3Dan Gohman // external globals. 235799fca5de96d3435e8eb7c84e8366cee98ef5416aMikhail Glushenkov if (!GV->hasUniqueInitializer()) 2358fd54a898be08e8da12cb2e99dbb63015083940a3Dan Gohman return false; 235980bdc967e946b5d68646ffdee857400f9a120ccaDan Gohman 236080bdc967e946b5d68646ffdee857400f9a120ccaDan Gohman // The first index must be zero. 2361ee56c42168f6c4271593f6018c4409b6a5910302Oscar Fuentes ConstantInt *CI = dyn_cast<ConstantInt>(*llvm::next(CE->op_begin())); 236280bdc967e946b5d68646ffdee857400f9a120ccaDan Gohman if (!CI || !CI->isZero()) return false; 236380bdc967e946b5d68646ffdee857400f9a120ccaDan Gohman 236480bdc967e946b5d68646ffdee857400f9a120ccaDan Gohman // The remaining indices must be compile-time known integers within the 2365e6992f728a94654e43269580a10a667f18dadba9Dan Gohman // notional bounds of the corresponding static array types. 2366e6992f728a94654e43269580a10a667f18dadba9Dan Gohman if (!CE->isGEPWithNoNotionalOverIndexing()) 2367e6992f728a94654e43269580a10a667f18dadba9Dan Gohman return false; 236880bdc967e946b5d68646ffdee857400f9a120ccaDan Gohman 2369c6f69e94fa46f585b59bb9d7ace3224b0e638c95Dan Gohman return ConstantFoldLoadThroughGEPConstantExpr(GV->getInitializer(), CE); 2370cff6b3772bd991119ff4882e06af29fbdb60e93fOwen Anderson 2371cff6b3772bd991119ff4882e06af29fbdb60e93fOwen Anderson // A constantexpr bitcast from a pointer to another pointer is a no-op, 2372cff6b3772bd991119ff4882e06af29fbdb60e93fOwen Anderson // and we know how to evaluate it by moving the bitcast from the pointer 2373cff6b3772bd991119ff4882e06af29fbdb60e93fOwen Anderson // operand to the value operand. 2374cff6b3772bd991119ff4882e06af29fbdb60e93fOwen Anderson } else if (CE->getOpcode() == Instruction::BitCast && 2375d5f656f48b98b4fc4dcb131f113316ba04180f11Chris Lattner isa<GlobalVariable>(CE->getOperand(0))) { 2376cff6b3772bd991119ff4882e06af29fbdb60e93fOwen Anderson // Do not allow weak/*_odr/linkonce/dllimport/dllexport linkage or 2377cff6b3772bd991119ff4882e06af29fbdb60e93fOwen Anderson // external globals. 2378d5f656f48b98b4fc4dcb131f113316ba04180f11Chris Lattner return cast<GlobalVariable>(CE->getOperand(0))->hasUniqueInitializer(); 2379798b4d5bb32d51f9fed87893f65ea571fd90b161Chris Lattner } 2380e95a32ce40f8c189e939788a82fd54ca9280f973Owen Anderson } 2381e95a32ce40f8c189e939788a82fd54ca9280f973Owen Anderson 238279c1101947101ff1585a38dc69d1f1079d44bb04Chris Lattner return false; 238379c1101947101ff1585a38dc69d1f1079d44bb04Chris Lattner} 238479c1101947101ff1585a38dc69d1f1079d44bb04Chris Lattner 2385798b4d5bb32d51f9fed87893f65ea571fd90b161Chris Lattner/// EvaluateStoreInto - Evaluate a piece of a constantexpr store into a global 2386798b4d5bb32d51f9fed87893f65ea571fd90b161Chris Lattner/// initializer. This returns 'Init' modified to reflect 'Val' stored into it. 2387798b4d5bb32d51f9fed87893f65ea571fd90b161Chris Lattner/// At this point, the GEP operands of Addr [0, OpNo) have been stepped into. 2388798b4d5bb32d51f9fed87893f65ea571fd90b161Chris Lattnerstatic Constant *EvaluateStoreInto(Constant *Init, Constant *Val, 23897b550ccfc5a3346c17e0390a59e2d6d19bc52705Chris Lattner ConstantExpr *Addr, unsigned OpNo) { 2390798b4d5bb32d51f9fed87893f65ea571fd90b161Chris Lattner // Base case of the recursion. 2391798b4d5bb32d51f9fed87893f65ea571fd90b161Chris Lattner if (OpNo == Addr->getNumOperands()) { 2392798b4d5bb32d51f9fed87893f65ea571fd90b161Chris Lattner assert(Val->getType() == Init->getType() && "Type mismatch!"); 2393798b4d5bb32d51f9fed87893f65ea571fd90b161Chris Lattner return Val; 2394798b4d5bb32d51f9fed87893f65ea571fd90b161Chris Lattner } 23959d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 2396a78fa8cc2dd6d2ffe5e4fe605f38aae7b3d2fb7aChris Lattner SmallVector<Constant*, 32> Elts; 2397db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner if (StructType *STy = dyn_cast<StructType>(Init->getType())) { 2398798b4d5bb32d51f9fed87893f65ea571fd90b161Chris Lattner // Break up the constant into its elements. 2399d59ae907eea28285ece6696d6f3271b4ca578c0dChris Lattner for (unsigned i = 0, e = STy->getNumElements(); i != e; ++i) 2400d59ae907eea28285ece6696d6f3271b4ca578c0dChris Lattner Elts.push_back(Init->getAggregateElement(i)); 24019d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 2402798b4d5bb32d51f9fed87893f65ea571fd90b161Chris Lattner // Replace the element that we are supposed to. 2403b83eb6447ba155342598f0fabe1f08f5baa9164aReid Spencer ConstantInt *CU = cast<ConstantInt>(Addr->getOperand(OpNo)); 2404b83eb6447ba155342598f0fabe1f08f5baa9164aReid Spencer unsigned Idx = CU->getZExtValue(); 2405b83eb6447ba155342598f0fabe1f08f5baa9164aReid Spencer assert(Idx < STy->getNumElements() && "Struct index out of range!"); 24067b550ccfc5a3346c17e0390a59e2d6d19bc52705Chris Lattner Elts[Idx] = EvaluateStoreInto(Elts[Idx], Val, Addr, OpNo+1); 24079d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 2408798b4d5bb32d51f9fed87893f65ea571fd90b161Chris Lattner // Return the modified struct. 2409b065b06c12dba6001b8140df2744d0c856ef6ea1Chris Lattner return ConstantStruct::get(STy, Elts); 2410b065b06c12dba6001b8140df2744d0c856ef6ea1Chris Lattner } 2411b065b06c12dba6001b8140df2744d0c856ef6ea1Chris Lattner 2412b065b06c12dba6001b8140df2744d0c856ef6ea1Chris Lattner ConstantInt *CI = cast<ConstantInt>(Addr->getOperand(OpNo)); 2413db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner SequentialType *InitTy = cast<SequentialType>(Init->getType()); 24149d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 2415b065b06c12dba6001b8140df2744d0c856ef6ea1Chris Lattner uint64_t NumElts; 2416db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner if (ArrayType *ATy = dyn_cast<ArrayType>(InitTy)) 2417b065b06c12dba6001b8140df2744d0c856ef6ea1Chris Lattner NumElts = ATy->getNumElements(); 2418b065b06c12dba6001b8140df2744d0c856ef6ea1Chris Lattner else 2419d59ae907eea28285ece6696d6f3271b4ca578c0dChris Lattner NumElts = InitTy->getVectorNumElements(); 2420b065b06c12dba6001b8140df2744d0c856ef6ea1Chris Lattner 2421b065b06c12dba6001b8140df2744d0c856ef6ea1Chris Lattner // Break up the array into elements. 2422d59ae907eea28285ece6696d6f3271b4ca578c0dChris Lattner for (uint64_t i = 0, e = NumElts; i != e; ++i) 2423d59ae907eea28285ece6696d6f3271b4ca578c0dChris Lattner Elts.push_back(Init->getAggregateElement(i)); 24249d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 2425b065b06c12dba6001b8140df2744d0c856ef6ea1Chris Lattner assert(CI->getZExtValue() < NumElts); 2426b065b06c12dba6001b8140df2744d0c856ef6ea1Chris Lattner Elts[CI->getZExtValue()] = 2427b065b06c12dba6001b8140df2744d0c856ef6ea1Chris Lattner EvaluateStoreInto(Elts[CI->getZExtValue()], Val, Addr, OpNo+1); 24289d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 2429b065b06c12dba6001b8140df2744d0c856ef6ea1Chris Lattner if (Init->getType()->isArrayTy()) 2430b065b06c12dba6001b8140df2744d0c856ef6ea1Chris Lattner return ConstantArray::get(cast<ArrayType>(InitTy), Elts); 2431b065b06c12dba6001b8140df2744d0c856ef6ea1Chris Lattner return ConstantVector::get(Elts); 2432798b4d5bb32d51f9fed87893f65ea571fd90b161Chris Lattner} 2433798b4d5bb32d51f9fed87893f65ea571fd90b161Chris Lattner 243479c1101947101ff1585a38dc69d1f1079d44bb04Chris Lattner/// CommitValueTo - We have decided that Addr (which satisfies the predicate 243579c1101947101ff1585a38dc69d1f1079d44bb04Chris Lattner/// isSimpleEnoughPointerToCommit) should get Val as its value. Make it happen. 24367b550ccfc5a3346c17e0390a59e2d6d19bc52705Chris Lattnerstatic void CommitValueTo(Constant *Val, Constant *Addr) { 2437798b4d5bb32d51f9fed87893f65ea571fd90b161Chris Lattner if (GlobalVariable *GV = dyn_cast<GlobalVariable>(Addr)) { 2438798b4d5bb32d51f9fed87893f65ea571fd90b161Chris Lattner assert(GV->hasInitializer()); 2439798b4d5bb32d51f9fed87893f65ea571fd90b161Chris Lattner GV->setInitializer(Val); 2440798b4d5bb32d51f9fed87893f65ea571fd90b161Chris Lattner return; 2441798b4d5bb32d51f9fed87893f65ea571fd90b161Chris Lattner } 2442a0e9a2475cd6e45966a591de8e0740a102fe0dfeChris Lattner 2443798b4d5bb32d51f9fed87893f65ea571fd90b161Chris Lattner ConstantExpr *CE = cast<ConstantExpr>(Addr); 2444798b4d5bb32d51f9fed87893f65ea571fd90b161Chris Lattner GlobalVariable *GV = cast<GlobalVariable>(CE->getOperand(0)); 2445a0e9a2475cd6e45966a591de8e0740a102fe0dfeChris Lattner GV->setInitializer(EvaluateStoreInto(GV->getInitializer(), Val, CE, 2)); 244679c1101947101ff1585a38dc69d1f1079d44bb04Chris Lattner} 244779c1101947101ff1585a38dc69d1f1079d44bb04Chris Lattner 24487fa767770574ba0312165ac9ed08f792b8fb7874Nick Lewyckynamespace { 24497fa767770574ba0312165ac9ed08f792b8fb7874Nick Lewycky 24507fa767770574ba0312165ac9ed08f792b8fb7874Nick Lewycky/// Evaluator - This class evaluates LLVM IR, producing the Constant 24517fa767770574ba0312165ac9ed08f792b8fb7874Nick Lewycky/// representing each SSA instruction. Changes to global variables are stored 24527fa767770574ba0312165ac9ed08f792b8fb7874Nick Lewycky/// in a mapping that can be iterated over after the evaluation is complete. 24537fa767770574ba0312165ac9ed08f792b8fb7874Nick Lewycky/// Once an evaluation call fails, the evaluation object should not be reused. 24547fa767770574ba0312165ac9ed08f792b8fb7874Nick Lewyckyclass Evaluator { 245523ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewyckypublic: 24567fa767770574ba0312165ac9ed08f792b8fb7874Nick Lewycky Evaluator(const TargetData *TD, const TargetLibraryInfo *TLI) 245723ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky : TD(TD), TLI(TLI) { 245823ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky ValueStack.push_back(new DenseMap<Value*, Constant*>); 245923ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky } 246023ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky 24617fa767770574ba0312165ac9ed08f792b8fb7874Nick Lewycky ~Evaluator() { 246223ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky DeleteContainerPointers(ValueStack); 246323ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky while (!AllocaTmps.empty()) { 246423ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky GlobalVariable *Tmp = AllocaTmps.back(); 246523ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky AllocaTmps.pop_back(); 246623ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky 246723ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky // If there are still users of the alloca, the program is doing something 246823ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky // silly, e.g. storing the address of the alloca somewhere and using it 246923ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky // later. Since this is undefined, we'll just make it be null. 247023ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky if (!Tmp->use_empty()) 247123ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky Tmp->replaceAllUsesWith(Constant::getNullValue(Tmp->getType())); 247223ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky delete Tmp; 247323ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky } 247423ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky } 247523ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky 247623ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky /// EvaluateFunction - Evaluate a call to function F, returning true if 247723ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky /// successful, false if we can't evaluate it. ActualArgs contains the formal 247823ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky /// arguments for the function. 247923ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky bool EvaluateFunction(Function *F, Constant *&RetVal, 248023ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky const SmallVectorImpl<Constant*> &ActualArgs); 248123ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky 248223ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky /// EvaluateBlock - Evaluate all instructions in block BB, returning true if 248323ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky /// successful, false if we can't evaluate it. NewBB returns the next BB that 248423ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky /// control flows into, or null upon return. 248523ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky bool EvaluateBlock(BasicBlock::iterator CurInst, BasicBlock *&NextBB); 248623ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky 248723ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky Constant *getVal(Value *V) { 248823ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky if (Constant *CV = dyn_cast<Constant>(V)) return CV; 248923ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky Constant *R = ValueStack.back()->lookup(V); 249023ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky assert(R && "Reference to an uncomputed value!"); 249123ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky return R; 249223ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky } 249323ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky 249423ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky void setVal(Value *V, Constant *C) { 249523ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky ValueStack.back()->operator[](V) = C; 249623ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky } 249723ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky 249823ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky const DenseMap<Constant*, Constant*> &getMutatedMemory() const { 249923ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky return MutatedMemory; 250023ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky } 250123ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky 250223ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky const SmallPtrSet<GlobalVariable*, 8> &getInvariants() const { 250323ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky return Invariants; 250423ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky } 250523ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky 250623ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewyckyprivate: 250723ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky Constant *ComputeLoadResult(Constant *P); 250823ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky 250923ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky /// ValueStack - As we compute SSA register values, we store their contents 251023ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky /// here. The back of the vector contains the current function and the stack 251123ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky /// contains the values in the calling frames. 251223ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky SmallVector<DenseMap<Value*, Constant*>*, 4> ValueStack; 251323ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky 251423ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky /// CallStack - This is used to detect recursion. In pathological situations 251523ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky /// we could hit exponential behavior, but at least there is nothing 251623ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky /// unbounded. 251723ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky SmallVector<Function*, 4> CallStack; 251823ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky 251923ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky /// MutatedMemory - For each store we execute, we update this map. Loads 252023ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky /// check this to get the most up-to-date value. If evaluation is successful, 252123ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky /// this state is committed to the process. 252223ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky DenseMap<Constant*, Constant*> MutatedMemory; 252323ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky 252423ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky /// AllocaTmps - To 'execute' an alloca, we create a temporary global variable 252523ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky /// to represent its body. This vector is needed so we can delete the 252623ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky /// temporary globals when we are done. 252723ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky SmallVector<GlobalVariable*, 32> AllocaTmps; 252823ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky 252923ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky /// Invariants - These global variables have been marked invariant by the 253023ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky /// static constructor. 253123ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky SmallPtrSet<GlobalVariable*, 8> Invariants; 253223ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky 253323ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky /// SimpleConstants - These are constants we have checked and know to be 253423ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky /// simple enough to live in a static initializer of a global. 253523ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky SmallPtrSet<Constant*, 8> SimpleConstants; 253623ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky 253723ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky const TargetData *TD; 253823ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky const TargetLibraryInfo *TLI; 253923ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky}; 254023ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky 25417fa767770574ba0312165ac9ed08f792b8fb7874Nick Lewycky} // anonymous namespace 25427fa767770574ba0312165ac9ed08f792b8fb7874Nick Lewycky 2543562a055ca731c2f673cc4cfb60de963fce5e38a6Chris Lattner/// ComputeLoadResult - Return the value that would be computed by a load from 2544562a055ca731c2f673cc4cfb60de963fce5e38a6Chris Lattner/// P after the stores reflected by 'memory' have been performed. If we can't 2545562a055ca731c2f673cc4cfb60de963fce5e38a6Chris Lattner/// decide, return null. 25467fa767770574ba0312165ac9ed08f792b8fb7874Nick LewyckyConstant *Evaluator::ComputeLoadResult(Constant *P) { 254704de1cfb2b58cd3fff06d0328a733082ce775ab6Chris Lattner // If this memory location has been recently stored, use the stored value: it 254804de1cfb2b58cd3fff06d0328a733082ce775ab6Chris Lattner // is the most up-to-date. 254923ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky DenseMap<Constant*, Constant*>::const_iterator I = MutatedMemory.find(P); 255023ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky if (I != MutatedMemory.end()) return I->second; 25519d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 255204de1cfb2b58cd3fff06d0328a733082ce775ab6Chris Lattner // Access it. 255304de1cfb2b58cd3fff06d0328a733082ce775ab6Chris Lattner if (GlobalVariable *GV = dyn_cast<GlobalVariable>(P)) { 25548255573835970e7130ba93271972172fb335f2ecDan Gohman if (GV->hasDefinitiveInitializer()) 255504de1cfb2b58cd3fff06d0328a733082ce775ab6Chris Lattner return GV->getInitializer(); 255604de1cfb2b58cd3fff06d0328a733082ce775ab6Chris Lattner return 0; 255704de1cfb2b58cd3fff06d0328a733082ce775ab6Chris Lattner } 25589d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 2559798b4d5bb32d51f9fed87893f65ea571fd90b161Chris Lattner // Handle a constantexpr getelementptr. 2560798b4d5bb32d51f9fed87893f65ea571fd90b161Chris Lattner if (ConstantExpr *CE = dyn_cast<ConstantExpr>(P)) 2561798b4d5bb32d51f9fed87893f65ea571fd90b161Chris Lattner if (CE->getOpcode() == Instruction::GetElementPtr && 2562798b4d5bb32d51f9fed87893f65ea571fd90b161Chris Lattner isa<GlobalVariable>(CE->getOperand(0))) { 2563798b4d5bb32d51f9fed87893f65ea571fd90b161Chris Lattner GlobalVariable *GV = cast<GlobalVariable>(CE->getOperand(0)); 25648255573835970e7130ba93271972172fb335f2ecDan Gohman if (GV->hasDefinitiveInitializer()) 2565c6f69e94fa46f585b59bb9d7ace3224b0e638c95Dan Gohman return ConstantFoldLoadThroughGEPConstantExpr(GV->getInitializer(), CE); 2566798b4d5bb32d51f9fed87893f65ea571fd90b161Chris Lattner } 2567798b4d5bb32d51f9fed87893f65ea571fd90b161Chris Lattner 2568798b4d5bb32d51f9fed87893f65ea571fd90b161Chris Lattner return 0; // don't know how to evaluate. 256904de1cfb2b58cd3fff06d0328a733082ce775ab6Chris Lattner} 257004de1cfb2b58cd3fff06d0328a733082ce775ab6Chris Lattner 2571da82fd411ec37bc81a1e584d2f3163aeda4d2e95Nick Lewycky/// EvaluateBlock - Evaluate all instructions in block BB, returning true if 2572da82fd411ec37bc81a1e584d2f3163aeda4d2e95Nick Lewycky/// successful, false if we can't evaluate it. NewBB returns the next BB that 2573da82fd411ec37bc81a1e584d2f3163aeda4d2e95Nick Lewycky/// control flows into, or null upon return. 25747fa767770574ba0312165ac9ed08f792b8fb7874Nick Lewyckybool Evaluator::EvaluateBlock(BasicBlock::iterator CurInst, 25757fa767770574ba0312165ac9ed08f792b8fb7874Nick Lewycky BasicBlock *&NextBB) { 257679c1101947101ff1585a38dc69d1f1079d44bb04Chris Lattner // This is the main evaluation loop. 257779c1101947101ff1585a38dc69d1f1079d44bb04Chris Lattner while (1) { 257879c1101947101ff1585a38dc69d1f1079d44bb04Chris Lattner Constant *InstResult = 0; 25799d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 258079c1101947101ff1585a38dc69d1f1079d44bb04Chris Lattner if (StoreInst *SI = dyn_cast<StoreInst>(CurInst)) { 258133cb445fb68589d59172e02253367cfae700d4b1Eli Friedman if (!SI->isSimple()) return false; // no volatile/atomic accesses. 258223ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky Constant *Ptr = getVal(SI->getOperand(1)); 2583a641c07828fe4e836d680b9e8b0b4af3204b8b97Nick Lewycky if (ConstantExpr *CE = dyn_cast<ConstantExpr>(Ptr)) 2584a641c07828fe4e836d680b9e8b0b4af3204b8b97Nick Lewycky Ptr = ConstantFoldConstantExpression(CE, TD, TLI); 25857b550ccfc5a3346c17e0390a59e2d6d19bc52705Chris Lattner if (!isSimpleEnoughPointerToCommit(Ptr)) 258679c1101947101ff1585a38dc69d1f1079d44bb04Chris Lattner // If this is too complex for us to commit, reject it. 2587cd27142cc8d09dcab8110a7ef31e5cd6767d8b93Chris Lattner return false; 25881945d58025203aec7883c11ac51b827d440f6916Chris Lattner 258923ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky Constant *Val = getVal(SI->getOperand(0)); 25901945d58025203aec7883c11ac51b827d440f6916Chris Lattner 25911945d58025203aec7883c11ac51b827d440f6916Chris Lattner // If this might be too difficult for the backend to handle (e.g. the addr 25921945d58025203aec7883c11ac51b827d440f6916Chris Lattner // of one global variable divided by another) then we can't commit it. 2593fb54ad19e7ef1b4f7177a005332ca8aca9bdbcb1Eli Friedman if (!isSimpleEnoughValueToCommit(Val, SimpleConstants, TD)) 25941945d58025203aec7883c11ac51b827d440f6916Chris Lattner return false; 2595cff6b3772bd991119ff4882e06af29fbdb60e93fOwen Anderson 2596cff6b3772bd991119ff4882e06af29fbdb60e93fOwen Anderson if (ConstantExpr *CE = dyn_cast<ConstantExpr>(Ptr)) 2597cff6b3772bd991119ff4882e06af29fbdb60e93fOwen Anderson if (CE->getOpcode() == Instruction::BitCast) { 2598cff6b3772bd991119ff4882e06af29fbdb60e93fOwen Anderson // If we're evaluating a store through a bitcast, then we need 2599cff6b3772bd991119ff4882e06af29fbdb60e93fOwen Anderson // to pull the bitcast off the pointer type and push it onto the 2600cff6b3772bd991119ff4882e06af29fbdb60e93fOwen Anderson // stored value. 2601d5f656f48b98b4fc4dcb131f113316ba04180f11Chris Lattner Ptr = CE->getOperand(0); 2602cff6b3772bd991119ff4882e06af29fbdb60e93fOwen Anderson 2603da82fd411ec37bc81a1e584d2f3163aeda4d2e95Nick Lewycky Type *NewTy = cast<PointerType>(Ptr->getType())->getElementType(); 2604cff6b3772bd991119ff4882e06af29fbdb60e93fOwen Anderson 260566f708f7e5f207d7a7ab259b70b5fd94795fb74cOwen Anderson // In order to push the bitcast onto the stored value, a bitcast 260666f708f7e5f207d7a7ab259b70b5fd94795fb74cOwen Anderson // from NewTy to Val's type must be legal. If it's not, we can try 260766f708f7e5f207d7a7ab259b70b5fd94795fb74cOwen Anderson // introspecting NewTy to find a legal conversion. 260866f708f7e5f207d7a7ab259b70b5fd94795fb74cOwen Anderson while (!Val->getType()->canLosslesslyBitCastTo(NewTy)) { 260966f708f7e5f207d7a7ab259b70b5fd94795fb74cOwen Anderson // If NewTy is a struct, we can convert the pointer to the struct 261066f708f7e5f207d7a7ab259b70b5fd94795fb74cOwen Anderson // into a pointer to its first member. 261166f708f7e5f207d7a7ab259b70b5fd94795fb74cOwen Anderson // FIXME: This could be extended to support arrays as well. 2612db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner if (StructType *STy = dyn_cast<StructType>(NewTy)) { 261366f708f7e5f207d7a7ab259b70b5fd94795fb74cOwen Anderson NewTy = STy->getTypeAtIndex(0U); 261466f708f7e5f207d7a7ab259b70b5fd94795fb74cOwen Anderson 2615da82fd411ec37bc81a1e584d2f3163aeda4d2e95Nick Lewycky IntegerType *IdxTy = IntegerType::get(NewTy->getContext(), 32); 261666f708f7e5f207d7a7ab259b70b5fd94795fb74cOwen Anderson Constant *IdxZero = ConstantInt::get(IdxTy, 0, false); 261766f708f7e5f207d7a7ab259b70b5fd94795fb74cOwen Anderson Constant * const IdxList[] = {IdxZero, IdxZero}; 261866f708f7e5f207d7a7ab259b70b5fd94795fb74cOwen Anderson 2619b4263a6ff4f9696fc84a8f75b5d09564ff06381fJay Foad Ptr = ConstantExpr::getGetElementPtr(Ptr, IdxList); 2620a641c07828fe4e836d680b9e8b0b4af3204b8b97Nick Lewycky if (ConstantExpr *CE = dyn_cast<ConstantExpr>(Ptr)) 2621a641c07828fe4e836d680b9e8b0b4af3204b8b97Nick Lewycky Ptr = ConstantFoldConstantExpression(CE, TD, TLI); 2622a641c07828fe4e836d680b9e8b0b4af3204b8b97Nick Lewycky 262366f708f7e5f207d7a7ab259b70b5fd94795fb74cOwen Anderson // If we can't improve the situation by introspecting NewTy, 262466f708f7e5f207d7a7ab259b70b5fd94795fb74cOwen Anderson // we have to give up. 262566f708f7e5f207d7a7ab259b70b5fd94795fb74cOwen Anderson } else { 2626da82fd411ec37bc81a1e584d2f3163aeda4d2e95Nick Lewycky return false; 262766f708f7e5f207d7a7ab259b70b5fd94795fb74cOwen Anderson } 2628cff6b3772bd991119ff4882e06af29fbdb60e93fOwen Anderson } 2629cff6b3772bd991119ff4882e06af29fbdb60e93fOwen Anderson 263066f708f7e5f207d7a7ab259b70b5fd94795fb74cOwen Anderson // If we found compatible types, go ahead and push the bitcast 263166f708f7e5f207d7a7ab259b70b5fd94795fb74cOwen Anderson // onto the stored value. 2632cff6b3772bd991119ff4882e06af29fbdb60e93fOwen Anderson Val = ConstantExpr::getBitCast(Val, NewTy); 2633cff6b3772bd991119ff4882e06af29fbdb60e93fOwen Anderson } 2634cff6b3772bd991119ff4882e06af29fbdb60e93fOwen Anderson 263579c1101947101ff1585a38dc69d1f1079d44bb04Chris Lattner MutatedMemory[Ptr] = Val; 263679c1101947101ff1585a38dc69d1f1079d44bb04Chris Lattner } else if (BinaryOperator *BO = dyn_cast<BinaryOperator>(CurInst)) { 2637baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson InstResult = ConstantExpr::get(BO->getOpcode(), 263823ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky getVal(BO->getOperand(0)), 263923ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky getVal(BO->getOperand(1))); 2640e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer } else if (CmpInst *CI = dyn_cast<CmpInst>(CurInst)) { 2641baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson InstResult = ConstantExpr::getCompare(CI->getPredicate(), 264223ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky getVal(CI->getOperand(0)), 264323ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky getVal(CI->getOperand(1))); 264479c1101947101ff1585a38dc69d1f1079d44bb04Chris Lattner } else if (CastInst *CI = dyn_cast<CastInst>(CurInst)) { 2645baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson InstResult = ConstantExpr::getCast(CI->getOpcode(), 264623ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky getVal(CI->getOperand(0)), 264779c1101947101ff1585a38dc69d1f1079d44bb04Chris Lattner CI->getType()); 264879c1101947101ff1585a38dc69d1f1079d44bb04Chris Lattner } else if (SelectInst *SI = dyn_cast<SelectInst>(CurInst)) { 264923ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky InstResult = ConstantExpr::getSelect(getVal(SI->getOperand(0)), 265023ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky getVal(SI->getOperand(1)), 265123ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky getVal(SI->getOperand(2))); 265204de1cfb2b58cd3fff06d0328a733082ce775ab6Chris Lattner } else if (GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(CurInst)) { 265323ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky Constant *P = getVal(GEP->getOperand(0)); 265455eb1c47de30a6b4e8707b6392e878e32a6583e9Chris Lattner SmallVector<Constant*, 8> GEPOps; 26555e46321d665d6b1f445aff70d8eabb4870a6cf0eGabor Greif for (User::op_iterator i = GEP->op_begin() + 1, e = GEP->op_end(); 26565e46321d665d6b1f445aff70d8eabb4870a6cf0eGabor Greif i != e; ++i) 265723ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky GEPOps.push_back(getVal(*i)); 26584b5e207bf24ea9799547a0634acaf7398b32897cJay Foad InstResult = 26594b5e207bf24ea9799547a0634acaf7398b32897cJay Foad ConstantExpr::getGetElementPtr(P, GEPOps, 26604b5e207bf24ea9799547a0634acaf7398b32897cJay Foad cast<GEPOperator>(GEP)->isInBounds()); 266104de1cfb2b58cd3fff06d0328a733082ce775ab6Chris Lattner } else if (LoadInst *LI = dyn_cast<LoadInst>(CurInst)) { 266233cb445fb68589d59172e02253367cfae700d4b1Eli Friedman if (!LI->isSimple()) return false; // no volatile/atomic accesses. 2663a641c07828fe4e836d680b9e8b0b4af3204b8b97Nick Lewycky Constant *Ptr = getVal(LI->getOperand(0)); 2664a641c07828fe4e836d680b9e8b0b4af3204b8b97Nick Lewycky if (ConstantExpr *CE = dyn_cast<ConstantExpr>(Ptr)) 2665a641c07828fe4e836d680b9e8b0b4af3204b8b97Nick Lewycky Ptr = ConstantFoldConstantExpression(CE, TD, TLI); 2666a641c07828fe4e836d680b9e8b0b4af3204b8b97Nick Lewycky InstResult = ComputeLoadResult(Ptr); 2667cd27142cc8d09dcab8110a7ef31e5cd6767d8b93Chris Lattner if (InstResult == 0) return false; // Could not evaluate load. 2668a22fdb0a37f935fc3e3391d47d64267a92cfc2e8Chris Lattner } else if (AllocaInst *AI = dyn_cast<AllocaInst>(CurInst)) { 2669cd27142cc8d09dcab8110a7ef31e5cd6767d8b93Chris Lattner if (AI->isArrayAllocation()) return false; // Cannot handle array allocs. 2670db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *Ty = AI->getType()->getElementType(); 26717b550ccfc5a3346c17e0390a59e2d6d19bc52705Chris Lattner AllocaTmps.push_back(new GlobalVariable(Ty, false, 2672a22fdb0a37f935fc3e3391d47d64267a92cfc2e8Chris Lattner GlobalValue::InternalLinkage, 26739e9a0d5fc26878e51a58a8b57900fcbf952c2691Owen Anderson UndefValue::get(Ty), 2674a22fdb0a37f935fc3e3391d47d64267a92cfc2e8Chris Lattner AI->getName())); 26759d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov InstResult = AllocaTmps.back(); 2676132bd9ce56e1f6d0231c34acec738a8bc92c9cfaNick Lewycky } else if (isa<CallInst>(CurInst) || isa<InvokeInst>(CurInst)) { 2677132bd9ce56e1f6d0231c34acec738a8bc92c9cfaNick Lewycky CallSite CS(CurInst); 2678412a4469746d468c46b7e7e4f1c77407dab0a1ceDevang Patel 2679412a4469746d468c46b7e7e4f1c77407dab0a1ceDevang Patel // Debug info can safely be ignored here. 2680132bd9ce56e1f6d0231c34acec738a8bc92c9cfaNick Lewycky if (isa<DbgInfoIntrinsic>(CS.getInstruction())) { 2681412a4469746d468c46b7e7e4f1c77407dab0a1ceDevang Patel ++CurInst; 2682412a4469746d468c46b7e7e4f1c77407dab0a1ceDevang Patel continue; 2683412a4469746d468c46b7e7e4f1c77407dab0a1ceDevang Patel } 2684412a4469746d468c46b7e7e4f1c77407dab0a1ceDevang Patel 26857cd580f0b7cf5f49ccd75bb747d6627292c8fe73Chris Lattner // Cannot handle inline asm. 2686132bd9ce56e1f6d0231c34acec738a8bc92c9cfaNick Lewycky if (isa<InlineAsm>(CS.getCalledValue())) return false; 26877cd580f0b7cf5f49ccd75bb747d6627292c8fe73Chris Lattner 268881266c5c9358d71331886a98e750ac9409cc640cNick Lewycky if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(CS.getInstruction())) { 268981266c5c9358d71331886a98e750ac9409cc640cNick Lewycky if (MemSetInst *MSI = dyn_cast<MemSetInst>(II)) { 269081266c5c9358d71331886a98e750ac9409cc640cNick Lewycky if (MSI->isVolatile()) return false; 269123ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky Constant *Ptr = getVal(MSI->getDest()); 269223ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky Constant *Val = getVal(MSI->getValue()); 269323ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky Constant *DestVal = ComputeLoadResult(getVal(Ptr)); 269481266c5c9358d71331886a98e750ac9409cc640cNick Lewycky if (Val->isNullValue() && DestVal && DestVal->isNullValue()) { 269581266c5c9358d71331886a98e750ac9409cc640cNick Lewycky // This memset is a no-op. 269681266c5c9358d71331886a98e750ac9409cc640cNick Lewycky ++CurInst; 269781266c5c9358d71331886a98e750ac9409cc640cNick Lewycky continue; 269881266c5c9358d71331886a98e750ac9409cc640cNick Lewycky } 269981266c5c9358d71331886a98e750ac9409cc640cNick Lewycky } 270081266c5c9358d71331886a98e750ac9409cc640cNick Lewycky 270181266c5c9358d71331886a98e750ac9409cc640cNick Lewycky if (II->getIntrinsicID() == Intrinsic::lifetime_start || 270281266c5c9358d71331886a98e750ac9409cc640cNick Lewycky II->getIntrinsicID() == Intrinsic::lifetime_end) { 270381266c5c9358d71331886a98e750ac9409cc640cNick Lewycky ++CurInst; 270481266c5c9358d71331886a98e750ac9409cc640cNick Lewycky continue; 270581266c5c9358d71331886a98e750ac9409cc640cNick Lewycky } 270681266c5c9358d71331886a98e750ac9409cc640cNick Lewycky 270781266c5c9358d71331886a98e750ac9409cc640cNick Lewycky if (II->getIntrinsicID() == Intrinsic::invariant_start) { 270881266c5c9358d71331886a98e750ac9409cc640cNick Lewycky // We don't insert an entry into Values, as it doesn't have a 270981266c5c9358d71331886a98e750ac9409cc640cNick Lewycky // meaningful return value. 271081266c5c9358d71331886a98e750ac9409cc640cNick Lewycky if (!II->use_empty()) 271181266c5c9358d71331886a98e750ac9409cc640cNick Lewycky return false; 271281266c5c9358d71331886a98e750ac9409cc640cNick Lewycky ConstantInt *Size = cast<ConstantInt>(II->getArgOperand(0)); 27130ef0557ab5cd11f56c16e82551d4f3b58bb2507aNick Lewycky Value *PtrArg = getVal(II->getArgOperand(1)); 27140ef0557ab5cd11f56c16e82551d4f3b58bb2507aNick Lewycky Value *Ptr = PtrArg->stripPointerCasts(); 27150ef0557ab5cd11f56c16e82551d4f3b58bb2507aNick Lewycky if (GlobalVariable *GV = dyn_cast<GlobalVariable>(Ptr)) { 27160ef0557ab5cd11f56c16e82551d4f3b58bb2507aNick Lewycky Type *ElemTy = cast<PointerType>(GV->getType())->getElementType(); 27170ef0557ab5cd11f56c16e82551d4f3b58bb2507aNick Lewycky if (!Size->isAllOnesValue() && 27180ef0557ab5cd11f56c16e82551d4f3b58bb2507aNick Lewycky Size->getValue().getLimitedValue() >= 27190ef0557ab5cd11f56c16e82551d4f3b58bb2507aNick Lewycky TD->getTypeStoreSize(ElemTy)) 272081266c5c9358d71331886a98e750ac9409cc640cNick Lewycky Invariants.insert(GV); 272181266c5c9358d71331886a98e750ac9409cc640cNick Lewycky } 272281266c5c9358d71331886a98e750ac9409cc640cNick Lewycky // Continue even if we do nothing. 27231f237b00279ada1ccce35ab924a7f797d9dea25dNick Lewycky ++CurInst; 27241f237b00279ada1ccce35ab924a7f797d9dea25dNick Lewycky continue; 27251f237b00279ada1ccce35ab924a7f797d9dea25dNick Lewycky } 27261f237b00279ada1ccce35ab924a7f797d9dea25dNick Lewycky return false; 27271f237b00279ada1ccce35ab924a7f797d9dea25dNick Lewycky } 27281f237b00279ada1ccce35ab924a7f797d9dea25dNick Lewycky 2729cd27142cc8d09dcab8110a7ef31e5cd6767d8b93Chris Lattner // Resolve function pointers. 273023ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky Function *Callee = dyn_cast<Function>(getVal(CS.getCalledValue())); 2731132bd9ce56e1f6d0231c34acec738a8bc92c9cfaNick Lewycky if (!Callee || Callee->mayBeOverridden()) 2732132bd9ce56e1f6d0231c34acec738a8bc92c9cfaNick Lewycky return false; // Cannot resolve. 2733a9ec8ab32bce9021c9501b45eea6bbc76ffeb207Chris Lattner 2734fa6a1cf1ed4282145269b12578f687b3869d6476Duncan Sands SmallVector<Constant*, 8> Formals; 2735132bd9ce56e1f6d0231c34acec738a8bc92c9cfaNick Lewycky for (User::op_iterator i = CS.arg_begin(), e = CS.arg_end(); i != e; ++i) 273623ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky Formals.push_back(getVal(*i)); 2737fa6a1cf1ed4282145269b12578f687b3869d6476Duncan Sands 27385cbf985dcbc89fba3208e7baf8b6f488b06d3ec9Reid Spencer if (Callee->isDeclaration()) { 2739a9ec8ab32bce9021c9501b45eea6bbc76ffeb207Chris Lattner // If this is a function we can constant fold, do it. 274000737bdb488cc7157ca5f7a40d6cd8467ad09a79Chad Rosier if (Constant *C = ConstantFoldCall(Callee, Formals, TLI)) { 2741a9ec8ab32bce9021c9501b45eea6bbc76ffeb207Chris Lattner InstResult = C; 2742a9ec8ab32bce9021c9501b45eea6bbc76ffeb207Chris Lattner } else { 2743a9ec8ab32bce9021c9501b45eea6bbc76ffeb207Chris Lattner return false; 2744a9ec8ab32bce9021c9501b45eea6bbc76ffeb207Chris Lattner } 2745a9ec8ab32bce9021c9501b45eea6bbc76ffeb207Chris Lattner } else { 2746a9ec8ab32bce9021c9501b45eea6bbc76ffeb207Chris Lattner if (Callee->getFunctionType()->isVarArg()) 2747a9ec8ab32bce9021c9501b45eea6bbc76ffeb207Chris Lattner return false; 27489d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 2749a9ec8ab32bce9021c9501b45eea6bbc76ffeb207Chris Lattner Constant *RetVal; 2750a9ec8ab32bce9021c9501b45eea6bbc76ffeb207Chris Lattner // Execute the call, if successful, use the return value. 275123ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky ValueStack.push_back(new DenseMap<Value*, Constant*>); 275223ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky if (!EvaluateFunction(Callee, RetVal, Formals)) 2753a9ec8ab32bce9021c9501b45eea6bbc76ffeb207Chris Lattner return false; 27543bbf2b6548340bb9218836f991da8c3a4718f6dbBenjamin Kramer delete ValueStack.pop_back_val(); 2755a9ec8ab32bce9021c9501b45eea6bbc76ffeb207Chris Lattner InstResult = RetVal; 2756a9ec8ab32bce9021c9501b45eea6bbc76ffeb207Chris Lattner } 27573ed469ccd7b028a030b550d84b7336d146f5d8faReid Spencer } else if (isa<TerminatorInst>(CurInst)) { 2758cdf98bed968ff76b8f310a2adae5811f5ba88ec4Chris Lattner if (BranchInst *BI = dyn_cast<BranchInst>(CurInst)) { 2759cdf98bed968ff76b8f310a2adae5811f5ba88ec4Chris Lattner if (BI->isUnconditional()) { 2760da82fd411ec37bc81a1e584d2f3163aeda4d2e95Nick Lewycky NextBB = BI->getSuccessor(0); 2761cdf98bed968ff76b8f310a2adae5811f5ba88ec4Chris Lattner } else { 27626b6b6ef1677fa71b1072c2911b4c1f9524a558c9Zhou Sheng ConstantInt *Cond = 276323ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky dyn_cast<ConstantInt>(getVal(BI->getCondition())); 276497d1fad3d2e5aac2a89beacc3961ff9451841248Chris Lattner if (!Cond) return false; // Cannot determine. 27656b6b6ef1677fa71b1072c2911b4c1f9524a558c9Zhou Sheng 2766da82fd411ec37bc81a1e584d2f3163aeda4d2e95Nick Lewycky NextBB = BI->getSuccessor(!Cond->getZExtValue()); 2767cdf98bed968ff76b8f310a2adae5811f5ba88ec4Chris Lattner } 2768cdf98bed968ff76b8f310a2adae5811f5ba88ec4Chris Lattner } else if (SwitchInst *SI = dyn_cast<SwitchInst>(CurInst)) { 2769cdf98bed968ff76b8f310a2adae5811f5ba88ec4Chris Lattner ConstantInt *Val = 277023ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky dyn_cast<ConstantInt>(getVal(SI->getCondition())); 2771cd27142cc8d09dcab8110a7ef31e5cd6767d8b93Chris Lattner if (!Val) return false; // Cannot determine. 2772c10fa6c801e48771b5eade50afc2fe6abaf08227Stepan Dyatkovskiy NextBB = SI->findCaseValue(Val).getCaseSuccessor(); 2773b3d5a65d94ca017570fe86578423186c6a2f642eChris Lattner } else if (IndirectBrInst *IBI = dyn_cast<IndirectBrInst>(CurInst)) { 277423ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky Value *Val = getVal(IBI->getAddress())->stripPointerCasts(); 2775b3d5a65d94ca017570fe86578423186c6a2f642eChris Lattner if (BlockAddress *BA = dyn_cast<BlockAddress>(Val)) 2776da82fd411ec37bc81a1e584d2f3163aeda4d2e95Nick Lewycky NextBB = BA->getBasicBlock(); 2777cdfc940912d56a63b6f12eaa7f3faf79cf74c693Chris Lattner else 2778cdfc940912d56a63b6f12eaa7f3faf79cf74c693Chris Lattner return false; // Cannot determine. 2779da82fd411ec37bc81a1e584d2f3163aeda4d2e95Nick Lewycky } else if (isa<ReturnInst>(CurInst)) { 2780da82fd411ec37bc81a1e584d2f3163aeda4d2e95Nick Lewycky NextBB = 0; 2781cdf98bed968ff76b8f310a2adae5811f5ba88ec4Chris Lattner } else { 2782dccc03b2423fe65efb5963ae816b99c24fc53374Bill Wendling // invoke, unwind, resume, unreachable. 2783cd27142cc8d09dcab8110a7ef31e5cd6767d8b93Chris Lattner return false; // Cannot handle this terminator. 2784cdf98bed968ff76b8f310a2adae5811f5ba88ec4Chris Lattner } 27859d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 2786da82fd411ec37bc81a1e584d2f3163aeda4d2e95Nick Lewycky // We succeeded at evaluating this block! 2787da82fd411ec37bc81a1e584d2f3163aeda4d2e95Nick Lewycky return true; 278879c1101947101ff1585a38dc69d1f1079d44bb04Chris Lattner } else { 278979c1101947101ff1585a38dc69d1f1079d44bb04Chris Lattner // Did not know how to evaluate this! 2790cd27142cc8d09dcab8110a7ef31e5cd6767d8b93Chris Lattner return false; 279179c1101947101ff1585a38dc69d1f1079d44bb04Chris Lattner } 27929d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 27931945d58025203aec7883c11ac51b827d440f6916Chris Lattner if (!CurInst->use_empty()) { 27941945d58025203aec7883c11ac51b827d440f6916Chris Lattner if (ConstantExpr *CE = dyn_cast<ConstantExpr>(InstResult)) 2795aab8e28d5e470711d80276bbf717408c3ab966fdChad Rosier InstResult = ConstantFoldConstantExpression(CE, TD, TLI); 27961945d58025203aec7883c11ac51b827d440f6916Chris Lattner 279723ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky setVal(CurInst, InstResult); 27981945d58025203aec7883c11ac51b827d440f6916Chris Lattner } 27999d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 2800f1ce79f3c359bf33c2f30a74625a9babc3cc2a48Dan Gohman // If we just processed an invoke, we finished evaluating the block. 2801f1ce79f3c359bf33c2f30a74625a9babc3cc2a48Dan Gohman if (InvokeInst *II = dyn_cast<InvokeInst>(CurInst)) { 2802f1ce79f3c359bf33c2f30a74625a9babc3cc2a48Dan Gohman NextBB = II->getNormalDest(); 2803f1ce79f3c359bf33c2f30a74625a9babc3cc2a48Dan Gohman return true; 2804f1ce79f3c359bf33c2f30a74625a9babc3cc2a48Dan Gohman } 2805f1ce79f3c359bf33c2f30a74625a9babc3cc2a48Dan Gohman 280679c1101947101ff1585a38dc69d1f1079d44bb04Chris Lattner // Advance program counter. 280779c1101947101ff1585a38dc69d1f1079d44bb04Chris Lattner ++CurInst; 280879c1101947101ff1585a38dc69d1f1079d44bb04Chris Lattner } 28098a7cc6e71ca9bedf97abfae2ec9a5e9af212dc15Chris Lattner} 28108a7cc6e71ca9bedf97abfae2ec9a5e9af212dc15Chris Lattner 2811da82fd411ec37bc81a1e584d2f3163aeda4d2e95Nick Lewycky/// EvaluateFunction - Evaluate a call to function F, returning true if 2812da82fd411ec37bc81a1e584d2f3163aeda4d2e95Nick Lewycky/// successful, false if we can't evaluate it. ActualArgs contains the formal 2813da82fd411ec37bc81a1e584d2f3163aeda4d2e95Nick Lewycky/// arguments for the function. 28147fa767770574ba0312165ac9ed08f792b8fb7874Nick Lewyckybool Evaluator::EvaluateFunction(Function *F, Constant *&RetVal, 28157fa767770574ba0312165ac9ed08f792b8fb7874Nick Lewycky const SmallVectorImpl<Constant*> &ActualArgs) { 2816da82fd411ec37bc81a1e584d2f3163aeda4d2e95Nick Lewycky // Check to see if this function is already executing (recursion). If so, 2817da82fd411ec37bc81a1e584d2f3163aeda4d2e95Nick Lewycky // bail out. TODO: we might want to accept limited recursion. 2818da82fd411ec37bc81a1e584d2f3163aeda4d2e95Nick Lewycky if (std::find(CallStack.begin(), CallStack.end(), F) != CallStack.end()) 2819da82fd411ec37bc81a1e584d2f3163aeda4d2e95Nick Lewycky return false; 2820da82fd411ec37bc81a1e584d2f3163aeda4d2e95Nick Lewycky 2821da82fd411ec37bc81a1e584d2f3163aeda4d2e95Nick Lewycky CallStack.push_back(F); 2822da82fd411ec37bc81a1e584d2f3163aeda4d2e95Nick Lewycky 2823da82fd411ec37bc81a1e584d2f3163aeda4d2e95Nick Lewycky // Initialize arguments to the incoming values specified. 2824da82fd411ec37bc81a1e584d2f3163aeda4d2e95Nick Lewycky unsigned ArgNo = 0; 2825da82fd411ec37bc81a1e584d2f3163aeda4d2e95Nick Lewycky for (Function::arg_iterator AI = F->arg_begin(), E = F->arg_end(); AI != E; 2826da82fd411ec37bc81a1e584d2f3163aeda4d2e95Nick Lewycky ++AI, ++ArgNo) 282723ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky setVal(AI, ActualArgs[ArgNo]); 2828da82fd411ec37bc81a1e584d2f3163aeda4d2e95Nick Lewycky 2829da82fd411ec37bc81a1e584d2f3163aeda4d2e95Nick Lewycky // ExecutedBlocks - We only handle non-looping, non-recursive code. As such, 2830da82fd411ec37bc81a1e584d2f3163aeda4d2e95Nick Lewycky // we can only evaluate any one basic block at most once. This set keeps 2831da82fd411ec37bc81a1e584d2f3163aeda4d2e95Nick Lewycky // track of what we have executed so we can detect recursive cases etc. 2832da82fd411ec37bc81a1e584d2f3163aeda4d2e95Nick Lewycky SmallPtrSet<BasicBlock*, 32> ExecutedBlocks; 2833da82fd411ec37bc81a1e584d2f3163aeda4d2e95Nick Lewycky 2834da82fd411ec37bc81a1e584d2f3163aeda4d2e95Nick Lewycky // CurBB - The current basic block we're evaluating. 2835da82fd411ec37bc81a1e584d2f3163aeda4d2e95Nick Lewycky BasicBlock *CurBB = F->begin(); 2836da82fd411ec37bc81a1e584d2f3163aeda4d2e95Nick Lewycky 28378e4ba6b954d58bd60b342770dfca62de4cf4eb6eNick Lewycky BasicBlock::iterator CurInst = CurBB->begin(); 28388e4ba6b954d58bd60b342770dfca62de4cf4eb6eNick Lewycky 2839da82fd411ec37bc81a1e584d2f3163aeda4d2e95Nick Lewycky while (1) { 28404b794f81917d2799225a9d1951729f1798431f81Duncan Sands BasicBlock *NextBB = 0; // Initialized to avoid compiler warnings. 284123ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky if (!EvaluateBlock(CurInst, NextBB)) 2842da82fd411ec37bc81a1e584d2f3163aeda4d2e95Nick Lewycky return false; 2843da82fd411ec37bc81a1e584d2f3163aeda4d2e95Nick Lewycky 2844da82fd411ec37bc81a1e584d2f3163aeda4d2e95Nick Lewycky if (NextBB == 0) { 2845da82fd411ec37bc81a1e584d2f3163aeda4d2e95Nick Lewycky // Successfully running until there's no next block means that we found 2846da82fd411ec37bc81a1e584d2f3163aeda4d2e95Nick Lewycky // the return. Fill it the return value and pop the call stack. 2847da82fd411ec37bc81a1e584d2f3163aeda4d2e95Nick Lewycky ReturnInst *RI = cast<ReturnInst>(CurBB->getTerminator()); 2848da82fd411ec37bc81a1e584d2f3163aeda4d2e95Nick Lewycky if (RI->getNumOperands()) 284923ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky RetVal = getVal(RI->getOperand(0)); 2850da82fd411ec37bc81a1e584d2f3163aeda4d2e95Nick Lewycky CallStack.pop_back(); 2851da82fd411ec37bc81a1e584d2f3163aeda4d2e95Nick Lewycky return true; 2852da82fd411ec37bc81a1e584d2f3163aeda4d2e95Nick Lewycky } 2853da82fd411ec37bc81a1e584d2f3163aeda4d2e95Nick Lewycky 2854da82fd411ec37bc81a1e584d2f3163aeda4d2e95Nick Lewycky // Okay, we succeeded in evaluating this control flow. See if we have 2855da82fd411ec37bc81a1e584d2f3163aeda4d2e95Nick Lewycky // executed the new block before. If so, we have a looping function, 2856da82fd411ec37bc81a1e584d2f3163aeda4d2e95Nick Lewycky // which we cannot evaluate in reasonable time. 2857da82fd411ec37bc81a1e584d2f3163aeda4d2e95Nick Lewycky if (!ExecutedBlocks.insert(NextBB)) 2858da82fd411ec37bc81a1e584d2f3163aeda4d2e95Nick Lewycky return false; // looped! 2859da82fd411ec37bc81a1e584d2f3163aeda4d2e95Nick Lewycky 2860da82fd411ec37bc81a1e584d2f3163aeda4d2e95Nick Lewycky // Okay, we have never been in this block before. Check to see if there 2861da82fd411ec37bc81a1e584d2f3163aeda4d2e95Nick Lewycky // are any PHI nodes. If so, evaluate them with information about where 2862da82fd411ec37bc81a1e584d2f3163aeda4d2e95Nick Lewycky // we came from. 2863da82fd411ec37bc81a1e584d2f3163aeda4d2e95Nick Lewycky PHINode *PN = 0; 28648e4ba6b954d58bd60b342770dfca62de4cf4eb6eNick Lewycky for (CurInst = NextBB->begin(); 28658e4ba6b954d58bd60b342770dfca62de4cf4eb6eNick Lewycky (PN = dyn_cast<PHINode>(CurInst)); ++CurInst) 286623ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky setVal(PN, getVal(PN->getIncomingValueForBlock(CurBB))); 2867da82fd411ec37bc81a1e584d2f3163aeda4d2e95Nick Lewycky 2868da82fd411ec37bc81a1e584d2f3163aeda4d2e95Nick Lewycky // Advance to the next block. 2869da82fd411ec37bc81a1e584d2f3163aeda4d2e95Nick Lewycky CurBB = NextBB; 2870da82fd411ec37bc81a1e584d2f3163aeda4d2e95Nick Lewycky } 2871da82fd411ec37bc81a1e584d2f3163aeda4d2e95Nick Lewycky} 2872da82fd411ec37bc81a1e584d2f3163aeda4d2e95Nick Lewycky 28738a7cc6e71ca9bedf97abfae2ec9a5e9af212dc15Chris Lattner/// EvaluateStaticConstructor - Evaluate static constructors in the function, if 28748a7cc6e71ca9bedf97abfae2ec9a5e9af212dc15Chris Lattner/// we can. Return true if we can, false otherwise. 287500737bdb488cc7157ca5f7a40d6cd8467ad09a79Chad Rosierstatic bool EvaluateStaticConstructor(Function *F, const TargetData *TD, 287600737bdb488cc7157ca5f7a40d6cd8467ad09a79Chad Rosier const TargetLibraryInfo *TLI) { 28778a7cc6e71ca9bedf97abfae2ec9a5e9af212dc15Chris Lattner // Call the function. 28787fa767770574ba0312165ac9ed08f792b8fb7874Nick Lewycky Evaluator Eval(TD, TLI); 2879cd27142cc8d09dcab8110a7ef31e5cd6767d8b93Chris Lattner Constant *RetValDummy; 288023ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky bool EvalSuccess = Eval.EvaluateFunction(F, RetValDummy, 288123ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky SmallVector<Constant*, 0>()); 28821945d58025203aec7883c11ac51b827d440f6916Chris Lattner 28838a7cc6e71ca9bedf97abfae2ec9a5e9af212dc15Chris Lattner if (EvalSuccess) { 2884a22fdb0a37f935fc3e3391d47d64267a92cfc2e8Chris Lattner // We succeeded at evaluation: commit the result. 28853215b0ee8248ca1e4bc2c7e2f5fd3ce120c3ee45David Greene DEBUG(dbgs() << "FULLY EVALUATED GLOBAL CTOR FUNCTION '" 288623ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky << F->getName() << "' to " << Eval.getMutatedMemory().size() 2887ce63ffb52f249b62cdf2d250c128007b13f27e71Daniel Dunbar << " stores.\n"); 288823ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky for (DenseMap<Constant*, Constant*>::const_iterator I = 288923ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky Eval.getMutatedMemory().begin(), E = Eval.getMutatedMemory().end(); 28903eab3c4d40e381d2c2eed93a423cb67e97ad718fNick Lewycky I != E; ++I) 28917b550ccfc5a3346c17e0390a59e2d6d19bc52705Chris Lattner CommitValueTo(I->second, I->first); 289223ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky for (SmallPtrSet<GlobalVariable*, 8>::const_iterator I = 289323ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky Eval.getInvariants().begin(), E = Eval.getInvariants().end(); 289423ec5d7759ed9a3b52fc8c470695248a1719cce8Nick Lewycky I != E; ++I) 289581266c5c9358d71331886a98e750ac9409cc640cNick Lewycky (*I)->setConstant(true); 2896a22fdb0a37f935fc3e3391d47d64267a92cfc2e8Chris Lattner } 28979d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 28988a7cc6e71ca9bedf97abfae2ec9a5e9af212dc15Chris Lattner return EvalSuccess; 289979c1101947101ff1585a38dc69d1f1079d44bb04Chris Lattner} 290079c1101947101ff1585a38dc69d1f1079d44bb04Chris Lattner 2901db973e60ced33cfa0332462b1a2d5ae1ae15ad25Chris Lattner/// OptimizeGlobalCtorsList - Simplify and evaluation global ctors if possible. 2902db973e60ced33cfa0332462b1a2d5ae1ae15ad25Chris Lattner/// Return true if anything changed. 2903db973e60ced33cfa0332462b1a2d5ae1ae15ad25Chris Lattnerbool GlobalOpt::OptimizeGlobalCtorsList(GlobalVariable *&GCL) { 2904db973e60ced33cfa0332462b1a2d5ae1ae15ad25Chris Lattner std::vector<Function*> Ctors = ParseGlobalCtors(GCL); 2905db973e60ced33cfa0332462b1a2d5ae1ae15ad25Chris Lattner bool MadeChange = false; 2906db973e60ced33cfa0332462b1a2d5ae1ae15ad25Chris Lattner if (Ctors.empty()) return false; 29079d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 2908db973e60ced33cfa0332462b1a2d5ae1ae15ad25Chris Lattner // Loop over global ctors, optimizing them when we can. 2909db973e60ced33cfa0332462b1a2d5ae1ae15ad25Chris Lattner for (unsigned i = 0; i != Ctors.size(); ++i) { 2910db973e60ced33cfa0332462b1a2d5ae1ae15ad25Chris Lattner Function *F = Ctors[i]; 2911db973e60ced33cfa0332462b1a2d5ae1ae15ad25Chris Lattner // Found a null terminator in the middle of the list, prune off the rest of 2912db973e60ced33cfa0332462b1a2d5ae1ae15ad25Chris Lattner // the list. 2913db973e60ced33cfa0332462b1a2d5ae1ae15ad25Chris Lattner if (F == 0) { 2914db973e60ced33cfa0332462b1a2d5ae1ae15ad25Chris Lattner if (i != Ctors.size()-1) { 2915db973e60ced33cfa0332462b1a2d5ae1ae15ad25Chris Lattner Ctors.resize(i+1); 2916db973e60ced33cfa0332462b1a2d5ae1ae15ad25Chris Lattner MadeChange = true; 2917db973e60ced33cfa0332462b1a2d5ae1ae15ad25Chris Lattner } 2918db973e60ced33cfa0332462b1a2d5ae1ae15ad25Chris Lattner break; 2919db973e60ced33cfa0332462b1a2d5ae1ae15ad25Chris Lattner } 29209d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 292179c1101947101ff1585a38dc69d1f1079d44bb04Chris Lattner // We cannot simplify external ctor functions. 292279c1101947101ff1585a38dc69d1f1079d44bb04Chris Lattner if (F->empty()) continue; 29239d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 292479c1101947101ff1585a38dc69d1f1079d44bb04Chris Lattner // If we can evaluate the ctor at compile time, do. 292500737bdb488cc7157ca5f7a40d6cd8467ad09a79Chad Rosier if (EvaluateStaticConstructor(F, TD, TLI)) { 292679c1101947101ff1585a38dc69d1f1079d44bb04Chris Lattner Ctors.erase(Ctors.begin()+i); 292779c1101947101ff1585a38dc69d1f1079d44bb04Chris Lattner MadeChange = true; 292879c1101947101ff1585a38dc69d1f1079d44bb04Chris Lattner --i; 292979c1101947101ff1585a38dc69d1f1079d44bb04Chris Lattner ++NumCtorsEvaluated; 293079c1101947101ff1585a38dc69d1f1079d44bb04Chris Lattner continue; 293179c1101947101ff1585a38dc69d1f1079d44bb04Chris Lattner } 2932db973e60ced33cfa0332462b1a2d5ae1ae15ad25Chris Lattner } 29339d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 2934db973e60ced33cfa0332462b1a2d5ae1ae15ad25Chris Lattner if (!MadeChange) return false; 29359d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 29367b550ccfc5a3346c17e0390a59e2d6d19bc52705Chris Lattner GCL = InstallGlobalCtors(GCL, Ctors); 2937b1ab4580478c90375abec5e2b6e89dc1a15fa98bChris Lattner return true; 2938b1ab4580478c90375abec5e2b6e89dc1a15fa98bChris Lattner} 2939b1ab4580478c90375abec5e2b6e89dc1a15fa98bChris Lattner 2940fc5940d2a09a795e683ae86b237d6f55fb3551d4Duncan Sandsbool GlobalOpt::OptimizeGlobalAliases(Module &M) { 2941e4c6b61ebd8f2dbb6a2e51fe1d0e2bdbe17986c4Anton Korobeynikov bool Changed = false; 2942e4c6b61ebd8f2dbb6a2e51fe1d0e2bdbe17986c4Anton Korobeynikov 2943177d84e048d3c0b94ff2d2ff1a9bda8d498c1397Duncan Sands for (Module::alias_iterator I = M.alias_begin(), E = M.alias_end(); 29444782b305c2ccc2b2e5a4cad65d7ffd15395d0727Duncan Sands I != E;) { 29454782b305c2ccc2b2e5a4cad65d7ffd15395d0727Duncan Sands Module::alias_iterator J = I++; 2946fc5940d2a09a795e683ae86b237d6f55fb3551d4Duncan Sands // Aliases without names cannot be referenced outside this module. 2947fc5940d2a09a795e683ae86b237d6f55fb3551d4Duncan Sands if (!J->hasName() && !J->isDeclaration()) 2948fc5940d2a09a795e683ae86b237d6f55fb3551d4Duncan Sands J->setLinkage(GlobalValue::InternalLinkage); 29494782b305c2ccc2b2e5a4cad65d7ffd15395d0727Duncan Sands // If the aliasee may change at link time, nothing can be done - bail out. 29504782b305c2ccc2b2e5a4cad65d7ffd15395d0727Duncan Sands if (J->mayBeOverridden()) 2951e4c6b61ebd8f2dbb6a2e51fe1d0e2bdbe17986c4Anton Korobeynikov continue; 2952e4c6b61ebd8f2dbb6a2e51fe1d0e2bdbe17986c4Anton Korobeynikov 29534782b305c2ccc2b2e5a4cad65d7ffd15395d0727Duncan Sands Constant *Aliasee = J->getAliasee(); 29544782b305c2ccc2b2e5a4cad65d7ffd15395d0727Duncan Sands GlobalValue *Target = cast<GlobalValue>(Aliasee->stripPointerCasts()); 295595c5d0fb0a4e1ec88edae43c2db464e0cc63c76eDuncan Sands Target->removeDeadConstantUsers(); 29564782b305c2ccc2b2e5a4cad65d7ffd15395d0727Duncan Sands bool hasOneUse = Target->hasOneUse() && Aliasee->hasOneUse(); 29574782b305c2ccc2b2e5a4cad65d7ffd15395d0727Duncan Sands 29584782b305c2ccc2b2e5a4cad65d7ffd15395d0727Duncan Sands // Make all users of the alias use the aliasee instead. 29594782b305c2ccc2b2e5a4cad65d7ffd15395d0727Duncan Sands if (!J->use_empty()) { 29604782b305c2ccc2b2e5a4cad65d7ffd15395d0727Duncan Sands J->replaceAllUsesWith(Aliasee); 29614782b305c2ccc2b2e5a4cad65d7ffd15395d0727Duncan Sands ++NumAliasesResolved; 29624782b305c2ccc2b2e5a4cad65d7ffd15395d0727Duncan Sands Changed = true; 29634782b305c2ccc2b2e5a4cad65d7ffd15395d0727Duncan Sands } 29644782b305c2ccc2b2e5a4cad65d7ffd15395d0727Duncan Sands 29657a154cf22830857bc184566102abd8a2ada8df94Duncan Sands // If the alias is externally visible, we may still be able to simplify it. 29667a154cf22830857bc184566102abd8a2ada8df94Duncan Sands if (!J->hasLocalLinkage()) { 29677a154cf22830857bc184566102abd8a2ada8df94Duncan Sands // If the aliasee has internal linkage, give it the name and linkage 29687a154cf22830857bc184566102abd8a2ada8df94Duncan Sands // of the alias, and delete the alias. This turns: 29697a154cf22830857bc184566102abd8a2ada8df94Duncan Sands // define internal ... @f(...) 29707a154cf22830857bc184566102abd8a2ada8df94Duncan Sands // @a = alias ... @f 29717a154cf22830857bc184566102abd8a2ada8df94Duncan Sands // into: 29727a154cf22830857bc184566102abd8a2ada8df94Duncan Sands // define ... @a(...) 29737a154cf22830857bc184566102abd8a2ada8df94Duncan Sands if (!Target->hasLocalLinkage()) 29747a154cf22830857bc184566102abd8a2ada8df94Duncan Sands continue; 29754782b305c2ccc2b2e5a4cad65d7ffd15395d0727Duncan Sands 29767a154cf22830857bc184566102abd8a2ada8df94Duncan Sands // Do not perform the transform if multiple aliases potentially target the 2977272369149209bad11f2b2f9020362f77fae60579Gabor Greif // aliasee. This check also ensures that it is safe to replace the section 29787a154cf22830857bc184566102abd8a2ada8df94Duncan Sands // and other attributes of the aliasee with those of the alias. 29797a154cf22830857bc184566102abd8a2ada8df94Duncan Sands if (!hasOneUse) 29807a154cf22830857bc184566102abd8a2ada8df94Duncan Sands continue; 29814782b305c2ccc2b2e5a4cad65d7ffd15395d0727Duncan Sands 29827a154cf22830857bc184566102abd8a2ada8df94Duncan Sands // Give the aliasee the name, linkage and other attributes of the alias. 29837a154cf22830857bc184566102abd8a2ada8df94Duncan Sands Target->takeName(J); 29847a154cf22830857bc184566102abd8a2ada8df94Duncan Sands Target->setLinkage(J->getLinkage()); 29857a154cf22830857bc184566102abd8a2ada8df94Duncan Sands Target->GlobalValue::copyAttributesFrom(J); 29867a154cf22830857bc184566102abd8a2ada8df94Duncan Sands } 29874782b305c2ccc2b2e5a4cad65d7ffd15395d0727Duncan Sands 29884782b305c2ccc2b2e5a4cad65d7ffd15395d0727Duncan Sands // Delete the alias. 29894782b305c2ccc2b2e5a4cad65d7ffd15395d0727Duncan Sands M.getAliasList().erase(J); 29904782b305c2ccc2b2e5a4cad65d7ffd15395d0727Duncan Sands ++NumAliasesRemoved; 29914782b305c2ccc2b2e5a4cad65d7ffd15395d0727Duncan Sands Changed = true; 2992e4c6b61ebd8f2dbb6a2e51fe1d0e2bdbe17986c4Anton Korobeynikov } 2993e4c6b61ebd8f2dbb6a2e51fe1d0e2bdbe17986c4Anton Korobeynikov 2994e4c6b61ebd8f2dbb6a2e51fe1d0e2bdbe17986c4Anton Korobeynikov return Changed; 2995e4c6b61ebd8f2dbb6a2e51fe1d0e2bdbe17986c4Anton Korobeynikov} 2996b1ab4580478c90375abec5e2b6e89dc1a15fa98bChris Lattner 29976a7df9aae620801d97da72d718e9aff76eebac9bNick Lewyckystatic Function *FindCXAAtExit(Module &M, TargetLibraryInfo *TLI) { 29986a7df9aae620801d97da72d718e9aff76eebac9bNick Lewycky if (!TLI->has(LibFunc::cxa_atexit)) 29996f160d3d78c1b7839b6bc053339e1fdfbf0276deNick Lewycky return 0; 30006a7df9aae620801d97da72d718e9aff76eebac9bNick Lewycky 30016a7df9aae620801d97da72d718e9aff76eebac9bNick Lewycky Function *Fn = M.getFunction(TLI->getName(LibFunc::cxa_atexit)); 3002a201c4c2e604a519665ca55dc49e913628444ddbAnders Carlsson 3003a201c4c2e604a519665ca55dc49e913628444ddbAnders Carlsson if (!Fn) 3004a201c4c2e604a519665ca55dc49e913628444ddbAnders Carlsson return 0; 30056a7df9aae620801d97da72d718e9aff76eebac9bNick Lewycky 3006db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner FunctionType *FTy = Fn->getFunctionType(); 3007a201c4c2e604a519665ca55dc49e913628444ddbAnders Carlsson 30081f7c7ba380cf411fd02a070822c439fadac91ce6Anders Carlsson // Checking that the function has the right return type, the right number of 30091f7c7ba380cf411fd02a070822c439fadac91ce6Anders Carlsson // parameters and that they all have pointer types should be enough. 30101f7c7ba380cf411fd02a070822c439fadac91ce6Anders Carlsson if (!FTy->getReturnType()->isIntegerTy() || 30111f7c7ba380cf411fd02a070822c439fadac91ce6Anders Carlsson FTy->getNumParams() != 3 || 3012a201c4c2e604a519665ca55dc49e913628444ddbAnders Carlsson !FTy->getParamType(0)->isPointerTy() || 3013a201c4c2e604a519665ca55dc49e913628444ddbAnders Carlsson !FTy->getParamType(1)->isPointerTy() || 3014a201c4c2e604a519665ca55dc49e913628444ddbAnders Carlsson !FTy->getParamType(2)->isPointerTy()) 3015a201c4c2e604a519665ca55dc49e913628444ddbAnders Carlsson return 0; 3016a201c4c2e604a519665ca55dc49e913628444ddbAnders Carlsson 3017a201c4c2e604a519665ca55dc49e913628444ddbAnders Carlsson return Fn; 3018a201c4c2e604a519665ca55dc49e913628444ddbAnders Carlsson} 3019a201c4c2e604a519665ca55dc49e913628444ddbAnders Carlsson 3020a201c4c2e604a519665ca55dc49e913628444ddbAnders Carlsson/// cxxDtorIsEmpty - Returns whether the given function is an empty C++ 3021a201c4c2e604a519665ca55dc49e913628444ddbAnders Carlsson/// destructor and can therefore be eliminated. 3022a201c4c2e604a519665ca55dc49e913628444ddbAnders Carlsson/// Note that we assume that other optimization passes have already simplified 3023a201c4c2e604a519665ca55dc49e913628444ddbAnders Carlsson/// the code so we only look for a function with a single basic block, where 3024c1322a13b5b3a4e4f5017deeb27d85ac41f7a839Benjamin Kramer/// the only allowed instructions are 'ret', 'call' to an empty C++ dtor and 3025c1322a13b5b3a4e4f5017deeb27d85ac41f7a839Benjamin Kramer/// other side-effect free instructions. 3026372ec6aa915534f3b11c252dbc9e6c63814bcab3Anders Carlssonstatic bool cxxDtorIsEmpty(const Function &Fn, 3027372ec6aa915534f3b11c252dbc9e6c63814bcab3Anders Carlsson SmallPtrSet<const Function *, 8> &CalledFunctions) { 30281f7c7ba380cf411fd02a070822c439fadac91ce6Anders Carlsson // FIXME: We could eliminate C++ destructors if they're readonly/readnone and 302935ee1c921c55ced16748b90c486c9feeb433c74bNick Lewycky // nounwind, but that doesn't seem worth doing. 30301f7c7ba380cf411fd02a070822c439fadac91ce6Anders Carlsson if (Fn.isDeclaration()) 30311f7c7ba380cf411fd02a070822c439fadac91ce6Anders Carlsson return false; 3032a201c4c2e604a519665ca55dc49e913628444ddbAnders Carlsson 3033a201c4c2e604a519665ca55dc49e913628444ddbAnders Carlsson if (++Fn.begin() != Fn.end()) 3034a201c4c2e604a519665ca55dc49e913628444ddbAnders Carlsson return false; 3035a201c4c2e604a519665ca55dc49e913628444ddbAnders Carlsson 3036a201c4c2e604a519665ca55dc49e913628444ddbAnders Carlsson const BasicBlock &EntryBlock = Fn.getEntryBlock(); 3037a201c4c2e604a519665ca55dc49e913628444ddbAnders Carlsson for (BasicBlock::const_iterator I = EntryBlock.begin(), E = EntryBlock.end(); 3038a201c4c2e604a519665ca55dc49e913628444ddbAnders Carlsson I != E; ++I) { 3039a201c4c2e604a519665ca55dc49e913628444ddbAnders Carlsson if (const CallInst *CI = dyn_cast<CallInst>(I)) { 3040b12caf31f43eefc399eb2584225924d22cfd5b28Anders Carlsson // Ignore debug intrinsics. 3041b12caf31f43eefc399eb2584225924d22cfd5b28Anders Carlsson if (isa<DbgInfoIntrinsic>(CI)) 3042b12caf31f43eefc399eb2584225924d22cfd5b28Anders Carlsson continue; 3043b12caf31f43eefc399eb2584225924d22cfd5b28Anders Carlsson 3044a201c4c2e604a519665ca55dc49e913628444ddbAnders Carlsson const Function *CalledFn = CI->getCalledFunction(); 3045a201c4c2e604a519665ca55dc49e913628444ddbAnders Carlsson 3046a201c4c2e604a519665ca55dc49e913628444ddbAnders Carlsson if (!CalledFn) 3047a201c4c2e604a519665ca55dc49e913628444ddbAnders Carlsson return false; 3048a201c4c2e604a519665ca55dc49e913628444ddbAnders Carlsson 3049807bc2a3814bb45b38702785ad9978153d176698Anders Carlsson SmallPtrSet<const Function *, 8> NewCalledFunctions(CalledFunctions); 3050807bc2a3814bb45b38702785ad9978153d176698Anders Carlsson 30511f7c7ba380cf411fd02a070822c439fadac91ce6Anders Carlsson // Don't treat recursive functions as empty. 3052807bc2a3814bb45b38702785ad9978153d176698Anders Carlsson if (!NewCalledFunctions.insert(CalledFn)) 30531f7c7ba380cf411fd02a070822c439fadac91ce6Anders Carlsson return false; 30541f7c7ba380cf411fd02a070822c439fadac91ce6Anders Carlsson 3055807bc2a3814bb45b38702785ad9978153d176698Anders Carlsson if (!cxxDtorIsEmpty(*CalledFn, NewCalledFunctions)) 3056a201c4c2e604a519665ca55dc49e913628444ddbAnders Carlsson return false; 3057a201c4c2e604a519665ca55dc49e913628444ddbAnders Carlsson } else if (isa<ReturnInst>(*I)) 3058d4692747439aac1fbc2064e11b53e3e6ea5ad463Benjamin Kramer return true; // We're done. 3059d4692747439aac1fbc2064e11b53e3e6ea5ad463Benjamin Kramer else if (I->mayHaveSideEffects()) 3060d4692747439aac1fbc2064e11b53e3e6ea5ad463Benjamin Kramer return false; // Destructor with side effects, bail. 3061a201c4c2e604a519665ca55dc49e913628444ddbAnders Carlsson } 3062a201c4c2e604a519665ca55dc49e913628444ddbAnders Carlsson 3063a201c4c2e604a519665ca55dc49e913628444ddbAnders Carlsson return false; 3064a201c4c2e604a519665ca55dc49e913628444ddbAnders Carlsson} 3065a201c4c2e604a519665ca55dc49e913628444ddbAnders Carlsson 3066a201c4c2e604a519665ca55dc49e913628444ddbAnders Carlssonbool GlobalOpt::OptimizeEmptyGlobalCXXDtors(Function *CXAAtExitFn) { 3067a201c4c2e604a519665ca55dc49e913628444ddbAnders Carlsson /// Itanium C++ ABI p3.3.5: 3068a201c4c2e604a519665ca55dc49e913628444ddbAnders Carlsson /// 3069a201c4c2e604a519665ca55dc49e913628444ddbAnders Carlsson /// After constructing a global (or local static) object, that will require 3070a201c4c2e604a519665ca55dc49e913628444ddbAnders Carlsson /// destruction on exit, a termination function is registered as follows: 3071a201c4c2e604a519665ca55dc49e913628444ddbAnders Carlsson /// 3072a201c4c2e604a519665ca55dc49e913628444ddbAnders Carlsson /// extern "C" int __cxa_atexit ( void (*f)(void *), void *p, void *d ); 3073a201c4c2e604a519665ca55dc49e913628444ddbAnders Carlsson /// 3074a201c4c2e604a519665ca55dc49e913628444ddbAnders Carlsson /// This registration, e.g. __cxa_atexit(f,p,d), is intended to cause the 3075a201c4c2e604a519665ca55dc49e913628444ddbAnders Carlsson /// call f(p) when DSO d is unloaded, before all such termination calls 3076a201c4c2e604a519665ca55dc49e913628444ddbAnders Carlsson /// registered before this one. It returns zero if registration is 307735ee1c921c55ced16748b90c486c9feeb433c74bNick Lewycky /// successful, nonzero on failure. 3078a201c4c2e604a519665ca55dc49e913628444ddbAnders Carlsson 3079a201c4c2e604a519665ca55dc49e913628444ddbAnders Carlsson // This pass will look for calls to __cxa_atexit where the function is trivial 3080a201c4c2e604a519665ca55dc49e913628444ddbAnders Carlsson // and remove them. 3081a201c4c2e604a519665ca55dc49e913628444ddbAnders Carlsson bool Changed = false; 3082a201c4c2e604a519665ca55dc49e913628444ddbAnders Carlsson 3083a201c4c2e604a519665ca55dc49e913628444ddbAnders Carlsson for (Function::use_iterator I = CXAAtExitFn->use_begin(), 3084a201c4c2e604a519665ca55dc49e913628444ddbAnders Carlsson E = CXAAtExitFn->use_end(); I != E;) { 30854f735ca1855bb66974f3b1c4ee493534d5037edaAnders Carlsson // We're only interested in calls. Theoretically, we could handle invoke 30864f735ca1855bb66974f3b1c4ee493534d5037edaAnders Carlsson // instructions as well, but neither llvm-gcc nor clang generate invokes 30874f735ca1855bb66974f3b1c4ee493534d5037edaAnders Carlsson // to __cxa_atexit. 3088b12caf31f43eefc399eb2584225924d22cfd5b28Anders Carlsson CallInst *CI = dyn_cast<CallInst>(*I++); 3089b12caf31f43eefc399eb2584225924d22cfd5b28Anders Carlsson if (!CI) 30904f735ca1855bb66974f3b1c4ee493534d5037edaAnders Carlsson continue; 30914f735ca1855bb66974f3b1c4ee493534d5037edaAnders Carlsson 3092a201c4c2e604a519665ca55dc49e913628444ddbAnders Carlsson Function *DtorFn = 3093b12caf31f43eefc399eb2584225924d22cfd5b28Anders Carlsson dyn_cast<Function>(CI->getArgOperand(0)->stripPointerCasts()); 3094a201c4c2e604a519665ca55dc49e913628444ddbAnders Carlsson if (!DtorFn) 3095a201c4c2e604a519665ca55dc49e913628444ddbAnders Carlsson continue; 3096a201c4c2e604a519665ca55dc49e913628444ddbAnders Carlsson 3097372ec6aa915534f3b11c252dbc9e6c63814bcab3Anders Carlsson SmallPtrSet<const Function *, 8> CalledFunctions; 3098372ec6aa915534f3b11c252dbc9e6c63814bcab3Anders Carlsson if (!cxxDtorIsEmpty(*DtorFn, CalledFunctions)) 3099a201c4c2e604a519665ca55dc49e913628444ddbAnders Carlsson continue; 3100a201c4c2e604a519665ca55dc49e913628444ddbAnders Carlsson 3101a201c4c2e604a519665ca55dc49e913628444ddbAnders Carlsson // Just remove the call. 3102b12caf31f43eefc399eb2584225924d22cfd5b28Anders Carlsson CI->replaceAllUsesWith(Constant::getNullValue(CI->getType())); 3103b12caf31f43eefc399eb2584225924d22cfd5b28Anders Carlsson CI->eraseFromParent(); 31041f7c7ba380cf411fd02a070822c439fadac91ce6Anders Carlsson 3105a201c4c2e604a519665ca55dc49e913628444ddbAnders Carlsson ++NumCXXDtorsRemoved; 3106a201c4c2e604a519665ca55dc49e913628444ddbAnders Carlsson 3107a201c4c2e604a519665ca55dc49e913628444ddbAnders Carlsson Changed |= true; 3108a201c4c2e604a519665ca55dc49e913628444ddbAnders Carlsson } 3109a201c4c2e604a519665ca55dc49e913628444ddbAnders Carlsson 3110a201c4c2e604a519665ca55dc49e913628444ddbAnders Carlsson return Changed; 3111a201c4c2e604a519665ca55dc49e913628444ddbAnders Carlsson} 3112a201c4c2e604a519665ca55dc49e913628444ddbAnders Carlsson 3113b1ab4580478c90375abec5e2b6e89dc1a15fa98bChris Lattnerbool GlobalOpt::runOnModule(Module &M) { 3114b1ab4580478c90375abec5e2b6e89dc1a15fa98bChris Lattner bool Changed = false; 31159d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 31166a577f82ba56a4da48e984702240a01c3ba7e941Nick Lewycky TD = getAnalysisIfAvailable<TargetData>(); 31176a7df9aae620801d97da72d718e9aff76eebac9bNick Lewycky TLI = &getAnalysis<TargetLibraryInfo>(); 31186a577f82ba56a4da48e984702240a01c3ba7e941Nick Lewycky 3119b1ab4580478c90375abec5e2b6e89dc1a15fa98bChris Lattner // Try to find the llvm.globalctors list. 3120b1ab4580478c90375abec5e2b6e89dc1a15fa98bChris Lattner GlobalVariable *GlobalCtors = FindGlobalCtors(M); 3121b1ab4580478c90375abec5e2b6e89dc1a15fa98bChris Lattner 31226a7df9aae620801d97da72d718e9aff76eebac9bNick Lewycky Function *CXAAtExitFn = FindCXAAtExit(M, TLI); 3123a201c4c2e604a519665ca55dc49e913628444ddbAnders Carlsson 3124b1ab4580478c90375abec5e2b6e89dc1a15fa98bChris Lattner bool LocalChange = true; 3125a4be1dc0a192175bbc561a633c0b7197853e6a74Chris Lattner while (LocalChange) { 3126a4be1dc0a192175bbc561a633c0b7197853e6a74Chris Lattner LocalChange = false; 31279d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 3128b1ab4580478c90375abec5e2b6e89dc1a15fa98bChris Lattner // Delete functions that are trivially dead, ccc -> fastcc 3129b1ab4580478c90375abec5e2b6e89dc1a15fa98bChris Lattner LocalChange |= OptimizeFunctions(M); 31309d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 3131b1ab4580478c90375abec5e2b6e89dc1a15fa98bChris Lattner // Optimize global_ctors list. 3132b1ab4580478c90375abec5e2b6e89dc1a15fa98bChris Lattner if (GlobalCtors) 3133b1ab4580478c90375abec5e2b6e89dc1a15fa98bChris Lattner LocalChange |= OptimizeGlobalCtorsList(GlobalCtors); 31349d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 3135b1ab4580478c90375abec5e2b6e89dc1a15fa98bChris Lattner // Optimize non-address-taken globals. 3136b1ab4580478c90375abec5e2b6e89dc1a15fa98bChris Lattner LocalChange |= OptimizeGlobalVars(M); 3137e4c6b61ebd8f2dbb6a2e51fe1d0e2bdbe17986c4Anton Korobeynikov 3138e4c6b61ebd8f2dbb6a2e51fe1d0e2bdbe17986c4Anton Korobeynikov // Resolve aliases, when possible. 3139fc5940d2a09a795e683ae86b237d6f55fb3551d4Duncan Sands LocalChange |= OptimizeGlobalAliases(M); 3140a201c4c2e604a519665ca55dc49e913628444ddbAnders Carlsson 3141a201c4c2e604a519665ca55dc49e913628444ddbAnders Carlsson // Try to remove trivial global destructors. 3142a201c4c2e604a519665ca55dc49e913628444ddbAnders Carlsson if (CXAAtExitFn) 3143a201c4c2e604a519665ca55dc49e913628444ddbAnders Carlsson LocalChange |= OptimizeEmptyGlobalCXXDtors(CXAAtExitFn); 3144a201c4c2e604a519665ca55dc49e913628444ddbAnders Carlsson 3145e4c6b61ebd8f2dbb6a2e51fe1d0e2bdbe17986c4Anton Korobeynikov Changed |= LocalChange; 3146e47ba74b07b2a6015239bcbabba09750580aecedChris Lattner } 31479d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 3148b1ab4580478c90375abec5e2b6e89dc1a15fa98bChris Lattner // TODO: Move all global ctors functions to the end of the module for code 3149b1ab4580478c90375abec5e2b6e89dc1a15fa98bChris Lattner // layout. 31509d28fdd7225b344789ed7f54cf51b4019763b30bMikhail Glushenkov 3151079236d1c9909365ffd0ef06831523c87335bb4aChris Lattner return Changed; 3152079236d1c9909365ffd0ef06831523c87335bb4aChris Lattner} 3153