Reid Spencer | b7c11e3 | 2005-04-25 03:59:26 +0000 | [diff] [blame] | 1 | //===- SimplifyLibCalls.cpp - Optimize specific well-known library calls --===// |
Reid Spencer | a7c049b | 2005-04-25 02:53:12 +0000 | [diff] [blame] | 2 | // |
| 3 | // The LLVM Compiler Infrastructure |
| 4 | // |
Jeff Cohen | 00b16889 | 2005-07-27 06:12:32 +0000 | [diff] [blame] | 5 | // This file was developed by Reid Spencer and is distributed under the |
Reid Spencer | b7c11e3 | 2005-04-25 03:59:26 +0000 | [diff] [blame] | 6 | // University of Illinois Open Source License. See LICENSE.TXT for details. |
Reid Spencer | a7c049b | 2005-04-25 02:53:12 +0000 | [diff] [blame] | 7 | // |
| 8 | //===----------------------------------------------------------------------===// |
| 9 | // |
Jeff Cohen | 00b16889 | 2005-07-27 06:12:32 +0000 | [diff] [blame] | 10 | // This file implements a module pass that applies a variety of small |
| 11 | // optimizations for calls to specific well-known function calls (e.g. runtime |
| 12 | // library functions). For example, a call to the function "exit(3)" that |
Reid Spencer | 0660f75 | 2005-05-21 00:57:44 +0000 | [diff] [blame] | 13 | // occurs within the main() function can be transformed into a simple "return 3" |
Jeff Cohen | 00b16889 | 2005-07-27 06:12:32 +0000 | [diff] [blame] | 14 | // instruction. Any optimization that takes this form (replace call to library |
| 15 | // function with simpler code that provides the same result) belongs in this |
| 16 | // file. |
Reid Spencer | a7c049b | 2005-04-25 02:53:12 +0000 | [diff] [blame] | 17 | // |
| 18 | //===----------------------------------------------------------------------===// |
| 19 | |
Reid Spencer | ef99ea3 | 2005-04-26 23:05:17 +0000 | [diff] [blame] | 20 | #define DEBUG_TYPE "simplify-libcalls" |
Reid Spencer | 8f13261 | 2005-04-26 23:02:16 +0000 | [diff] [blame] | 21 | #include "llvm/Constants.h" |
| 22 | #include "llvm/DerivedTypes.h" |
| 23 | #include "llvm/Instructions.h" |
Reid Spencer | a7c049b | 2005-04-25 02:53:12 +0000 | [diff] [blame] | 24 | #include "llvm/Module.h" |
| 25 | #include "llvm/Pass.h" |
Reid Spencer | b7c11e3 | 2005-04-25 03:59:26 +0000 | [diff] [blame] | 26 | #include "llvm/ADT/hash_map" |
Reid Spencer | 8f13261 | 2005-04-26 23:02:16 +0000 | [diff] [blame] | 27 | #include "llvm/ADT/Statistic.h" |
Reid Spencer | aa87e05 | 2006-01-19 08:36:56 +0000 | [diff] [blame] | 28 | #include "llvm/Config/config.h" |
Reid Spencer | 8f13261 | 2005-04-26 23:02:16 +0000 | [diff] [blame] | 29 | #include "llvm/Support/Debug.h" |
Reid Spencer | fcbdb9c | 2005-04-26 19:13:17 +0000 | [diff] [blame] | 30 | #include "llvm/Target/TargetData.h" |
Reid Spencer | 8f13261 | 2005-04-26 23:02:16 +0000 | [diff] [blame] | 31 | #include "llvm/Transforms/IPO.h" |
Reid Spencer | a7c049b | 2005-04-25 02:53:12 +0000 | [diff] [blame] | 32 | using namespace llvm; |
| 33 | |
| 34 | namespace { |
Reid Spencer | a7c049b | 2005-04-25 02:53:12 +0000 | [diff] [blame] | 35 | |
Reid Spencer | a16d5a5 | 2005-04-27 07:54:40 +0000 | [diff] [blame] | 36 | /// This statistic keeps track of the total number of library calls that have |
| 37 | /// been simplified regardless of which call it is. |
Jeff Cohen | 00b16889 | 2005-07-27 06:12:32 +0000 | [diff] [blame] | 38 | Statistic<> SimplifiedLibCalls("simplify-libcalls", |
Chris Lattner | bbf728e | 2005-08-07 20:02:04 +0000 | [diff] [blame] | 39 | "Number of library calls simplified"); |
Reid Spencer | a7c049b | 2005-04-25 02:53:12 +0000 | [diff] [blame] | 40 | |
Reid Spencer | 716f49e | 2005-04-27 21:29:20 +0000 | [diff] [blame] | 41 | // Forward declarations |
Reid Spencer | a16d5a5 | 2005-04-27 07:54:40 +0000 | [diff] [blame] | 42 | class LibCallOptimization; |
| 43 | class SimplifyLibCalls; |
Reid Spencer | 716f49e | 2005-04-27 21:29:20 +0000 | [diff] [blame] | 44 | |
Chris Lattner | e05cf71 | 2006-01-22 23:10:26 +0000 | [diff] [blame] | 45 | /// This list is populated by the constructor for LibCallOptimization class. |
Reid Spencer | 8902602 | 2005-05-21 01:27:04 +0000 | [diff] [blame] | 46 | /// Therefore all subclasses are registered here at static initialization time |
| 47 | /// and this list is what the SimplifyLibCalls pass uses to apply the individual |
| 48 | /// optimizations to the call sites. |
Reid Spencer | 716f49e | 2005-04-27 21:29:20 +0000 | [diff] [blame] | 49 | /// @brief The list of optimizations deriving from LibCallOptimization |
Chris Lattner | e05cf71 | 2006-01-22 23:10:26 +0000 | [diff] [blame] | 50 | static LibCallOptimization *OptList = 0; |
Reid Spencer | a7c049b | 2005-04-25 02:53:12 +0000 | [diff] [blame] | 51 | |
Reid Spencer | a16d5a5 | 2005-04-27 07:54:40 +0000 | [diff] [blame] | 52 | /// This class is the abstract base class for the set of optimizations that |
Reid Spencer | 716f49e | 2005-04-27 21:29:20 +0000 | [diff] [blame] | 53 | /// corresponds to one library call. The SimplifyLibCalls pass will call the |
Reid Spencer | a16d5a5 | 2005-04-27 07:54:40 +0000 | [diff] [blame] | 54 | /// ValidateCalledFunction method to ask the optimization if a given Function |
Reid Spencer | 716f49e | 2005-04-27 21:29:20 +0000 | [diff] [blame] | 55 | /// is the kind that the optimization can handle. If the subclass returns true, |
Jeff Cohen | 00b16889 | 2005-07-27 06:12:32 +0000 | [diff] [blame] | 56 | /// then SImplifyLibCalls will also call the OptimizeCall method to perform, |
Reid Spencer | 716f49e | 2005-04-27 21:29:20 +0000 | [diff] [blame] | 57 | /// or attempt to perform, the optimization(s) for the library call. Otherwise, |
| 58 | /// OptimizeCall won't be called. Subclasses are responsible for providing the |
| 59 | /// name of the library call (strlen, strcpy, etc.) to the LibCallOptimization |
| 60 | /// constructor. This is used to efficiently select which call instructions to |
Jeff Cohen | 00b16889 | 2005-07-27 06:12:32 +0000 | [diff] [blame] | 61 | /// optimize. The criteria for a "lib call" is "anything with well known |
Reid Spencer | 716f49e | 2005-04-27 21:29:20 +0000 | [diff] [blame] | 62 | /// semantics", typically a library function that is defined by an international |
Jeff Cohen | 00b16889 | 2005-07-27 06:12:32 +0000 | [diff] [blame] | 63 | /// standard. Because the semantics are well known, the optimizations can |
Reid Spencer | 716f49e | 2005-04-27 21:29:20 +0000 | [diff] [blame] | 64 | /// generally short-circuit actually calling the function if there's a simpler |
| 65 | /// way (e.g. strlen(X) can be reduced to a constant if X is a constant global). |
Reid Spencer | a16d5a5 | 2005-04-27 07:54:40 +0000 | [diff] [blame] | 66 | /// @brief Base class for library call optimizations |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 67 | class LibCallOptimization { |
Chris Lattner | e05cf71 | 2006-01-22 23:10:26 +0000 | [diff] [blame] | 68 | LibCallOptimization **Prev, *Next; |
| 69 | const char *FunctionName; ///< Name of the library call we optimize |
| 70 | #ifndef NDEBUG |
| 71 | Statistic<> occurrences; ///< debug statistic (-debug-only=simplify-libcalls) |
| 72 | #endif |
Jeff Cohen | 5882b92 | 2005-04-29 03:05:44 +0000 | [diff] [blame] | 73 | public: |
Jeff Cohen | 00b16889 | 2005-07-27 06:12:32 +0000 | [diff] [blame] | 74 | /// The \p fname argument must be the name of the library function being |
Reid Spencer | 716f49e | 2005-04-27 21:29:20 +0000 | [diff] [blame] | 75 | /// optimized by the subclass. |
| 76 | /// @brief Constructor that registers the optimization. |
Chris Lattner | e05cf71 | 2006-01-22 23:10:26 +0000 | [diff] [blame] | 77 | LibCallOptimization(const char *FName, const char *Description) |
| 78 | : FunctionName(FName) |
Reid Spencer | 1ea099c | 2005-04-27 00:05:45 +0000 | [diff] [blame] | 79 | #ifndef NDEBUG |
Chris Lattner | e05cf71 | 2006-01-22 23:10:26 +0000 | [diff] [blame] | 80 | , occurrences("simplify-libcalls", Description) |
Reid Spencer | 1ea099c | 2005-04-27 00:05:45 +0000 | [diff] [blame] | 81 | #endif |
Reid Spencer | a7c049b | 2005-04-25 02:53:12 +0000 | [diff] [blame] | 82 | { |
Chris Lattner | e05cf71 | 2006-01-22 23:10:26 +0000 | [diff] [blame] | 83 | // Register this optimizer in the list of optimizations. |
| 84 | Next = OptList; |
| 85 | OptList = this; |
| 86 | Prev = &OptList; |
| 87 | if (Next) Next->Prev = &Next; |
Reid Spencer | a7c049b | 2005-04-25 02:53:12 +0000 | [diff] [blame] | 88 | } |
Chris Lattner | e05cf71 | 2006-01-22 23:10:26 +0000 | [diff] [blame] | 89 | |
| 90 | /// getNext - All libcall optimizations are chained together into a list, |
| 91 | /// return the next one in the list. |
| 92 | LibCallOptimization *getNext() { return Next; } |
Reid Spencer | a7c049b | 2005-04-25 02:53:12 +0000 | [diff] [blame] | 93 | |
Reid Spencer | 716f49e | 2005-04-27 21:29:20 +0000 | [diff] [blame] | 94 | /// @brief Deregister from the optlist |
Chris Lattner | e05cf71 | 2006-01-22 23:10:26 +0000 | [diff] [blame] | 95 | virtual ~LibCallOptimization() { |
| 96 | *Prev = Next; |
| 97 | if (Next) Next->Prev = Prev; |
| 98 | } |
Reid Spencer | 43e0bae | 2005-04-26 03:26:15 +0000 | [diff] [blame] | 99 | |
Reid Spencer | a16d5a5 | 2005-04-27 07:54:40 +0000 | [diff] [blame] | 100 | /// The implementation of this function in subclasses should determine if |
Jeff Cohen | 00b16889 | 2005-07-27 06:12:32 +0000 | [diff] [blame] | 101 | /// \p F is suitable for the optimization. This method is called by |
| 102 | /// SimplifyLibCalls::runOnModule to short circuit visiting all the call |
| 103 | /// sites of such a function if that function is not suitable in the first |
Reid Spencer | 716f49e | 2005-04-27 21:29:20 +0000 | [diff] [blame] | 104 | /// place. If the called function is suitabe, this method should return true; |
Jeff Cohen | 00b16889 | 2005-07-27 06:12:32 +0000 | [diff] [blame] | 105 | /// false, otherwise. This function should also perform any lazy |
| 106 | /// initialization that the LibCallOptimization needs to do, if its to return |
Reid Spencer | a16d5a5 | 2005-04-27 07:54:40 +0000 | [diff] [blame] | 107 | /// true. This avoids doing initialization until the optimizer is actually |
| 108 | /// going to be called upon to do some optimization. |
Reid Spencer | 716f49e | 2005-04-27 21:29:20 +0000 | [diff] [blame] | 109 | /// @brief Determine if the function is suitable for optimization |
Reid Spencer | a16d5a5 | 2005-04-27 07:54:40 +0000 | [diff] [blame] | 110 | virtual bool ValidateCalledFunction( |
| 111 | const Function* F, ///< The function that is the target of call sites |
| 112 | SimplifyLibCalls& SLC ///< The pass object invoking us |
| 113 | ) = 0; |
Reid Spencer | fcbdb9c | 2005-04-26 19:13:17 +0000 | [diff] [blame] | 114 | |
Jeff Cohen | 00b16889 | 2005-07-27 06:12:32 +0000 | [diff] [blame] | 115 | /// The implementations of this function in subclasses is the heart of the |
| 116 | /// SimplifyLibCalls algorithm. Sublcasses of this class implement |
Reid Spencer | a16d5a5 | 2005-04-27 07:54:40 +0000 | [diff] [blame] | 117 | /// OptimizeCall to determine if (a) the conditions are right for optimizing |
Jeff Cohen | 00b16889 | 2005-07-27 06:12:32 +0000 | [diff] [blame] | 118 | /// the call and (b) to perform the optimization. If an action is taken |
Reid Spencer | a16d5a5 | 2005-04-27 07:54:40 +0000 | [diff] [blame] | 119 | /// against ci, the subclass is responsible for returning true and ensuring |
| 120 | /// that ci is erased from its parent. |
Reid Spencer | a16d5a5 | 2005-04-27 07:54:40 +0000 | [diff] [blame] | 121 | /// @brief Optimize a call, if possible. |
| 122 | virtual bool OptimizeCall( |
| 123 | CallInst* ci, ///< The call instruction that should be optimized. |
| 124 | SimplifyLibCalls& SLC ///< The pass object invoking us |
| 125 | ) = 0; |
Reid Spencer | fcbdb9c | 2005-04-26 19:13:17 +0000 | [diff] [blame] | 126 | |
Reid Spencer | a16d5a5 | 2005-04-27 07:54:40 +0000 | [diff] [blame] | 127 | /// @brief Get the name of the library call being optimized |
Chris Lattner | e05cf71 | 2006-01-22 23:10:26 +0000 | [diff] [blame] | 128 | const char *getFunctionName() const { return FunctionName; } |
Reid Spencer | fcbdb9c | 2005-04-26 19:13:17 +0000 | [diff] [blame] | 129 | |
Reid Spencer | 716f49e | 2005-04-27 21:29:20 +0000 | [diff] [blame] | 130 | /// @brief Called by SimplifyLibCalls to update the occurrences statistic. |
Chris Lattner | e05cf71 | 2006-01-22 23:10:26 +0000 | [diff] [blame] | 131 | void succeeded() { |
Reid Spencer | a16d5a5 | 2005-04-27 07:54:40 +0000 | [diff] [blame] | 132 | #ifndef NDEBUG |
Chris Lattner | e05cf71 | 2006-01-22 23:10:26 +0000 | [diff] [blame] | 133 | DEBUG(++occurrences); |
Reid Spencer | a16d5a5 | 2005-04-27 07:54:40 +0000 | [diff] [blame] | 134 | #endif |
Chris Lattner | e05cf71 | 2006-01-22 23:10:26 +0000 | [diff] [blame] | 135 | } |
Reid Spencer | a16d5a5 | 2005-04-27 07:54:40 +0000 | [diff] [blame] | 136 | }; |
| 137 | |
Jeff Cohen | 00b16889 | 2005-07-27 06:12:32 +0000 | [diff] [blame] | 138 | /// This class is an LLVM Pass that applies each of the LibCallOptimization |
Reid Spencer | a16d5a5 | 2005-04-27 07:54:40 +0000 | [diff] [blame] | 139 | /// instances to all the call sites in a module, relatively efficiently. The |
Jeff Cohen | 00b16889 | 2005-07-27 06:12:32 +0000 | [diff] [blame] | 140 | /// purpose of this pass is to provide optimizations for calls to well-known |
Reid Spencer | a16d5a5 | 2005-04-27 07:54:40 +0000 | [diff] [blame] | 141 | /// functions with well-known semantics, such as those in the c library. The |
Chris Lattner | 5324986 | 2005-08-24 17:22:17 +0000 | [diff] [blame] | 142 | /// class provides the basic infrastructure for handling runOnModule. Whenever |
| 143 | /// this pass finds a function call, it asks the appropriate optimizer to |
Reid Spencer | 716f49e | 2005-04-27 21:29:20 +0000 | [diff] [blame] | 144 | /// validate the call (ValidateLibraryCall). If it is validated, then |
| 145 | /// the OptimizeCall method is also called. |
Reid Spencer | a16d5a5 | 2005-04-27 07:54:40 +0000 | [diff] [blame] | 146 | /// @brief A ModulePass for optimizing well-known function calls. |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 147 | class SimplifyLibCalls : public ModulePass { |
Jeff Cohen | 5882b92 | 2005-04-29 03:05:44 +0000 | [diff] [blame] | 148 | public: |
Reid Spencer | a16d5a5 | 2005-04-27 07:54:40 +0000 | [diff] [blame] | 149 | /// We need some target data for accurate signature details that are |
| 150 | /// target dependent. So we require target data in our AnalysisUsage. |
Reid Spencer | 716f49e | 2005-04-27 21:29:20 +0000 | [diff] [blame] | 151 | /// @brief Require TargetData from AnalysisUsage. |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 152 | virtual void getAnalysisUsage(AnalysisUsage& Info) const { |
Reid Spencer | a16d5a5 | 2005-04-27 07:54:40 +0000 | [diff] [blame] | 153 | // Ask that the TargetData analysis be performed before us so we can use |
| 154 | // the target data. |
| 155 | Info.addRequired<TargetData>(); |
| 156 | } |
| 157 | |
| 158 | /// For this pass, process all of the function calls in the module, calling |
| 159 | /// ValidateLibraryCall and OptimizeCall as appropriate. |
Reid Spencer | 716f49e | 2005-04-27 21:29:20 +0000 | [diff] [blame] | 160 | /// @brief Run all the lib call optimizations on a Module. |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 161 | virtual bool runOnModule(Module &M) { |
Reid Spencer | a16d5a5 | 2005-04-27 07:54:40 +0000 | [diff] [blame] | 162 | reset(M); |
| 163 | |
| 164 | bool result = false; |
Chris Lattner | e05cf71 | 2006-01-22 23:10:26 +0000 | [diff] [blame] | 165 | hash_map<std::string, LibCallOptimization*> OptznMap; |
| 166 | for (LibCallOptimization *Optzn = OptList; Optzn; Optzn = Optzn->getNext()) |
| 167 | OptznMap[Optzn->getFunctionName()] = Optzn; |
Reid Spencer | a16d5a5 | 2005-04-27 07:54:40 +0000 | [diff] [blame] | 168 | |
| 169 | // The call optimizations can be recursive. That is, the optimization might |
| 170 | // generate a call to another function which can also be optimized. This way |
Jeff Cohen | 00b16889 | 2005-07-27 06:12:32 +0000 | [diff] [blame] | 171 | // we make the LibCallOptimization instances very specific to the case they |
| 172 | // handle. It also means we need to keep running over the function calls in |
Reid Spencer | a16d5a5 | 2005-04-27 07:54:40 +0000 | [diff] [blame] | 173 | // the module until we don't get any more optimizations possible. |
| 174 | bool found_optimization = false; |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 175 | do { |
Reid Spencer | a16d5a5 | 2005-04-27 07:54:40 +0000 | [diff] [blame] | 176 | found_optimization = false; |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 177 | for (Module::iterator FI = M.begin(), FE = M.end(); FI != FE; ++FI) { |
Reid Spencer | a16d5a5 | 2005-04-27 07:54:40 +0000 | [diff] [blame] | 178 | // All the "well-known" functions are external and have external linkage |
Jeff Cohen | 00b16889 | 2005-07-27 06:12:32 +0000 | [diff] [blame] | 179 | // because they live in a runtime library somewhere and were (probably) |
| 180 | // not compiled by LLVM. So, we only act on external functions that |
Anton Korobeynikov | b74ed07 | 2006-09-14 18:23:27 +0000 | [diff] [blame] | 181 | // have external or dllimport linkage and non-empty uses. |
| 182 | if (!FI->isExternal() || |
| 183 | !(FI->hasExternalLinkage() || FI->hasDLLImportLinkage()) || |
| 184 | FI->use_empty()) |
Reid Spencer | a16d5a5 | 2005-04-27 07:54:40 +0000 | [diff] [blame] | 185 | continue; |
| 186 | |
| 187 | // Get the optimization class that pertains to this function |
Chris Lattner | e05cf71 | 2006-01-22 23:10:26 +0000 | [diff] [blame] | 188 | hash_map<std::string, LibCallOptimization*>::iterator OMI = |
| 189 | OptznMap.find(FI->getName()); |
| 190 | if (OMI == OptznMap.end()) continue; |
| 191 | |
| 192 | LibCallOptimization *CO = OMI->second; |
Reid Spencer | a16d5a5 | 2005-04-27 07:54:40 +0000 | [diff] [blame] | 193 | |
| 194 | // Make sure the called function is suitable for the optimization |
Chris Lattner | e05cf71 | 2006-01-22 23:10:26 +0000 | [diff] [blame] | 195 | if (!CO->ValidateCalledFunction(FI, *this)) |
Reid Spencer | a16d5a5 | 2005-04-27 07:54:40 +0000 | [diff] [blame] | 196 | continue; |
| 197 | |
| 198 | // Loop over each of the uses of the function |
Jeff Cohen | 00b16889 | 2005-07-27 06:12:32 +0000 | [diff] [blame] | 199 | for (Value::use_iterator UI = FI->use_begin(), UE = FI->use_end(); |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 200 | UI != UE ; ) { |
Reid Spencer | a16d5a5 | 2005-04-27 07:54:40 +0000 | [diff] [blame] | 201 | // If the use of the function is a call instruction |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 202 | if (CallInst* CI = dyn_cast<CallInst>(*UI++)) { |
Reid Spencer | a16d5a5 | 2005-04-27 07:54:40 +0000 | [diff] [blame] | 203 | // Do the optimization on the LibCallOptimization. |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 204 | if (CO->OptimizeCall(CI, *this)) { |
Reid Spencer | a16d5a5 | 2005-04-27 07:54:40 +0000 | [diff] [blame] | 205 | ++SimplifiedLibCalls; |
| 206 | found_optimization = result = true; |
Reid Spencer | 716f49e | 2005-04-27 21:29:20 +0000 | [diff] [blame] | 207 | CO->succeeded(); |
Reid Spencer | a16d5a5 | 2005-04-27 07:54:40 +0000 | [diff] [blame] | 208 | } |
Reid Spencer | fcbdb9c | 2005-04-26 19:13:17 +0000 | [diff] [blame] | 209 | } |
| 210 | } |
| 211 | } |
Reid Spencer | a16d5a5 | 2005-04-27 07:54:40 +0000 | [diff] [blame] | 212 | } while (found_optimization); |
Chris Lattner | e05cf71 | 2006-01-22 23:10:26 +0000 | [diff] [blame] | 213 | |
Reid Spencer | a16d5a5 | 2005-04-27 07:54:40 +0000 | [diff] [blame] | 214 | return result; |
| 215 | } |
Reid Spencer | fcbdb9c | 2005-04-26 19:13:17 +0000 | [diff] [blame] | 216 | |
Reid Spencer | a16d5a5 | 2005-04-27 07:54:40 +0000 | [diff] [blame] | 217 | /// @brief Return the *current* module we're working on. |
Reid Spencer | ff5525d | 2005-04-29 09:39:47 +0000 | [diff] [blame] | 218 | Module* getModule() const { return M; } |
Reid Spencer | fcbdb9c | 2005-04-26 19:13:17 +0000 | [diff] [blame] | 219 | |
Reid Spencer | a16d5a5 | 2005-04-27 07:54:40 +0000 | [diff] [blame] | 220 | /// @brief Return the *current* target data for the module we're working on. |
Reid Spencer | ff5525d | 2005-04-29 09:39:47 +0000 | [diff] [blame] | 221 | TargetData* getTargetData() const { return TD; } |
| 222 | |
| 223 | /// @brief Return the size_t type -- syntactic shortcut |
| 224 | const Type* getIntPtrType() const { return TD->getIntPtrType(); } |
| 225 | |
Evan Cheng | 21abac2 | 2006-06-16 08:36:35 +0000 | [diff] [blame] | 226 | /// @brief Return a Function* for the putchar libcall |
| 227 | Function* get_putchar() { |
| 228 | if (!putchar_func) |
| 229 | putchar_func = M->getOrInsertFunction("putchar", Type::IntTy, Type::IntTy, |
| 230 | NULL); |
| 231 | return putchar_func; |
| 232 | } |
| 233 | |
| 234 | /// @brief Return a Function* for the puts libcall |
| 235 | Function* get_puts() { |
| 236 | if (!puts_func) |
| 237 | puts_func = M->getOrInsertFunction("puts", Type::IntTy, |
| 238 | PointerType::get(Type::SByteTy), |
| 239 | NULL); |
| 240 | return puts_func; |
| 241 | } |
| 242 | |
Reid Spencer | ff5525d | 2005-04-29 09:39:47 +0000 | [diff] [blame] | 243 | /// @brief Return a Function* for the fputc libcall |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 244 | Function* get_fputc(const Type* FILEptr_type) { |
Reid Spencer | ff5525d | 2005-04-29 09:39:47 +0000 | [diff] [blame] | 245 | if (!fputc_func) |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 246 | fputc_func = M->getOrInsertFunction("fputc", Type::IntTy, Type::IntTy, |
| 247 | FILEptr_type, NULL); |
Reid Spencer | ff5525d | 2005-04-29 09:39:47 +0000 | [diff] [blame] | 248 | return fputc_func; |
| 249 | } |
| 250 | |
Evan Cheng | 9528952 | 2006-06-16 04:52:30 +0000 | [diff] [blame] | 251 | /// @brief Return a Function* for the fputs libcall |
| 252 | Function* get_fputs(const Type* FILEptr_type) { |
| 253 | if (!fputs_func) |
| 254 | fputs_func = M->getOrInsertFunction("fputs", Type::IntTy, |
| 255 | PointerType::get(Type::SByteTy), |
| 256 | FILEptr_type, NULL); |
| 257 | return fputs_func; |
| 258 | } |
| 259 | |
Reid Spencer | ff5525d | 2005-04-29 09:39:47 +0000 | [diff] [blame] | 260 | /// @brief Return a Function* for the fwrite libcall |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 261 | Function* get_fwrite(const Type* FILEptr_type) { |
Reid Spencer | ff5525d | 2005-04-29 09:39:47 +0000 | [diff] [blame] | 262 | if (!fwrite_func) |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 263 | fwrite_func = M->getOrInsertFunction("fwrite", TD->getIntPtrType(), |
| 264 | PointerType::get(Type::SByteTy), |
| 265 | TD->getIntPtrType(), |
| 266 | TD->getIntPtrType(), |
| 267 | FILEptr_type, NULL); |
Reid Spencer | ff5525d | 2005-04-29 09:39:47 +0000 | [diff] [blame] | 268 | return fwrite_func; |
| 269 | } |
| 270 | |
| 271 | /// @brief Return a Function* for the sqrt libcall |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 272 | Function* get_sqrt() { |
Reid Spencer | ff5525d | 2005-04-29 09:39:47 +0000 | [diff] [blame] | 273 | if (!sqrt_func) |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 274 | sqrt_func = M->getOrInsertFunction("sqrt", Type::DoubleTy, |
| 275 | Type::DoubleTy, NULL); |
Reid Spencer | ff5525d | 2005-04-29 09:39:47 +0000 | [diff] [blame] | 276 | return sqrt_func; |
| 277 | } |
Reid Spencer | a16d5a5 | 2005-04-27 07:54:40 +0000 | [diff] [blame] | 278 | |
| 279 | /// @brief Return a Function* for the strlen libcall |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 280 | Function* get_strcpy() { |
Reid Spencer | 58b563c | 2005-05-04 03:20:21 +0000 | [diff] [blame] | 281 | if (!strcpy_func) |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 282 | strcpy_func = M->getOrInsertFunction("strcpy", |
| 283 | PointerType::get(Type::SByteTy), |
| 284 | PointerType::get(Type::SByteTy), |
| 285 | PointerType::get(Type::SByteTy), |
| 286 | NULL); |
Reid Spencer | 58b563c | 2005-05-04 03:20:21 +0000 | [diff] [blame] | 287 | return strcpy_func; |
| 288 | } |
| 289 | |
| 290 | /// @brief Return a Function* for the strlen libcall |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 291 | Function* get_strlen() { |
Reid Spencer | a16d5a5 | 2005-04-27 07:54:40 +0000 | [diff] [blame] | 292 | if (!strlen_func) |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 293 | strlen_func = M->getOrInsertFunction("strlen", TD->getIntPtrType(), |
| 294 | PointerType::get(Type::SByteTy), |
| 295 | NULL); |
Reid Spencer | a16d5a5 | 2005-04-27 07:54:40 +0000 | [diff] [blame] | 296 | return strlen_func; |
Reid Spencer | 43e0bae | 2005-04-26 03:26:15 +0000 | [diff] [blame] | 297 | } |
| 298 | |
Reid Spencer | 21506ff | 2005-05-03 07:23:44 +0000 | [diff] [blame] | 299 | /// @brief Return a Function* for the memchr libcall |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 300 | Function* get_memchr() { |
Reid Spencer | 21506ff | 2005-05-03 07:23:44 +0000 | [diff] [blame] | 301 | if (!memchr_func) |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 302 | memchr_func = M->getOrInsertFunction("memchr", |
| 303 | PointerType::get(Type::SByteTy), |
| 304 | PointerType::get(Type::SByteTy), |
| 305 | Type::IntTy, TD->getIntPtrType(), |
| 306 | NULL); |
Reid Spencer | 21506ff | 2005-05-03 07:23:44 +0000 | [diff] [blame] | 307 | return memchr_func; |
| 308 | } |
| 309 | |
Reid Spencer | a16d5a5 | 2005-04-27 07:54:40 +0000 | [diff] [blame] | 310 | /// @brief Return a Function* for the memcpy libcall |
Chris Lattner | 5324986 | 2005-08-24 17:22:17 +0000 | [diff] [blame] | 311 | Function* get_memcpy() { |
| 312 | if (!memcpy_func) { |
| 313 | const Type *SBP = PointerType::get(Type::SByteTy); |
Chris Lattner | aecb062 | 2006-03-03 01:30:23 +0000 | [diff] [blame] | 314 | const char *N = TD->getIntPtrType() == Type::UIntTy ? |
| 315 | "llvm.memcpy.i32" : "llvm.memcpy.i64"; |
| 316 | memcpy_func = M->getOrInsertFunction(N, Type::VoidTy, SBP, SBP, |
| 317 | TD->getIntPtrType(), Type::UIntTy, |
| 318 | NULL); |
Reid Spencer | 43e0bae | 2005-04-26 03:26:15 +0000 | [diff] [blame] | 319 | } |
Reid Spencer | a16d5a5 | 2005-04-27 07:54:40 +0000 | [diff] [blame] | 320 | return memcpy_func; |
Reid Spencer | 43e0bae | 2005-04-26 03:26:15 +0000 | [diff] [blame] | 321 | } |
Reid Spencer | 912401c | 2005-04-26 05:24:00 +0000 | [diff] [blame] | 322 | |
Chris Lattner | e46f6e9 | 2006-01-23 06:24:46 +0000 | [diff] [blame] | 323 | Function *getUnaryFloatFunction(const char *Name, Function *&Cache) { |
| 324 | if (!Cache) |
| 325 | Cache = M->getOrInsertFunction(Name, Type::FloatTy, Type::FloatTy, NULL); |
| 326 | return Cache; |
Chris Lattner | 5324986 | 2005-08-24 17:22:17 +0000 | [diff] [blame] | 327 | } |
| 328 | |
Chris Lattner | e46f6e9 | 2006-01-23 06:24:46 +0000 | [diff] [blame] | 329 | Function *get_floorf() { return getUnaryFloatFunction("floorf", floorf_func);} |
| 330 | Function *get_ceilf() { return getUnaryFloatFunction( "ceilf", ceilf_func);} |
| 331 | Function *get_roundf() { return getUnaryFloatFunction("roundf", roundf_func);} |
| 332 | Function *get_rintf() { return getUnaryFloatFunction( "rintf", rintf_func);} |
| 333 | Function *get_nearbyintf() { return getUnaryFloatFunction("nearbyintf", |
| 334 | nearbyintf_func); } |
Reid Spencer | a16d5a5 | 2005-04-27 07:54:40 +0000 | [diff] [blame] | 335 | private: |
Reid Spencer | 716f49e | 2005-04-27 21:29:20 +0000 | [diff] [blame] | 336 | /// @brief Reset our cached data for a new Module |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 337 | void reset(Module& mod) { |
Reid Spencer | a16d5a5 | 2005-04-27 07:54:40 +0000 | [diff] [blame] | 338 | M = &mod; |
| 339 | TD = &getAnalysis<TargetData>(); |
Evan Cheng | 21abac2 | 2006-06-16 08:36:35 +0000 | [diff] [blame] | 340 | putchar_func = 0; |
| 341 | puts_func = 0; |
Reid Spencer | ff5525d | 2005-04-29 09:39:47 +0000 | [diff] [blame] | 342 | fputc_func = 0; |
Evan Cheng | 9528952 | 2006-06-16 04:52:30 +0000 | [diff] [blame] | 343 | fputs_func = 0; |
Reid Spencer | ff5525d | 2005-04-29 09:39:47 +0000 | [diff] [blame] | 344 | fwrite_func = 0; |
Reid Spencer | a16d5a5 | 2005-04-27 07:54:40 +0000 | [diff] [blame] | 345 | memcpy_func = 0; |
Reid Spencer | 21506ff | 2005-05-03 07:23:44 +0000 | [diff] [blame] | 346 | memchr_func = 0; |
Reid Spencer | ff5525d | 2005-04-29 09:39:47 +0000 | [diff] [blame] | 347 | sqrt_func = 0; |
Reid Spencer | 58b563c | 2005-05-04 03:20:21 +0000 | [diff] [blame] | 348 | strcpy_func = 0; |
Reid Spencer | a16d5a5 | 2005-04-27 07:54:40 +0000 | [diff] [blame] | 349 | strlen_func = 0; |
Chris Lattner | 5324986 | 2005-08-24 17:22:17 +0000 | [diff] [blame] | 350 | floorf_func = 0; |
Chris Lattner | e46f6e9 | 2006-01-23 06:24:46 +0000 | [diff] [blame] | 351 | ceilf_func = 0; |
| 352 | roundf_func = 0; |
| 353 | rintf_func = 0; |
| 354 | nearbyintf_func = 0; |
Reid Spencer | 912401c | 2005-04-26 05:24:00 +0000 | [diff] [blame] | 355 | } |
Reid Spencer | a7c049b | 2005-04-25 02:53:12 +0000 | [diff] [blame] | 356 | |
Reid Spencer | a16d5a5 | 2005-04-27 07:54:40 +0000 | [diff] [blame] | 357 | private: |
Chris Lattner | e46f6e9 | 2006-01-23 06:24:46 +0000 | [diff] [blame] | 358 | /// Caches for function pointers. |
Evan Cheng | 21abac2 | 2006-06-16 08:36:35 +0000 | [diff] [blame] | 359 | Function *putchar_func, *puts_func; |
Evan Cheng | 9528952 | 2006-06-16 04:52:30 +0000 | [diff] [blame] | 360 | Function *fputc_func, *fputs_func, *fwrite_func; |
Chris Lattner | e46f6e9 | 2006-01-23 06:24:46 +0000 | [diff] [blame] | 361 | Function *memcpy_func, *memchr_func; |
| 362 | Function* sqrt_func; |
| 363 | Function *strcpy_func, *strlen_func; |
| 364 | Function *floorf_func, *ceilf_func, *roundf_func; |
| 365 | Function *rintf_func, *nearbyintf_func; |
| 366 | Module *M; ///< Cached Module |
| 367 | TargetData *TD; ///< Cached TargetData |
Reid Spencer | a16d5a5 | 2005-04-27 07:54:40 +0000 | [diff] [blame] | 368 | }; |
| 369 | |
| 370 | // Register the pass |
Chris Lattner | 7f8897f | 2006-08-27 22:42:52 +0000 | [diff] [blame] | 371 | RegisterPass<SimplifyLibCalls> |
| 372 | X("simplify-libcalls", "Simplify well-known library calls"); |
Reid Spencer | a16d5a5 | 2005-04-27 07:54:40 +0000 | [diff] [blame] | 373 | |
| 374 | } // anonymous namespace |
| 375 | |
| 376 | // The only public symbol in this file which just instantiates the pass object |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 377 | ModulePass *llvm::createSimplifyLibCallsPass() { |
Jeff Cohen | 00b16889 | 2005-07-27 06:12:32 +0000 | [diff] [blame] | 378 | return new SimplifyLibCalls(); |
Reid Spencer | a16d5a5 | 2005-04-27 07:54:40 +0000 | [diff] [blame] | 379 | } |
| 380 | |
| 381 | // Classes below here, in the anonymous namespace, are all subclasses of the |
| 382 | // LibCallOptimization class, each implementing all optimizations possible for a |
| 383 | // single well-known library call. Each has a static singleton instance that |
Jeff Cohen | 00b16889 | 2005-07-27 06:12:32 +0000 | [diff] [blame] | 384 | // auto registers it into the "optlist" global above. |
Reid Spencer | a16d5a5 | 2005-04-27 07:54:40 +0000 | [diff] [blame] | 385 | namespace { |
| 386 | |
Reid Spencer | 134d2e4 | 2005-06-18 17:46:28 +0000 | [diff] [blame] | 387 | // Forward declare utility functions. |
Reid Spencer | 9f56b1f | 2005-04-30 03:17:54 +0000 | [diff] [blame] | 388 | bool getConstantStringLength(Value* V, uint64_t& len, ConstantArray** A = 0 ); |
Reid Spencer | 134d2e4 | 2005-06-18 17:46:28 +0000 | [diff] [blame] | 389 | Value *CastToCStr(Value *V, Instruction &IP); |
Reid Spencer | a16d5a5 | 2005-04-27 07:54:40 +0000 | [diff] [blame] | 390 | |
| 391 | /// This LibCallOptimization will find instances of a call to "exit" that occurs |
Reid Spencer | a7c049b | 2005-04-25 02:53:12 +0000 | [diff] [blame] | 392 | /// within the "main" function and change it to a simple "ret" instruction with |
Reid Spencer | 716f49e | 2005-04-27 21:29:20 +0000 | [diff] [blame] | 393 | /// the same value passed to the exit function. When this is done, it splits the |
| 394 | /// basic block at the exit(3) call and deletes the call instruction. |
Reid Spencer | a7c049b | 2005-04-25 02:53:12 +0000 | [diff] [blame] | 395 | /// @brief Replace calls to exit in main with a simple return |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 396 | struct ExitInMainOptimization : public LibCallOptimization { |
Reid Spencer | 9974dda | 2005-05-03 02:54:54 +0000 | [diff] [blame] | 397 | ExitInMainOptimization() : LibCallOptimization("exit", |
Reid Spencer | 789082a | 2005-05-07 20:15:59 +0000 | [diff] [blame] | 398 | "Number of 'exit' calls simplified") {} |
Reid Spencer | 6cc0311 | 2005-04-25 21:11:48 +0000 | [diff] [blame] | 399 | |
| 400 | // Make sure the called function looks like exit (int argument, int return |
Jeff Cohen | 00b16889 | 2005-07-27 06:12:32 +0000 | [diff] [blame] | 401 | // type, external linkage, not varargs). |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 402 | virtual bool ValidateCalledFunction(const Function *F, SimplifyLibCalls &SLC){ |
| 403 | return F->arg_size() >= 1 && F->arg_begin()->getType()->isInteger(); |
Reid Spencer | 6cc0311 | 2005-04-25 21:11:48 +0000 | [diff] [blame] | 404 | } |
| 405 | |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 406 | virtual bool OptimizeCall(CallInst* ci, SimplifyLibCalls& SLC) { |
Reid Spencer | 6cc0311 | 2005-04-25 21:11:48 +0000 | [diff] [blame] | 407 | // To be careful, we check that the call to exit is coming from "main", that |
| 408 | // main has external linkage, and the return type of main and the argument |
Jeff Cohen | 00b16889 | 2005-07-27 06:12:32 +0000 | [diff] [blame] | 409 | // to exit have the same type. |
Reid Spencer | 6cc0311 | 2005-04-25 21:11:48 +0000 | [diff] [blame] | 410 | Function *from = ci->getParent()->getParent(); |
| 411 | if (from->hasExternalLinkage()) |
| 412 | if (from->getReturnType() == ci->getOperand(1)->getType()) |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 413 | if (from->getName() == "main") { |
Jeff Cohen | 00b16889 | 2005-07-27 06:12:32 +0000 | [diff] [blame] | 414 | // Okay, time to actually do the optimization. First, get the basic |
Reid Spencer | 6cc0311 | 2005-04-25 21:11:48 +0000 | [diff] [blame] | 415 | // block of the call instruction |
| 416 | BasicBlock* bb = ci->getParent(); |
Reid Spencer | a7c049b | 2005-04-25 02:53:12 +0000 | [diff] [blame] | 417 | |
Jeff Cohen | 00b16889 | 2005-07-27 06:12:32 +0000 | [diff] [blame] | 418 | // Create a return instruction that we'll replace the call with. |
| 419 | // Note that the argument of the return is the argument of the call |
Reid Spencer | 6cc0311 | 2005-04-25 21:11:48 +0000 | [diff] [blame] | 420 | // instruction. |
Chris Lattner | 2144c25 | 2006-05-12 23:35:26 +0000 | [diff] [blame] | 421 | new ReturnInst(ci->getOperand(1), ci); |
Reid Spencer | a7c049b | 2005-04-25 02:53:12 +0000 | [diff] [blame] | 422 | |
Reid Spencer | 6cc0311 | 2005-04-25 21:11:48 +0000 | [diff] [blame] | 423 | // Split the block at the call instruction which places it in a new |
| 424 | // basic block. |
Reid Spencer | 43e0bae | 2005-04-26 03:26:15 +0000 | [diff] [blame] | 425 | bb->splitBasicBlock(ci); |
Reid Spencer | a7c049b | 2005-04-25 02:53:12 +0000 | [diff] [blame] | 426 | |
Reid Spencer | 6cc0311 | 2005-04-25 21:11:48 +0000 | [diff] [blame] | 427 | // The block split caused a branch instruction to be inserted into |
| 428 | // the end of the original block, right after the return instruction |
| 429 | // that we put there. That's not a valid block, so delete the branch |
| 430 | // instruction. |
Reid Spencer | 43e0bae | 2005-04-26 03:26:15 +0000 | [diff] [blame] | 431 | bb->getInstList().pop_back(); |
Reid Spencer | a7c049b | 2005-04-25 02:53:12 +0000 | [diff] [blame] | 432 | |
Reid Spencer | 6cc0311 | 2005-04-25 21:11:48 +0000 | [diff] [blame] | 433 | // Now we can finally get rid of the call instruction which now lives |
| 434 | // in the new basic block. |
| 435 | ci->eraseFromParent(); |
| 436 | |
| 437 | // Optimization succeeded, return true. |
| 438 | return true; |
| 439 | } |
| 440 | // We didn't pass the criteria for this optimization so return false |
| 441 | return false; |
Reid Spencer | b7c11e3 | 2005-04-25 03:59:26 +0000 | [diff] [blame] | 442 | } |
Reid Spencer | a7c049b | 2005-04-25 02:53:12 +0000 | [diff] [blame] | 443 | } ExitInMainOptimizer; |
| 444 | |
Jeff Cohen | 00b16889 | 2005-07-27 06:12:32 +0000 | [diff] [blame] | 445 | /// This LibCallOptimization will simplify a call to the strcat library |
| 446 | /// function. The simplification is possible only if the string being |
| 447 | /// concatenated is a constant array or a constant expression that results in |
| 448 | /// a constant string. In this case we can replace it with strlen + llvm.memcpy |
Reid Spencer | 716f49e | 2005-04-27 21:29:20 +0000 | [diff] [blame] | 449 | /// of the constant string. Both of these calls are further reduced, if possible |
| 450 | /// on subsequent passes. |
Reid Spencer | 6cc0311 | 2005-04-25 21:11:48 +0000 | [diff] [blame] | 451 | /// @brief Simplify the strcat library function. |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 452 | struct StrCatOptimization : public LibCallOptimization { |
Reid Spencer | 43e0bae | 2005-04-26 03:26:15 +0000 | [diff] [blame] | 453 | public: |
Reid Spencer | 716f49e | 2005-04-27 21:29:20 +0000 | [diff] [blame] | 454 | /// @brief Default constructor |
Reid Spencer | 9974dda | 2005-05-03 02:54:54 +0000 | [diff] [blame] | 455 | StrCatOptimization() : LibCallOptimization("strcat", |
Reid Spencer | 789082a | 2005-05-07 20:15:59 +0000 | [diff] [blame] | 456 | "Number of 'strcat' calls simplified") {} |
Reid Spencer | a16d5a5 | 2005-04-27 07:54:40 +0000 | [diff] [blame] | 457 | |
| 458 | public: |
Reid Spencer | 6cc0311 | 2005-04-25 21:11:48 +0000 | [diff] [blame] | 459 | |
| 460 | /// @brief Make sure that the "strcat" function has the right prototype |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 461 | virtual bool ValidateCalledFunction(const Function* f, SimplifyLibCalls& SLC){ |
Reid Spencer | 6cc0311 | 2005-04-25 21:11:48 +0000 | [diff] [blame] | 462 | if (f->getReturnType() == PointerType::get(Type::SByteTy)) |
Jeff Cohen | 00b16889 | 2005-07-27 06:12:32 +0000 | [diff] [blame] | 463 | if (f->arg_size() == 2) |
Reid Spencer | 6cc0311 | 2005-04-25 21:11:48 +0000 | [diff] [blame] | 464 | { |
| 465 | Function::const_arg_iterator AI = f->arg_begin(); |
| 466 | if (AI++->getType() == PointerType::get(Type::SByteTy)) |
| 467 | if (AI->getType() == PointerType::get(Type::SByteTy)) |
Reid Spencer | 43e0bae | 2005-04-26 03:26:15 +0000 | [diff] [blame] | 468 | { |
Reid Spencer | 43e0bae | 2005-04-26 03:26:15 +0000 | [diff] [blame] | 469 | // Indicate this is a suitable call type. |
Reid Spencer | 6cc0311 | 2005-04-25 21:11:48 +0000 | [diff] [blame] | 470 | return true; |
Reid Spencer | 43e0bae | 2005-04-26 03:26:15 +0000 | [diff] [blame] | 471 | } |
Reid Spencer | 6cc0311 | 2005-04-25 21:11:48 +0000 | [diff] [blame] | 472 | } |
| 473 | return false; |
| 474 | } |
| 475 | |
Reid Spencer | a16d5a5 | 2005-04-27 07:54:40 +0000 | [diff] [blame] | 476 | /// @brief Optimize the strcat library function |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 477 | virtual bool OptimizeCall(CallInst* ci, SimplifyLibCalls& SLC) { |
Reid Spencer | 3f7d8c6 | 2005-04-27 17:46:54 +0000 | [diff] [blame] | 478 | // Extract some information from the instruction |
Reid Spencer | 3f7d8c6 | 2005-04-27 17:46:54 +0000 | [diff] [blame] | 479 | Value* dest = ci->getOperand(1); |
| 480 | Value* src = ci->getOperand(2); |
| 481 | |
Jeff Cohen | 00b16889 | 2005-07-27 06:12:32 +0000 | [diff] [blame] | 482 | // Extract the initializer (while making numerous checks) from the |
Reid Spencer | 912401c | 2005-04-26 05:24:00 +0000 | [diff] [blame] | 483 | // source operand of the call to strcat. If we get null back, one of |
| 484 | // a variety of checks in get_GVInitializer failed |
Reid Spencer | 20754ac | 2005-04-26 07:45:18 +0000 | [diff] [blame] | 485 | uint64_t len = 0; |
Reid Spencer | 3f7d8c6 | 2005-04-27 17:46:54 +0000 | [diff] [blame] | 486 | if (!getConstantStringLength(src,len)) |
Reid Spencer | 43e0bae | 2005-04-26 03:26:15 +0000 | [diff] [blame] | 487 | return false; |
| 488 | |
Reid Spencer | 20754ac | 2005-04-26 07:45:18 +0000 | [diff] [blame] | 489 | // Handle the simple, do-nothing case |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 490 | if (len == 0) { |
Reid Spencer | 3f7d8c6 | 2005-04-27 17:46:54 +0000 | [diff] [blame] | 491 | ci->replaceAllUsesWith(dest); |
Reid Spencer | 43e0bae | 2005-04-26 03:26:15 +0000 | [diff] [blame] | 492 | ci->eraseFromParent(); |
| 493 | return true; |
| 494 | } |
| 495 | |
Reid Spencer | 20754ac | 2005-04-26 07:45:18 +0000 | [diff] [blame] | 496 | // Increment the length because we actually want to memcpy the null |
| 497 | // terminator as well. |
| 498 | len++; |
Reid Spencer | 6cc0311 | 2005-04-25 21:11:48 +0000 | [diff] [blame] | 499 | |
Jeff Cohen | 00b16889 | 2005-07-27 06:12:32 +0000 | [diff] [blame] | 500 | // We need to find the end of the destination string. That's where the |
| 501 | // memory is to be moved to. We just generate a call to strlen (further |
| 502 | // optimized in another pass). Note that the SLC.get_strlen() call |
Reid Spencer | 20754ac | 2005-04-26 07:45:18 +0000 | [diff] [blame] | 503 | // caches the Function* for us. |
Jeff Cohen | 00b16889 | 2005-07-27 06:12:32 +0000 | [diff] [blame] | 504 | CallInst* strlen_inst = |
Reid Spencer | 3f7d8c6 | 2005-04-27 17:46:54 +0000 | [diff] [blame] | 505 | new CallInst(SLC.get_strlen(), dest, dest->getName()+".len",ci); |
Reid Spencer | 20754ac | 2005-04-26 07:45:18 +0000 | [diff] [blame] | 506 | |
Jeff Cohen | 00b16889 | 2005-07-27 06:12:32 +0000 | [diff] [blame] | 507 | // Now that we have the destination's length, we must index into the |
Reid Spencer | 20754ac | 2005-04-26 07:45:18 +0000 | [diff] [blame] | 508 | // destination's pointer to get the actual memcpy destination (end of |
| 509 | // the string .. we're concatenating). |
| 510 | std::vector<Value*> idx; |
| 511 | idx.push_back(strlen_inst); |
Jeff Cohen | 00b16889 | 2005-07-27 06:12:32 +0000 | [diff] [blame] | 512 | GetElementPtrInst* gep = |
Reid Spencer | 3f7d8c6 | 2005-04-27 17:46:54 +0000 | [diff] [blame] | 513 | new GetElementPtrInst(dest,idx,dest->getName()+".indexed",ci); |
Reid Spencer | 20754ac | 2005-04-26 07:45:18 +0000 | [diff] [blame] | 514 | |
| 515 | // We have enough information to now generate the memcpy call to |
| 516 | // do the concatenation for us. |
| 517 | std::vector<Value*> vals; |
| 518 | vals.push_back(gep); // destination |
| 519 | vals.push_back(ci->getOperand(2)); // source |
Reid Spencer | b83eb64 | 2006-10-20 07:07:24 +0000 | [diff] [blame] | 520 | vals.push_back(ConstantInt::get(SLC.getIntPtrType(),len)); // length |
| 521 | vals.push_back(ConstantInt::get(Type::UIntTy,1)); // alignment |
Reid Spencer | 3f7d8c6 | 2005-04-27 17:46:54 +0000 | [diff] [blame] | 522 | new CallInst(SLC.get_memcpy(), vals, "", ci); |
Reid Spencer | 20754ac | 2005-04-26 07:45:18 +0000 | [diff] [blame] | 523 | |
Jeff Cohen | 00b16889 | 2005-07-27 06:12:32 +0000 | [diff] [blame] | 524 | // Finally, substitute the first operand of the strcat call for the |
| 525 | // strcat call itself since strcat returns its first operand; and, |
Reid Spencer | 20754ac | 2005-04-26 07:45:18 +0000 | [diff] [blame] | 526 | // kill the strcat CallInst. |
Reid Spencer | 3f7d8c6 | 2005-04-27 17:46:54 +0000 | [diff] [blame] | 527 | ci->replaceAllUsesWith(dest); |
Reid Spencer | 20754ac | 2005-04-26 07:45:18 +0000 | [diff] [blame] | 528 | ci->eraseFromParent(); |
| 529 | return true; |
Reid Spencer | b7c11e3 | 2005-04-25 03:59:26 +0000 | [diff] [blame] | 530 | } |
| 531 | } StrCatOptimizer; |
| 532 | |
Jeff Cohen | 00b16889 | 2005-07-27 06:12:32 +0000 | [diff] [blame] | 533 | /// This LibCallOptimization will simplify a call to the strchr library |
Reid Spencer | 21506ff | 2005-05-03 07:23:44 +0000 | [diff] [blame] | 534 | /// function. It optimizes out cases where the arguments are both constant |
| 535 | /// and the result can be determined statically. |
| 536 | /// @brief Simplify the strcmp library function. |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 537 | struct StrChrOptimization : public LibCallOptimization { |
Reid Spencer | 21506ff | 2005-05-03 07:23:44 +0000 | [diff] [blame] | 538 | public: |
| 539 | StrChrOptimization() : LibCallOptimization("strchr", |
Reid Spencer | 789082a | 2005-05-07 20:15:59 +0000 | [diff] [blame] | 540 | "Number of 'strchr' calls simplified") {} |
Reid Spencer | 21506ff | 2005-05-03 07:23:44 +0000 | [diff] [blame] | 541 | |
| 542 | /// @brief Make sure that the "strchr" function has the right prototype |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 543 | virtual bool ValidateCalledFunction(const Function* f, SimplifyLibCalls& SLC){ |
Jeff Cohen | 00b16889 | 2005-07-27 06:12:32 +0000 | [diff] [blame] | 544 | if (f->getReturnType() == PointerType::get(Type::SByteTy) && |
Reid Spencer | 21506ff | 2005-05-03 07:23:44 +0000 | [diff] [blame] | 545 | f->arg_size() == 2) |
| 546 | return true; |
| 547 | return false; |
| 548 | } |
| 549 | |
Chris Lattner | 9375135 | 2005-05-20 22:22:25 +0000 | [diff] [blame] | 550 | /// @brief Perform the strchr optimizations |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 551 | virtual bool OptimizeCall(CallInst *ci, SimplifyLibCalls &SLC) { |
Reid Spencer | 21506ff | 2005-05-03 07:23:44 +0000 | [diff] [blame] | 552 | // If there aren't three operands, bail |
| 553 | if (ci->getNumOperands() != 3) |
| 554 | return false; |
| 555 | |
| 556 | // Check that the first argument to strchr is a constant array of sbyte. |
| 557 | // If it is, get the length and data, otherwise return false. |
| 558 | uint64_t len = 0; |
Reid Spencer | b83eb64 | 2006-10-20 07:07:24 +0000 | [diff] [blame] | 559 | ConstantArray* CA = 0; |
Reid Spencer | 21506ff | 2005-05-03 07:23:44 +0000 | [diff] [blame] | 560 | if (!getConstantStringLength(ci->getOperand(1),len,&CA)) |
| 561 | return false; |
| 562 | |
Reid Spencer | b83eb64 | 2006-10-20 07:07:24 +0000 | [diff] [blame] | 563 | // Check that the second argument to strchr is a constant int. If it isn't |
| 564 | // a constant signed integer, we can try an alternate optimization |
| 565 | ConstantInt* CSI = dyn_cast<ConstantInt>(ci->getOperand(2)); |
| 566 | if (!CSI || CSI->getType()->isUnsigned() ) { |
| 567 | // The second operand is not constant, or not signed. Just lower this to |
| 568 | // memchr since we know the length of the string since it is constant. |
Reid Spencer | 21506ff | 2005-05-03 07:23:44 +0000 | [diff] [blame] | 569 | Function* f = SLC.get_memchr(); |
| 570 | std::vector<Value*> args; |
| 571 | args.push_back(ci->getOperand(1)); |
| 572 | args.push_back(ci->getOperand(2)); |
Reid Spencer | b83eb64 | 2006-10-20 07:07:24 +0000 | [diff] [blame] | 573 | args.push_back(ConstantInt::get(SLC.getIntPtrType(),len)); |
Reid Spencer | 21506ff | 2005-05-03 07:23:44 +0000 | [diff] [blame] | 574 | ci->replaceAllUsesWith( new CallInst(f,args,ci->getName(),ci)); |
| 575 | ci->eraseFromParent(); |
| 576 | return true; |
| 577 | } |
| 578 | |
| 579 | // Get the character we're looking for |
Reid Spencer | b83eb64 | 2006-10-20 07:07:24 +0000 | [diff] [blame] | 580 | int64_t chr = CSI->getSExtValue(); |
Reid Spencer | 21506ff | 2005-05-03 07:23:44 +0000 | [diff] [blame] | 581 | |
| 582 | // Compute the offset |
| 583 | uint64_t offset = 0; |
| 584 | bool char_found = false; |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 585 | for (uint64_t i = 0; i < len; ++i) { |
Reid Spencer | b83eb64 | 2006-10-20 07:07:24 +0000 | [diff] [blame] | 586 | if (ConstantInt* CI = dyn_cast<ConstantInt>(CA->getOperand(i))) { |
Reid Spencer | 21506ff | 2005-05-03 07:23:44 +0000 | [diff] [blame] | 587 | // Check for the null terminator |
| 588 | if (CI->isNullValue()) |
| 589 | break; // we found end of string |
Reid Spencer | b83eb64 | 2006-10-20 07:07:24 +0000 | [diff] [blame] | 590 | else if (CI->getSExtValue() == chr) { |
Reid Spencer | 21506ff | 2005-05-03 07:23:44 +0000 | [diff] [blame] | 591 | char_found = true; |
| 592 | offset = i; |
| 593 | break; |
| 594 | } |
| 595 | } |
| 596 | } |
| 597 | |
| 598 | // strchr(s,c) -> offset_of_in(c,s) |
| 599 | // (if c is a constant integer and s is a constant string) |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 600 | if (char_found) { |
Reid Spencer | 21506ff | 2005-05-03 07:23:44 +0000 | [diff] [blame] | 601 | std::vector<Value*> indices; |
Reid Spencer | b83eb64 | 2006-10-20 07:07:24 +0000 | [diff] [blame] | 602 | indices.push_back(ConstantInt::get(Type::ULongTy,offset)); |
Reid Spencer | 21506ff | 2005-05-03 07:23:44 +0000 | [diff] [blame] | 603 | GetElementPtrInst* GEP = new GetElementPtrInst(ci->getOperand(1),indices, |
| 604 | ci->getOperand(1)->getName()+".strchr",ci); |
| 605 | ci->replaceAllUsesWith(GEP); |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 606 | } else { |
Reid Spencer | 21506ff | 2005-05-03 07:23:44 +0000 | [diff] [blame] | 607 | ci->replaceAllUsesWith( |
| 608 | ConstantPointerNull::get(PointerType::get(Type::SByteTy))); |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 609 | } |
Reid Spencer | 21506ff | 2005-05-03 07:23:44 +0000 | [diff] [blame] | 610 | ci->eraseFromParent(); |
| 611 | return true; |
| 612 | } |
| 613 | } StrChrOptimizer; |
| 614 | |
Jeff Cohen | 00b16889 | 2005-07-27 06:12:32 +0000 | [diff] [blame] | 615 | /// This LibCallOptimization will simplify a call to the strcmp library |
Reid Spencer | 9f56b1f | 2005-04-30 03:17:54 +0000 | [diff] [blame] | 616 | /// function. It optimizes out cases where one or both arguments are constant |
| 617 | /// and the result can be determined statically. |
| 618 | /// @brief Simplify the strcmp library function. |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 619 | struct StrCmpOptimization : public LibCallOptimization { |
Reid Spencer | 9f56b1f | 2005-04-30 03:17:54 +0000 | [diff] [blame] | 620 | public: |
Reid Spencer | 9974dda | 2005-05-03 02:54:54 +0000 | [diff] [blame] | 621 | StrCmpOptimization() : LibCallOptimization("strcmp", |
Reid Spencer | 789082a | 2005-05-07 20:15:59 +0000 | [diff] [blame] | 622 | "Number of 'strcmp' calls simplified") {} |
Reid Spencer | 9f56b1f | 2005-04-30 03:17:54 +0000 | [diff] [blame] | 623 | |
Chris Lattner | 9375135 | 2005-05-20 22:22:25 +0000 | [diff] [blame] | 624 | /// @brief Make sure that the "strcmp" function has the right prototype |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 625 | virtual bool ValidateCalledFunction(const Function *F, SimplifyLibCalls &SLC){ |
| 626 | return F->getReturnType() == Type::IntTy && F->arg_size() == 2; |
Reid Spencer | 9f56b1f | 2005-04-30 03:17:54 +0000 | [diff] [blame] | 627 | } |
| 628 | |
Chris Lattner | 9375135 | 2005-05-20 22:22:25 +0000 | [diff] [blame] | 629 | /// @brief Perform the strcmp optimization |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 630 | virtual bool OptimizeCall(CallInst* ci, SimplifyLibCalls& SLC) { |
Reid Spencer | 9f56b1f | 2005-04-30 03:17:54 +0000 | [diff] [blame] | 631 | // First, check to see if src and destination are the same. If they are, |
Reid Spencer | 63a7513 | 2005-04-30 06:45:47 +0000 | [diff] [blame] | 632 | // then the optimization is to replace the CallInst with a constant 0 |
Jeff Cohen | 00b16889 | 2005-07-27 06:12:32 +0000 | [diff] [blame] | 633 | // because the call is a no-op. |
Reid Spencer | 9f56b1f | 2005-04-30 03:17:54 +0000 | [diff] [blame] | 634 | Value* s1 = ci->getOperand(1); |
| 635 | Value* s2 = ci->getOperand(2); |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 636 | if (s1 == s2) { |
Reid Spencer | 9f56b1f | 2005-04-30 03:17:54 +0000 | [diff] [blame] | 637 | // strcmp(x,x) -> 0 |
| 638 | ci->replaceAllUsesWith(ConstantInt::get(Type::IntTy,0)); |
| 639 | ci->eraseFromParent(); |
| 640 | return true; |
| 641 | } |
| 642 | |
| 643 | bool isstr_1 = false; |
| 644 | uint64_t len_1 = 0; |
| 645 | ConstantArray* A1; |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 646 | if (getConstantStringLength(s1,len_1,&A1)) { |
Reid Spencer | 9f56b1f | 2005-04-30 03:17:54 +0000 | [diff] [blame] | 647 | isstr_1 = true; |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 648 | if (len_1 == 0) { |
Reid Spencer | 9f56b1f | 2005-04-30 03:17:54 +0000 | [diff] [blame] | 649 | // strcmp("",x) -> *x |
Jeff Cohen | 00b16889 | 2005-07-27 06:12:32 +0000 | [diff] [blame] | 650 | LoadInst* load = |
Reid Spencer | 134d2e4 | 2005-06-18 17:46:28 +0000 | [diff] [blame] | 651 | new LoadInst(CastToCStr(s2,*ci), ci->getName()+".load",ci); |
Jeff Cohen | 00b16889 | 2005-07-27 06:12:32 +0000 | [diff] [blame] | 652 | CastInst* cast = |
Reid Spencer | 3da59db | 2006-11-27 01:05:10 +0000 | [diff] [blame^] | 653 | CastInst::create(Instruction::SExt, load, Type::IntTy, |
| 654 | ci->getName()+".int", ci); |
Reid Spencer | 9f56b1f | 2005-04-30 03:17:54 +0000 | [diff] [blame] | 655 | ci->replaceAllUsesWith(cast); |
| 656 | ci->eraseFromParent(); |
| 657 | return true; |
| 658 | } |
| 659 | } |
| 660 | |
| 661 | bool isstr_2 = false; |
| 662 | uint64_t len_2 = 0; |
| 663 | ConstantArray* A2; |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 664 | if (getConstantStringLength(s2, len_2, &A2)) { |
Reid Spencer | 9f56b1f | 2005-04-30 03:17:54 +0000 | [diff] [blame] | 665 | isstr_2 = true; |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 666 | if (len_2 == 0) { |
Reid Spencer | 9f56b1f | 2005-04-30 03:17:54 +0000 | [diff] [blame] | 667 | // strcmp(x,"") -> *x |
Jeff Cohen | 00b16889 | 2005-07-27 06:12:32 +0000 | [diff] [blame] | 668 | LoadInst* load = |
Reid Spencer | 134d2e4 | 2005-06-18 17:46:28 +0000 | [diff] [blame] | 669 | new LoadInst(CastToCStr(s1,*ci),ci->getName()+".val",ci); |
Jeff Cohen | 00b16889 | 2005-07-27 06:12:32 +0000 | [diff] [blame] | 670 | CastInst* cast = |
Reid Spencer | 3da59db | 2006-11-27 01:05:10 +0000 | [diff] [blame^] | 671 | CastInst::create(Instruction::SExt, load, Type::IntTy, |
| 672 | ci->getName()+".int", ci); |
Reid Spencer | 9f56b1f | 2005-04-30 03:17:54 +0000 | [diff] [blame] | 673 | ci->replaceAllUsesWith(cast); |
| 674 | ci->eraseFromParent(); |
| 675 | return true; |
| 676 | } |
| 677 | } |
| 678 | |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 679 | if (isstr_1 && isstr_2) { |
Reid Spencer | 9f56b1f | 2005-04-30 03:17:54 +0000 | [diff] [blame] | 680 | // strcmp(x,y) -> cnst (if both x and y are constant strings) |
| 681 | std::string str1 = A1->getAsString(); |
| 682 | std::string str2 = A2->getAsString(); |
| 683 | int result = strcmp(str1.c_str(), str2.c_str()); |
Reid Spencer | b83eb64 | 2006-10-20 07:07:24 +0000 | [diff] [blame] | 684 | ci->replaceAllUsesWith(ConstantInt::get(Type::IntTy,result)); |
Reid Spencer | 9f56b1f | 2005-04-30 03:17:54 +0000 | [diff] [blame] | 685 | ci->eraseFromParent(); |
| 686 | return true; |
| 687 | } |
| 688 | return false; |
| 689 | } |
| 690 | } StrCmpOptimizer; |
| 691 | |
Jeff Cohen | 00b16889 | 2005-07-27 06:12:32 +0000 | [diff] [blame] | 692 | /// This LibCallOptimization will simplify a call to the strncmp library |
Reid Spencer | e6ec8cc | 2005-05-03 01:43:45 +0000 | [diff] [blame] | 693 | /// function. It optimizes out cases where one or both arguments are constant |
| 694 | /// and the result can be determined statically. |
| 695 | /// @brief Simplify the strncmp library function. |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 696 | struct StrNCmpOptimization : public LibCallOptimization { |
Reid Spencer | e6ec8cc | 2005-05-03 01:43:45 +0000 | [diff] [blame] | 697 | public: |
Reid Spencer | 9974dda | 2005-05-03 02:54:54 +0000 | [diff] [blame] | 698 | StrNCmpOptimization() : LibCallOptimization("strncmp", |
Reid Spencer | 789082a | 2005-05-07 20:15:59 +0000 | [diff] [blame] | 699 | "Number of 'strncmp' calls simplified") {} |
Reid Spencer | e6ec8cc | 2005-05-03 01:43:45 +0000 | [diff] [blame] | 700 | |
Chris Lattner | 9375135 | 2005-05-20 22:22:25 +0000 | [diff] [blame] | 701 | /// @brief Make sure that the "strncmp" function has the right prototype |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 702 | virtual bool ValidateCalledFunction(const Function* f, SimplifyLibCalls& SLC){ |
Reid Spencer | e6ec8cc | 2005-05-03 01:43:45 +0000 | [diff] [blame] | 703 | if (f->getReturnType() == Type::IntTy && f->arg_size() == 3) |
| 704 | return true; |
| 705 | return false; |
| 706 | } |
| 707 | |
| 708 | /// @brief Perform the strncpy optimization |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 709 | virtual bool OptimizeCall(CallInst *ci, SimplifyLibCalls &SLC) { |
Reid Spencer | e6ec8cc | 2005-05-03 01:43:45 +0000 | [diff] [blame] | 710 | // First, check to see if src and destination are the same. If they are, |
| 711 | // then the optimization is to replace the CallInst with a constant 0 |
Jeff Cohen | 00b16889 | 2005-07-27 06:12:32 +0000 | [diff] [blame] | 712 | // because the call is a no-op. |
Reid Spencer | e6ec8cc | 2005-05-03 01:43:45 +0000 | [diff] [blame] | 713 | Value* s1 = ci->getOperand(1); |
| 714 | Value* s2 = ci->getOperand(2); |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 715 | if (s1 == s2) { |
Reid Spencer | e6ec8cc | 2005-05-03 01:43:45 +0000 | [diff] [blame] | 716 | // strncmp(x,x,l) -> 0 |
| 717 | ci->replaceAllUsesWith(ConstantInt::get(Type::IntTy,0)); |
| 718 | ci->eraseFromParent(); |
| 719 | return true; |
| 720 | } |
| 721 | |
| 722 | // Check the length argument, if it is Constant zero then the strings are |
| 723 | // considered equal. |
| 724 | uint64_t len_arg = 0; |
| 725 | bool len_arg_is_const = false; |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 726 | if (ConstantInt* len_CI = dyn_cast<ConstantInt>(ci->getOperand(3))) { |
Reid Spencer | e6ec8cc | 2005-05-03 01:43:45 +0000 | [diff] [blame] | 727 | len_arg_is_const = true; |
Reid Spencer | b83eb64 | 2006-10-20 07:07:24 +0000 | [diff] [blame] | 728 | len_arg = len_CI->getZExtValue(); |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 729 | if (len_arg == 0) { |
Reid Spencer | e6ec8cc | 2005-05-03 01:43:45 +0000 | [diff] [blame] | 730 | // strncmp(x,y,0) -> 0 |
| 731 | ci->replaceAllUsesWith(ConstantInt::get(Type::IntTy,0)); |
| 732 | ci->eraseFromParent(); |
| 733 | return true; |
Jeff Cohen | 00b16889 | 2005-07-27 06:12:32 +0000 | [diff] [blame] | 734 | } |
Reid Spencer | e6ec8cc | 2005-05-03 01:43:45 +0000 | [diff] [blame] | 735 | } |
| 736 | |
| 737 | bool isstr_1 = false; |
| 738 | uint64_t len_1 = 0; |
| 739 | ConstantArray* A1; |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 740 | if (getConstantStringLength(s1, len_1, &A1)) { |
Reid Spencer | e6ec8cc | 2005-05-03 01:43:45 +0000 | [diff] [blame] | 741 | isstr_1 = true; |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 742 | if (len_1 == 0) { |
Reid Spencer | e6ec8cc | 2005-05-03 01:43:45 +0000 | [diff] [blame] | 743 | // strncmp("",x) -> *x |
| 744 | LoadInst* load = new LoadInst(s1,ci->getName()+".load",ci); |
Jeff Cohen | 00b16889 | 2005-07-27 06:12:32 +0000 | [diff] [blame] | 745 | CastInst* cast = |
Reid Spencer | 3da59db | 2006-11-27 01:05:10 +0000 | [diff] [blame^] | 746 | CastInst::create(Instruction::SExt, load, Type::IntTy, |
| 747 | ci->getName()+".int", ci); |
Reid Spencer | e6ec8cc | 2005-05-03 01:43:45 +0000 | [diff] [blame] | 748 | ci->replaceAllUsesWith(cast); |
| 749 | ci->eraseFromParent(); |
| 750 | return true; |
| 751 | } |
| 752 | } |
| 753 | |
| 754 | bool isstr_2 = false; |
| 755 | uint64_t len_2 = 0; |
| 756 | ConstantArray* A2; |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 757 | if (getConstantStringLength(s2,len_2,&A2)) { |
Reid Spencer | e6ec8cc | 2005-05-03 01:43:45 +0000 | [diff] [blame] | 758 | isstr_2 = true; |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 759 | if (len_2 == 0) { |
Reid Spencer | e6ec8cc | 2005-05-03 01:43:45 +0000 | [diff] [blame] | 760 | // strncmp(x,"") -> *x |
| 761 | LoadInst* load = new LoadInst(s2,ci->getName()+".val",ci); |
Jeff Cohen | 00b16889 | 2005-07-27 06:12:32 +0000 | [diff] [blame] | 762 | CastInst* cast = |
Reid Spencer | 3da59db | 2006-11-27 01:05:10 +0000 | [diff] [blame^] | 763 | CastInst::create(Instruction::SExt, load, Type::IntTy, |
| 764 | ci->getName()+".int", ci); |
Reid Spencer | e6ec8cc | 2005-05-03 01:43:45 +0000 | [diff] [blame] | 765 | ci->replaceAllUsesWith(cast); |
| 766 | ci->eraseFromParent(); |
| 767 | return true; |
| 768 | } |
| 769 | } |
| 770 | |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 771 | if (isstr_1 && isstr_2 && len_arg_is_const) { |
Reid Spencer | e6ec8cc | 2005-05-03 01:43:45 +0000 | [diff] [blame] | 772 | // strncmp(x,y,const) -> constant |
| 773 | std::string str1 = A1->getAsString(); |
| 774 | std::string str2 = A2->getAsString(); |
| 775 | int result = strncmp(str1.c_str(), str2.c_str(), len_arg); |
Reid Spencer | b83eb64 | 2006-10-20 07:07:24 +0000 | [diff] [blame] | 776 | ci->replaceAllUsesWith(ConstantInt::get(Type::IntTy,result)); |
Reid Spencer | e6ec8cc | 2005-05-03 01:43:45 +0000 | [diff] [blame] | 777 | ci->eraseFromParent(); |
| 778 | return true; |
| 779 | } |
| 780 | return false; |
| 781 | } |
| 782 | } StrNCmpOptimizer; |
| 783 | |
Jeff Cohen | 00b16889 | 2005-07-27 06:12:32 +0000 | [diff] [blame] | 784 | /// This LibCallOptimization will simplify a call to the strcpy library |
| 785 | /// function. Two optimizations are possible: |
Reid Spencer | a16d5a5 | 2005-04-27 07:54:40 +0000 | [diff] [blame] | 786 | /// (1) If src and dest are the same and not volatile, just return dest |
| 787 | /// (2) If the src is a constant then we can convert to llvm.memmove |
| 788 | /// @brief Simplify the strcpy library function. |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 789 | struct StrCpyOptimization : public LibCallOptimization { |
Reid Spencer | a16d5a5 | 2005-04-27 07:54:40 +0000 | [diff] [blame] | 790 | public: |
Reid Spencer | 9974dda | 2005-05-03 02:54:54 +0000 | [diff] [blame] | 791 | StrCpyOptimization() : LibCallOptimization("strcpy", |
Reid Spencer | 789082a | 2005-05-07 20:15:59 +0000 | [diff] [blame] | 792 | "Number of 'strcpy' calls simplified") {} |
Reid Spencer | a16d5a5 | 2005-04-27 07:54:40 +0000 | [diff] [blame] | 793 | |
| 794 | /// @brief Make sure that the "strcpy" function has the right prototype |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 795 | virtual bool ValidateCalledFunction(const Function* f, SimplifyLibCalls& SLC){ |
Reid Spencer | a16d5a5 | 2005-04-27 07:54:40 +0000 | [diff] [blame] | 796 | if (f->getReturnType() == PointerType::get(Type::SByteTy)) |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 797 | if (f->arg_size() == 2) { |
Reid Spencer | a16d5a5 | 2005-04-27 07:54:40 +0000 | [diff] [blame] | 798 | Function::const_arg_iterator AI = f->arg_begin(); |
| 799 | if (AI++->getType() == PointerType::get(Type::SByteTy)) |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 800 | if (AI->getType() == PointerType::get(Type::SByteTy)) { |
Reid Spencer | a16d5a5 | 2005-04-27 07:54:40 +0000 | [diff] [blame] | 801 | // Indicate this is a suitable call type. |
| 802 | return true; |
| 803 | } |
| 804 | } |
| 805 | return false; |
| 806 | } |
| 807 | |
| 808 | /// @brief Perform the strcpy optimization |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 809 | virtual bool OptimizeCall(CallInst* ci, SimplifyLibCalls& SLC) { |
Reid Spencer | a16d5a5 | 2005-04-27 07:54:40 +0000 | [diff] [blame] | 810 | // First, check to see if src and destination are the same. If they are, |
| 811 | // then the optimization is to replace the CallInst with the destination |
Jeff Cohen | 00b16889 | 2005-07-27 06:12:32 +0000 | [diff] [blame] | 812 | // because the call is a no-op. Note that this corresponds to the |
Reid Spencer | a16d5a5 | 2005-04-27 07:54:40 +0000 | [diff] [blame] | 813 | // degenerate strcpy(X,X) case which should have "undefined" results |
| 814 | // according to the C specification. However, it occurs sometimes and |
| 815 | // we optimize it as a no-op. |
| 816 | Value* dest = ci->getOperand(1); |
| 817 | Value* src = ci->getOperand(2); |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 818 | if (dest == src) { |
Reid Spencer | a16d5a5 | 2005-04-27 07:54:40 +0000 | [diff] [blame] | 819 | ci->replaceAllUsesWith(dest); |
| 820 | ci->eraseFromParent(); |
| 821 | return true; |
| 822 | } |
Jeff Cohen | 00b16889 | 2005-07-27 06:12:32 +0000 | [diff] [blame] | 823 | |
Reid Spencer | a16d5a5 | 2005-04-27 07:54:40 +0000 | [diff] [blame] | 824 | // Get the length of the constant string referenced by the second operand, |
| 825 | // the "src" parameter. Fail the optimization if we can't get the length |
| 826 | // (note that getConstantStringLength does lots of checks to make sure this |
| 827 | // is valid). |
| 828 | uint64_t len = 0; |
| 829 | if (!getConstantStringLength(ci->getOperand(2),len)) |
| 830 | return false; |
| 831 | |
| 832 | // If the constant string's length is zero we can optimize this by just |
| 833 | // doing a store of 0 at the first byte of the destination |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 834 | if (len == 0) { |
Reid Spencer | a16d5a5 | 2005-04-27 07:54:40 +0000 | [diff] [blame] | 835 | new StoreInst(ConstantInt::get(Type::SByteTy,0),ci->getOperand(1),ci); |
| 836 | ci->replaceAllUsesWith(dest); |
| 837 | ci->eraseFromParent(); |
| 838 | return true; |
| 839 | } |
| 840 | |
| 841 | // Increment the length because we actually want to memcpy the null |
| 842 | // terminator as well. |
| 843 | len++; |
| 844 | |
Reid Spencer | a16d5a5 | 2005-04-27 07:54:40 +0000 | [diff] [blame] | 845 | // We have enough information to now generate the memcpy call to |
| 846 | // do the concatenation for us. |
| 847 | std::vector<Value*> vals; |
| 848 | vals.push_back(dest); // destination |
| 849 | vals.push_back(src); // source |
Reid Spencer | b83eb64 | 2006-10-20 07:07:24 +0000 | [diff] [blame] | 850 | vals.push_back(ConstantInt::get(SLC.getIntPtrType(),len)); // length |
| 851 | vals.push_back(ConstantInt::get(Type::UIntTy,1)); // alignment |
Reid Spencer | 3f7d8c6 | 2005-04-27 17:46:54 +0000 | [diff] [blame] | 852 | new CallInst(SLC.get_memcpy(), vals, "", ci); |
Reid Spencer | a16d5a5 | 2005-04-27 07:54:40 +0000 | [diff] [blame] | 853 | |
Jeff Cohen | 00b16889 | 2005-07-27 06:12:32 +0000 | [diff] [blame] | 854 | // Finally, substitute the first operand of the strcat call for the |
| 855 | // strcat call itself since strcat returns its first operand; and, |
Reid Spencer | a16d5a5 | 2005-04-27 07:54:40 +0000 | [diff] [blame] | 856 | // kill the strcat CallInst. |
| 857 | ci->replaceAllUsesWith(dest); |
| 858 | ci->eraseFromParent(); |
| 859 | return true; |
| 860 | } |
| 861 | } StrCpyOptimizer; |
| 862 | |
Jeff Cohen | 00b16889 | 2005-07-27 06:12:32 +0000 | [diff] [blame] | 863 | /// This LibCallOptimization will simplify a call to the strlen library |
| 864 | /// function by replacing it with a constant value if the string provided to |
Reid Spencer | 716f49e | 2005-04-27 21:29:20 +0000 | [diff] [blame] | 865 | /// it is a constant array. |
Reid Spencer | 912401c | 2005-04-26 05:24:00 +0000 | [diff] [blame] | 866 | /// @brief Simplify the strlen library function. |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 867 | struct StrLenOptimization : public LibCallOptimization { |
Reid Spencer | 9974dda | 2005-05-03 02:54:54 +0000 | [diff] [blame] | 868 | StrLenOptimization() : LibCallOptimization("strlen", |
Reid Spencer | 789082a | 2005-05-07 20:15:59 +0000 | [diff] [blame] | 869 | "Number of 'strlen' calls simplified") {} |
Reid Spencer | 912401c | 2005-04-26 05:24:00 +0000 | [diff] [blame] | 870 | |
| 871 | /// @brief Make sure that the "strlen" function has the right prototype |
Reid Spencer | a16d5a5 | 2005-04-27 07:54:40 +0000 | [diff] [blame] | 872 | virtual bool ValidateCalledFunction(const Function* f, SimplifyLibCalls& SLC) |
Reid Spencer | 912401c | 2005-04-26 05:24:00 +0000 | [diff] [blame] | 873 | { |
Reid Spencer | a16d5a5 | 2005-04-27 07:54:40 +0000 | [diff] [blame] | 874 | if (f->getReturnType() == SLC.getTargetData()->getIntPtrType()) |
Jeff Cohen | 00b16889 | 2005-07-27 06:12:32 +0000 | [diff] [blame] | 875 | if (f->arg_size() == 1) |
Reid Spencer | 912401c | 2005-04-26 05:24:00 +0000 | [diff] [blame] | 876 | if (Function::const_arg_iterator AI = f->arg_begin()) |
| 877 | if (AI->getType() == PointerType::get(Type::SByteTy)) |
| 878 | return true; |
| 879 | return false; |
| 880 | } |
| 881 | |
| 882 | /// @brief Perform the strlen optimization |
Reid Spencer | a16d5a5 | 2005-04-27 07:54:40 +0000 | [diff] [blame] | 883 | virtual bool OptimizeCall(CallInst* ci, SimplifyLibCalls& SLC) |
Reid Spencer | 912401c | 2005-04-26 05:24:00 +0000 | [diff] [blame] | 884 | { |
Reid Spencer | 789082a | 2005-05-07 20:15:59 +0000 | [diff] [blame] | 885 | // Make sure we're dealing with an sbyte* here. |
| 886 | Value* str = ci->getOperand(1); |
| 887 | if (str->getType() != PointerType::get(Type::SByteTy)) |
| 888 | return false; |
| 889 | |
| 890 | // Does the call to strlen have exactly one use? |
Jeff Cohen | 00b16889 | 2005-07-27 06:12:32 +0000 | [diff] [blame] | 891 | if (ci->hasOneUse()) |
Reid Spencer | 789082a | 2005-05-07 20:15:59 +0000 | [diff] [blame] | 892 | // Is that single use a binary operator? |
| 893 | if (BinaryOperator* bop = dyn_cast<BinaryOperator>(ci->use_back())) |
| 894 | // Is it compared against a constant integer? |
| 895 | if (ConstantInt* CI = dyn_cast<ConstantInt>(bop->getOperand(1))) |
| 896 | { |
| 897 | // Get the value the strlen result is compared to |
Reid Spencer | b83eb64 | 2006-10-20 07:07:24 +0000 | [diff] [blame] | 898 | uint64_t val = CI->getZExtValue(); |
Reid Spencer | 789082a | 2005-05-07 20:15:59 +0000 | [diff] [blame] | 899 | |
| 900 | // If its compared against length 0 with == or != |
| 901 | if (val == 0 && |
| 902 | (bop->getOpcode() == Instruction::SetEQ || |
| 903 | bop->getOpcode() == Instruction::SetNE)) |
| 904 | { |
| 905 | // strlen(x) != 0 -> *x != 0 |
| 906 | // strlen(x) == 0 -> *x == 0 |
| 907 | LoadInst* load = new LoadInst(str,str->getName()+".first",ci); |
| 908 | BinaryOperator* rbop = BinaryOperator::create(bop->getOpcode(), |
Reid Spencer | b83eb64 | 2006-10-20 07:07:24 +0000 | [diff] [blame] | 909 | load, ConstantInt::get(Type::SByteTy,0), |
Reid Spencer | 789082a | 2005-05-07 20:15:59 +0000 | [diff] [blame] | 910 | bop->getName()+".strlen", ci); |
| 911 | bop->replaceAllUsesWith(rbop); |
| 912 | bop->eraseFromParent(); |
| 913 | ci->eraseFromParent(); |
| 914 | return true; |
| 915 | } |
| 916 | } |
| 917 | |
| 918 | // Get the length of the constant string operand |
Reid Spencer | 20754ac | 2005-04-26 07:45:18 +0000 | [diff] [blame] | 919 | uint64_t len = 0; |
| 920 | if (!getConstantStringLength(ci->getOperand(1),len)) |
Reid Spencer | 912401c | 2005-04-26 05:24:00 +0000 | [diff] [blame] | 921 | return false; |
| 922 | |
Reid Spencer | 789082a | 2005-05-07 20:15:59 +0000 | [diff] [blame] | 923 | // strlen("xyz") -> 3 (for example) |
Chris Lattner | 9cc5f42 | 2005-08-01 16:52:50 +0000 | [diff] [blame] | 924 | const Type *Ty = SLC.getTargetData()->getIntPtrType(); |
| 925 | if (Ty->isSigned()) |
Reid Spencer | b83eb64 | 2006-10-20 07:07:24 +0000 | [diff] [blame] | 926 | ci->replaceAllUsesWith(ConstantInt::get(Ty, len)); |
Chris Lattner | 9cc5f42 | 2005-08-01 16:52:50 +0000 | [diff] [blame] | 927 | else |
Reid Spencer | b83eb64 | 2006-10-20 07:07:24 +0000 | [diff] [blame] | 928 | ci->replaceAllUsesWith(ConstantInt::get(Ty, len)); |
Chris Lattner | 9cc5f42 | 2005-08-01 16:52:50 +0000 | [diff] [blame] | 929 | |
Reid Spencer | 20754ac | 2005-04-26 07:45:18 +0000 | [diff] [blame] | 930 | ci->eraseFromParent(); |
| 931 | return true; |
Reid Spencer | 912401c | 2005-04-26 05:24:00 +0000 | [diff] [blame] | 932 | } |
| 933 | } StrLenOptimizer; |
| 934 | |
Chris Lattner | c330069 | 2005-09-29 04:54:20 +0000 | [diff] [blame] | 935 | /// IsOnlyUsedInEqualsComparison - Return true if it only matters that the value |
| 936 | /// is equal or not-equal to zero. |
| 937 | static bool IsOnlyUsedInEqualsZeroComparison(Instruction *I) { |
| 938 | for (Value::use_iterator UI = I->use_begin(), E = I->use_end(); |
| 939 | UI != E; ++UI) { |
| 940 | Instruction *User = cast<Instruction>(*UI); |
| 941 | if (User->getOpcode() == Instruction::SetNE || |
| 942 | User->getOpcode() == Instruction::SetEQ) { |
| 943 | if (isa<Constant>(User->getOperand(1)) && |
| 944 | cast<Constant>(User->getOperand(1))->isNullValue()) |
| 945 | continue; |
| 946 | } else if (CastInst *CI = dyn_cast<CastInst>(User)) |
| 947 | if (CI->getType() == Type::BoolTy) |
| 948 | continue; |
| 949 | // Unknown instruction. |
| 950 | return false; |
| 951 | } |
| 952 | return true; |
| 953 | } |
| 954 | |
| 955 | /// This memcmpOptimization will simplify a call to the memcmp library |
| 956 | /// function. |
| 957 | struct memcmpOptimization : public LibCallOptimization { |
| 958 | /// @brief Default Constructor |
| 959 | memcmpOptimization() |
| 960 | : LibCallOptimization("memcmp", "Number of 'memcmp' calls simplified") {} |
| 961 | |
| 962 | /// @brief Make sure that the "memcmp" function has the right prototype |
| 963 | virtual bool ValidateCalledFunction(const Function *F, SimplifyLibCalls &TD) { |
| 964 | Function::const_arg_iterator AI = F->arg_begin(); |
| 965 | if (F->arg_size() != 3 || !isa<PointerType>(AI->getType())) return false; |
| 966 | if (!isa<PointerType>((++AI)->getType())) return false; |
| 967 | if (!(++AI)->getType()->isInteger()) return false; |
| 968 | if (!F->getReturnType()->isInteger()) return false; |
| 969 | return true; |
| 970 | } |
| 971 | |
| 972 | /// Because of alignment and instruction information that we don't have, we |
| 973 | /// leave the bulk of this to the code generators. |
| 974 | /// |
| 975 | /// Note that we could do much more if we could force alignment on otherwise |
| 976 | /// small aligned allocas, or if we could indicate that loads have a small |
| 977 | /// alignment. |
| 978 | virtual bool OptimizeCall(CallInst *CI, SimplifyLibCalls &TD) { |
| 979 | Value *LHS = CI->getOperand(1), *RHS = CI->getOperand(2); |
| 980 | |
| 981 | // If the two operands are the same, return zero. |
| 982 | if (LHS == RHS) { |
| 983 | // memcmp(s,s,x) -> 0 |
| 984 | CI->replaceAllUsesWith(Constant::getNullValue(CI->getType())); |
| 985 | CI->eraseFromParent(); |
| 986 | return true; |
| 987 | } |
| 988 | |
| 989 | // Make sure we have a constant length. |
| 990 | ConstantInt *LenC = dyn_cast<ConstantInt>(CI->getOperand(3)); |
| 991 | if (!LenC) return false; |
Reid Spencer | b83eb64 | 2006-10-20 07:07:24 +0000 | [diff] [blame] | 992 | uint64_t Len = LenC->getZExtValue(); |
Chris Lattner | c330069 | 2005-09-29 04:54:20 +0000 | [diff] [blame] | 993 | |
| 994 | // If the length is zero, this returns 0. |
| 995 | switch (Len) { |
| 996 | case 0: |
| 997 | // memcmp(s1,s2,0) -> 0 |
| 998 | CI->replaceAllUsesWith(Constant::getNullValue(CI->getType())); |
| 999 | CI->eraseFromParent(); |
| 1000 | return true; |
| 1001 | case 1: { |
| 1002 | // memcmp(S1,S2,1) -> *(ubyte*)S1 - *(ubyte*)S2 |
| 1003 | const Type *UCharPtr = PointerType::get(Type::UByteTy); |
Reid Spencer | 3da59db | 2006-11-27 01:05:10 +0000 | [diff] [blame^] | 1004 | CastInst *Op1Cast = CastInst::create( |
| 1005 | Instruction::BitCast, LHS, UCharPtr, LHS->getName(), CI); |
| 1006 | CastInst *Op2Cast = CastInst::create( |
| 1007 | Instruction::BitCast, RHS, UCharPtr, RHS->getName(), CI); |
Chris Lattner | c330069 | 2005-09-29 04:54:20 +0000 | [diff] [blame] | 1008 | Value *S1V = new LoadInst(Op1Cast, LHS->getName()+".val", CI); |
| 1009 | Value *S2V = new LoadInst(Op2Cast, RHS->getName()+".val", CI); |
| 1010 | Value *RV = BinaryOperator::createSub(S1V, S2V, CI->getName()+".diff",CI); |
| 1011 | if (RV->getType() != CI->getType()) |
Reid Spencer | 3da59db | 2006-11-27 01:05:10 +0000 | [diff] [blame^] | 1012 | RV = CastInst::createInferredCast(RV, CI->getType(), RV->getName(), CI); |
Chris Lattner | c330069 | 2005-09-29 04:54:20 +0000 | [diff] [blame] | 1013 | CI->replaceAllUsesWith(RV); |
| 1014 | CI->eraseFromParent(); |
| 1015 | return true; |
| 1016 | } |
| 1017 | case 2: |
| 1018 | if (IsOnlyUsedInEqualsZeroComparison(CI)) { |
| 1019 | // TODO: IF both are aligned, use a short load/compare. |
| 1020 | |
| 1021 | // memcmp(S1,S2,2) -> S1[0]-S2[0] | S1[1]-S2[1] iff only ==/!= 0 matters |
| 1022 | const Type *UCharPtr = PointerType::get(Type::UByteTy); |
Reid Spencer | 3da59db | 2006-11-27 01:05:10 +0000 | [diff] [blame^] | 1023 | CastInst *Op1Cast = CastInst::create( |
| 1024 | Instruction::BitCast, LHS, UCharPtr, LHS->getName(), CI); |
| 1025 | CastInst *Op2Cast = CastInst::create( |
| 1026 | Instruction::BitCast, RHS, UCharPtr, RHS->getName(), CI); |
Chris Lattner | c330069 | 2005-09-29 04:54:20 +0000 | [diff] [blame] | 1027 | Value *S1V1 = new LoadInst(Op1Cast, LHS->getName()+".val1", CI); |
| 1028 | Value *S2V1 = new LoadInst(Op2Cast, RHS->getName()+".val1", CI); |
| 1029 | Value *D1 = BinaryOperator::createSub(S1V1, S2V1, |
| 1030 | CI->getName()+".d1", CI); |
| 1031 | Constant *One = ConstantInt::get(Type::IntTy, 1); |
| 1032 | Value *G1 = new GetElementPtrInst(Op1Cast, One, "next1v", CI); |
| 1033 | Value *G2 = new GetElementPtrInst(Op2Cast, One, "next2v", CI); |
| 1034 | Value *S1V2 = new LoadInst(G1, LHS->getName()+".val2", CI); |
Chris Lattner | 2144c25 | 2006-05-12 23:35:26 +0000 | [diff] [blame] | 1035 | Value *S2V2 = new LoadInst(G2, RHS->getName()+".val2", CI); |
Chris Lattner | c330069 | 2005-09-29 04:54:20 +0000 | [diff] [blame] | 1036 | Value *D2 = BinaryOperator::createSub(S1V2, S2V2, |
| 1037 | CI->getName()+".d1", CI); |
| 1038 | Value *Or = BinaryOperator::createOr(D1, D2, CI->getName()+".res", CI); |
| 1039 | if (Or->getType() != CI->getType()) |
Reid Spencer | 3da59db | 2006-11-27 01:05:10 +0000 | [diff] [blame^] | 1040 | Or = CastInst::createInferredCast(Or, CI->getType(), Or->getName(), |
| 1041 | CI); |
Chris Lattner | c330069 | 2005-09-29 04:54:20 +0000 | [diff] [blame] | 1042 | CI->replaceAllUsesWith(Or); |
| 1043 | CI->eraseFromParent(); |
| 1044 | return true; |
| 1045 | } |
| 1046 | break; |
| 1047 | default: |
| 1048 | break; |
| 1049 | } |
| 1050 | |
Chris Lattner | c330069 | 2005-09-29 04:54:20 +0000 | [diff] [blame] | 1051 | return false; |
| 1052 | } |
| 1053 | } memcmpOptimizer; |
| 1054 | |
| 1055 | |
Jeff Cohen | 00b16889 | 2005-07-27 06:12:32 +0000 | [diff] [blame] | 1056 | /// This LibCallOptimization will simplify a call to the memcpy library |
| 1057 | /// function by expanding it out to a single store of size 0, 1, 2, 4, or 8 |
Reid Spencer | 716f49e | 2005-04-27 21:29:20 +0000 | [diff] [blame] | 1058 | /// bytes depending on the length of the string and the alignment. Additional |
| 1059 | /// optimizations are possible in code generation (sequence of immediate store) |
Reid Spencer | 6cc0311 | 2005-04-25 21:11:48 +0000 | [diff] [blame] | 1060 | /// @brief Simplify the memcpy library function. |
Chris Lattner | aecb062 | 2006-03-03 01:30:23 +0000 | [diff] [blame] | 1061 | struct LLVMMemCpyMoveOptzn : public LibCallOptimization { |
| 1062 | LLVMMemCpyMoveOptzn(const char* fname, const char* desc) |
| 1063 | : LibCallOptimization(fname, desc) {} |
Reid Spencer | 6cc0311 | 2005-04-25 21:11:48 +0000 | [diff] [blame] | 1064 | |
| 1065 | /// @brief Make sure that the "memcpy" function has the right prototype |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 1066 | virtual bool ValidateCalledFunction(const Function* f, SimplifyLibCalls& TD) { |
Reid Spencer | fcbdb9c | 2005-04-26 19:13:17 +0000 | [diff] [blame] | 1067 | // Just make sure this has 4 arguments per LLVM spec. |
Reid Spencer | 8f13261 | 2005-04-26 23:02:16 +0000 | [diff] [blame] | 1068 | return (f->arg_size() == 4); |
Reid Spencer | 6cc0311 | 2005-04-25 21:11:48 +0000 | [diff] [blame] | 1069 | } |
| 1070 | |
Reid Spencer | 20754ac | 2005-04-26 07:45:18 +0000 | [diff] [blame] | 1071 | /// Because of alignment and instruction information that we don't have, we |
| 1072 | /// leave the bulk of this to the code generators. The optimization here just |
| 1073 | /// deals with a few degenerate cases where the length of the string and the |
| 1074 | /// alignment match the sizes of our intrinsic types so we can do a load and |
| 1075 | /// store instead of the memcpy call. |
| 1076 | /// @brief Perform the memcpy optimization. |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 1077 | virtual bool OptimizeCall(CallInst* ci, SimplifyLibCalls& TD) { |
Reid Spencer | 43fd4d0 | 2005-04-26 19:55:57 +0000 | [diff] [blame] | 1078 | // Make sure we have constant int values to work with |
| 1079 | ConstantInt* LEN = dyn_cast<ConstantInt>(ci->getOperand(3)); |
| 1080 | if (!LEN) |
| 1081 | return false; |
| 1082 | ConstantInt* ALIGN = dyn_cast<ConstantInt>(ci->getOperand(4)); |
| 1083 | if (!ALIGN) |
| 1084 | return false; |
| 1085 | |
| 1086 | // If the length is larger than the alignment, we can't optimize |
Reid Spencer | b83eb64 | 2006-10-20 07:07:24 +0000 | [diff] [blame] | 1087 | uint64_t len = LEN->getZExtValue(); |
| 1088 | uint64_t alignment = ALIGN->getZExtValue(); |
Reid Spencer | 21506ff | 2005-05-03 07:23:44 +0000 | [diff] [blame] | 1089 | if (alignment == 0) |
| 1090 | alignment = 1; // Alignment 0 is identity for alignment 1 |
Reid Spencer | fcbdb9c | 2005-04-26 19:13:17 +0000 | [diff] [blame] | 1091 | if (len > alignment) |
Reid Spencer | 20754ac | 2005-04-26 07:45:18 +0000 | [diff] [blame] | 1092 | return false; |
| 1093 | |
Reid Spencer | 3f7d8c6 | 2005-04-27 17:46:54 +0000 | [diff] [blame] | 1094 | // Get the type we will cast to, based on size of the string |
Reid Spencer | 20754ac | 2005-04-26 07:45:18 +0000 | [diff] [blame] | 1095 | Value* dest = ci->getOperand(1); |
| 1096 | Value* src = ci->getOperand(2); |
Reid Spencer | 3f7d8c6 | 2005-04-27 17:46:54 +0000 | [diff] [blame] | 1097 | Type* castType = 0; |
Reid Spencer | 20754ac | 2005-04-26 07:45:18 +0000 | [diff] [blame] | 1098 | switch (len) |
| 1099 | { |
Reid Spencer | fcbdb9c | 2005-04-26 19:13:17 +0000 | [diff] [blame] | 1100 | case 0: |
Reid Spencer | ff5525d | 2005-04-29 09:39:47 +0000 | [diff] [blame] | 1101 | // memcpy(d,s,0,a) -> noop |
Reid Spencer | fcbdb9c | 2005-04-26 19:13:17 +0000 | [diff] [blame] | 1102 | ci->eraseFromParent(); |
| 1103 | return true; |
Reid Spencer | 3f7d8c6 | 2005-04-27 17:46:54 +0000 | [diff] [blame] | 1104 | case 1: castType = Type::SByteTy; break; |
| 1105 | case 2: castType = Type::ShortTy; break; |
| 1106 | case 4: castType = Type::IntTy; break; |
| 1107 | case 8: castType = Type::LongTy; break; |
Reid Spencer | 20754ac | 2005-04-26 07:45:18 +0000 | [diff] [blame] | 1108 | default: |
| 1109 | return false; |
| 1110 | } |
Reid Spencer | 3f7d8c6 | 2005-04-27 17:46:54 +0000 | [diff] [blame] | 1111 | |
| 1112 | // Cast source and dest to the right sized primitive and then load/store |
Reid Spencer | 3da59db | 2006-11-27 01:05:10 +0000 | [diff] [blame^] | 1113 | CastInst* SrcCast = CastInst::create(Instruction::BitCast, |
| 1114 | src, PointerType::get(castType), src->getName()+".cast", ci); |
| 1115 | CastInst* DestCast = CastInst::create(Instruction::BitCast, |
| 1116 | dest, PointerType::get(castType),dest->getName()+".cast", ci); |
Reid Spencer | 3f7d8c6 | 2005-04-27 17:46:54 +0000 | [diff] [blame] | 1117 | LoadInst* LI = new LoadInst(SrcCast,SrcCast->getName()+".val",ci); |
Reid Spencer | 3ed469c | 2006-11-02 20:25:50 +0000 | [diff] [blame] | 1118 | new StoreInst(LI, DestCast, ci); |
Reid Spencer | 20754ac | 2005-04-26 07:45:18 +0000 | [diff] [blame] | 1119 | ci->eraseFromParent(); |
| 1120 | return true; |
Reid Spencer | 6cc0311 | 2005-04-25 21:11:48 +0000 | [diff] [blame] | 1121 | } |
Chris Lattner | aecb062 | 2006-03-03 01:30:23 +0000 | [diff] [blame] | 1122 | }; |
Reid Spencer | fcbdb9c | 2005-04-26 19:13:17 +0000 | [diff] [blame] | 1123 | |
Chris Lattner | aecb062 | 2006-03-03 01:30:23 +0000 | [diff] [blame] | 1124 | /// This LibCallOptimization will simplify a call to the memcpy/memmove library |
| 1125 | /// functions. |
| 1126 | LLVMMemCpyMoveOptzn LLVMMemCpyOptimizer32("llvm.memcpy.i32", |
| 1127 | "Number of 'llvm.memcpy' calls simplified"); |
| 1128 | LLVMMemCpyMoveOptzn LLVMMemCpyOptimizer64("llvm.memcpy.i64", |
| 1129 | "Number of 'llvm.memcpy' calls simplified"); |
| 1130 | LLVMMemCpyMoveOptzn LLVMMemMoveOptimizer32("llvm.memmove.i32", |
| 1131 | "Number of 'llvm.memmove' calls simplified"); |
| 1132 | LLVMMemCpyMoveOptzn LLVMMemMoveOptimizer64("llvm.memmove.i64", |
| 1133 | "Number of 'llvm.memmove' calls simplified"); |
Reid Spencer | 21506ff | 2005-05-03 07:23:44 +0000 | [diff] [blame] | 1134 | |
Jeff Cohen | 00b16889 | 2005-07-27 06:12:32 +0000 | [diff] [blame] | 1135 | /// This LibCallOptimization will simplify a call to the memset library |
| 1136 | /// function by expanding it out to a single store of size 0, 1, 2, 4, or 8 |
| 1137 | /// bytes depending on the length argument. |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 1138 | struct LLVMMemSetOptimization : public LibCallOptimization { |
Reid Spencer | 21506ff | 2005-05-03 07:23:44 +0000 | [diff] [blame] | 1139 | /// @brief Default Constructor |
Chris Lattner | aecb062 | 2006-03-03 01:30:23 +0000 | [diff] [blame] | 1140 | LLVMMemSetOptimization(const char *Name) : LibCallOptimization(Name, |
Reid Spencer | 21506ff | 2005-05-03 07:23:44 +0000 | [diff] [blame] | 1141 | "Number of 'llvm.memset' calls simplified") {} |
Reid Spencer | 21506ff | 2005-05-03 07:23:44 +0000 | [diff] [blame] | 1142 | |
| 1143 | /// @brief Make sure that the "memset" function has the right prototype |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 1144 | virtual bool ValidateCalledFunction(const Function *F, SimplifyLibCalls &TD) { |
Reid Spencer | 21506ff | 2005-05-03 07:23:44 +0000 | [diff] [blame] | 1145 | // Just make sure this has 3 arguments per LLVM spec. |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 1146 | return F->arg_size() == 4; |
Reid Spencer | 21506ff | 2005-05-03 07:23:44 +0000 | [diff] [blame] | 1147 | } |
| 1148 | |
| 1149 | /// Because of alignment and instruction information that we don't have, we |
| 1150 | /// leave the bulk of this to the code generators. The optimization here just |
| 1151 | /// deals with a few degenerate cases where the length parameter is constant |
Jeff Cohen | 00b16889 | 2005-07-27 06:12:32 +0000 | [diff] [blame] | 1152 | /// and the alignment matches the sizes of our intrinsic types so we can do |
Reid Spencer | 21506ff | 2005-05-03 07:23:44 +0000 | [diff] [blame] | 1153 | /// store instead of the memcpy call. Other calls are transformed into the |
| 1154 | /// llvm.memset intrinsic. |
| 1155 | /// @brief Perform the memset optimization. |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 1156 | virtual bool OptimizeCall(CallInst *ci, SimplifyLibCalls &TD) { |
Reid Spencer | 21506ff | 2005-05-03 07:23:44 +0000 | [diff] [blame] | 1157 | // Make sure we have constant int values to work with |
| 1158 | ConstantInt* LEN = dyn_cast<ConstantInt>(ci->getOperand(3)); |
| 1159 | if (!LEN) |
| 1160 | return false; |
| 1161 | ConstantInt* ALIGN = dyn_cast<ConstantInt>(ci->getOperand(4)); |
| 1162 | if (!ALIGN) |
| 1163 | return false; |
| 1164 | |
| 1165 | // Extract the length and alignment |
Reid Spencer | b83eb64 | 2006-10-20 07:07:24 +0000 | [diff] [blame] | 1166 | uint64_t len = LEN->getZExtValue(); |
| 1167 | uint64_t alignment = ALIGN->getZExtValue(); |
Reid Spencer | 21506ff | 2005-05-03 07:23:44 +0000 | [diff] [blame] | 1168 | |
| 1169 | // Alignment 0 is identity for alignment 1 |
| 1170 | if (alignment == 0) |
| 1171 | alignment = 1; |
| 1172 | |
| 1173 | // If the length is zero, this is a no-op |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 1174 | if (len == 0) { |
Reid Spencer | 21506ff | 2005-05-03 07:23:44 +0000 | [diff] [blame] | 1175 | // memset(d,c,0,a) -> noop |
| 1176 | ci->eraseFromParent(); |
| 1177 | return true; |
| 1178 | } |
| 1179 | |
| 1180 | // If the length is larger than the alignment, we can't optimize |
| 1181 | if (len > alignment) |
| 1182 | return false; |
| 1183 | |
| 1184 | // Make sure we have a constant ubyte to work with so we can extract |
| 1185 | // the value to be filled. |
Reid Spencer | b83eb64 | 2006-10-20 07:07:24 +0000 | [diff] [blame] | 1186 | ConstantInt* FILL = dyn_cast<ConstantInt>(ci->getOperand(2)); |
Reid Spencer | 21506ff | 2005-05-03 07:23:44 +0000 | [diff] [blame] | 1187 | if (!FILL) |
| 1188 | return false; |
| 1189 | if (FILL->getType() != Type::UByteTy) |
| 1190 | return false; |
| 1191 | |
| 1192 | // memset(s,c,n) -> store s, c (for n=1,2,4,8) |
Jeff Cohen | 00b16889 | 2005-07-27 06:12:32 +0000 | [diff] [blame] | 1193 | |
Reid Spencer | 21506ff | 2005-05-03 07:23:44 +0000 | [diff] [blame] | 1194 | // Extract the fill character |
Reid Spencer | b83eb64 | 2006-10-20 07:07:24 +0000 | [diff] [blame] | 1195 | uint64_t fill_char = FILL->getZExtValue(); |
Reid Spencer | 21506ff | 2005-05-03 07:23:44 +0000 | [diff] [blame] | 1196 | uint64_t fill_value = fill_char; |
| 1197 | |
| 1198 | // Get the type we will cast to, based on size of memory area to fill, and |
| 1199 | // and the value we will store there. |
| 1200 | Value* dest = ci->getOperand(1); |
| 1201 | Type* castType = 0; |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 1202 | switch (len) { |
Jeff Cohen | 00b16889 | 2005-07-27 06:12:32 +0000 | [diff] [blame] | 1203 | case 1: |
| 1204 | castType = Type::UByteTy; |
Reid Spencer | 21506ff | 2005-05-03 07:23:44 +0000 | [diff] [blame] | 1205 | break; |
Jeff Cohen | 00b16889 | 2005-07-27 06:12:32 +0000 | [diff] [blame] | 1206 | case 2: |
| 1207 | castType = Type::UShortTy; |
Reid Spencer | 21506ff | 2005-05-03 07:23:44 +0000 | [diff] [blame] | 1208 | fill_value |= fill_char << 8; |
| 1209 | break; |
Jeff Cohen | 00b16889 | 2005-07-27 06:12:32 +0000 | [diff] [blame] | 1210 | case 4: |
Reid Spencer | 21506ff | 2005-05-03 07:23:44 +0000 | [diff] [blame] | 1211 | castType = Type::UIntTy; |
| 1212 | fill_value |= fill_char << 8 | fill_char << 16 | fill_char << 24; |
| 1213 | break; |
Jeff Cohen | 00b16889 | 2005-07-27 06:12:32 +0000 | [diff] [blame] | 1214 | case 8: |
Reid Spencer | 21506ff | 2005-05-03 07:23:44 +0000 | [diff] [blame] | 1215 | castType = Type::ULongTy; |
| 1216 | fill_value |= fill_char << 8 | fill_char << 16 | fill_char << 24; |
| 1217 | fill_value |= fill_char << 32 | fill_char << 40 | fill_char << 48; |
| 1218 | fill_value |= fill_char << 56; |
| 1219 | break; |
| 1220 | default: |
| 1221 | return false; |
| 1222 | } |
| 1223 | |
| 1224 | // Cast dest to the right sized primitive and then load/store |
Reid Spencer | 3da59db | 2006-11-27 01:05:10 +0000 | [diff] [blame^] | 1225 | CastInst* DestCast = CastInst::createInferredCast( |
| 1226 | dest, PointerType::get(castType), dest->getName()+".cast", ci); |
Reid Spencer | b83eb64 | 2006-10-20 07:07:24 +0000 | [diff] [blame] | 1227 | new StoreInst(ConstantInt::get(castType,fill_value),DestCast, ci); |
Reid Spencer | 21506ff | 2005-05-03 07:23:44 +0000 | [diff] [blame] | 1228 | ci->eraseFromParent(); |
| 1229 | return true; |
| 1230 | } |
Chris Lattner | aecb062 | 2006-03-03 01:30:23 +0000 | [diff] [blame] | 1231 | }; |
| 1232 | |
| 1233 | LLVMMemSetOptimization MemSet32Optimizer("llvm.memset.i32"); |
| 1234 | LLVMMemSetOptimization MemSet64Optimizer("llvm.memset.i64"); |
| 1235 | |
Reid Spencer | fcbdb9c | 2005-04-26 19:13:17 +0000 | [diff] [blame] | 1236 | |
Jeff Cohen | 00b16889 | 2005-07-27 06:12:32 +0000 | [diff] [blame] | 1237 | /// This LibCallOptimization will simplify calls to the "pow" library |
| 1238 | /// function. It looks for cases where the result of pow is well known and |
Reid Spencer | ff5525d | 2005-04-29 09:39:47 +0000 | [diff] [blame] | 1239 | /// substitutes the appropriate value. |
| 1240 | /// @brief Simplify the pow library function. |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 1241 | struct PowOptimization : public LibCallOptimization { |
Reid Spencer | ff5525d | 2005-04-29 09:39:47 +0000 | [diff] [blame] | 1242 | public: |
| 1243 | /// @brief Default Constructor |
Reid Spencer | 9974dda | 2005-05-03 02:54:54 +0000 | [diff] [blame] | 1244 | PowOptimization() : LibCallOptimization("pow", |
Reid Spencer | 789082a | 2005-05-07 20:15:59 +0000 | [diff] [blame] | 1245 | "Number of 'pow' calls simplified") {} |
Reid Spencer | 9974dda | 2005-05-03 02:54:54 +0000 | [diff] [blame] | 1246 | |
Reid Spencer | ff5525d | 2005-04-29 09:39:47 +0000 | [diff] [blame] | 1247 | /// @brief Make sure that the "pow" function has the right prototype |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 1248 | virtual bool ValidateCalledFunction(const Function* f, SimplifyLibCalls& SLC){ |
Reid Spencer | ff5525d | 2005-04-29 09:39:47 +0000 | [diff] [blame] | 1249 | // Just make sure this has 2 arguments |
| 1250 | return (f->arg_size() == 2); |
| 1251 | } |
| 1252 | |
| 1253 | /// @brief Perform the pow optimization. |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 1254 | virtual bool OptimizeCall(CallInst *ci, SimplifyLibCalls &SLC) { |
Reid Spencer | ff5525d | 2005-04-29 09:39:47 +0000 | [diff] [blame] | 1255 | const Type *Ty = cast<Function>(ci->getOperand(0))->getReturnType(); |
| 1256 | Value* base = ci->getOperand(1); |
| 1257 | Value* expn = ci->getOperand(2); |
| 1258 | if (ConstantFP *Op1 = dyn_cast<ConstantFP>(base)) { |
| 1259 | double Op1V = Op1->getValue(); |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 1260 | if (Op1V == 1.0) { |
Reid Spencer | ff5525d | 2005-04-29 09:39:47 +0000 | [diff] [blame] | 1261 | // pow(1.0,x) -> 1.0 |
| 1262 | ci->replaceAllUsesWith(ConstantFP::get(Ty,1.0)); |
| 1263 | ci->eraseFromParent(); |
| 1264 | return true; |
| 1265 | } |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 1266 | } else if (ConstantFP* Op2 = dyn_cast<ConstantFP>(expn)) { |
Reid Spencer | ff5525d | 2005-04-29 09:39:47 +0000 | [diff] [blame] | 1267 | double Op2V = Op2->getValue(); |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 1268 | if (Op2V == 0.0) { |
Reid Spencer | ff5525d | 2005-04-29 09:39:47 +0000 | [diff] [blame] | 1269 | // pow(x,0.0) -> 1.0 |
| 1270 | ci->replaceAllUsesWith(ConstantFP::get(Ty,1.0)); |
| 1271 | ci->eraseFromParent(); |
| 1272 | return true; |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 1273 | } else if (Op2V == 0.5) { |
Reid Spencer | ff5525d | 2005-04-29 09:39:47 +0000 | [diff] [blame] | 1274 | // pow(x,0.5) -> sqrt(x) |
| 1275 | CallInst* sqrt_inst = new CallInst(SLC.get_sqrt(), base, |
| 1276 | ci->getName()+".pow",ci); |
| 1277 | ci->replaceAllUsesWith(sqrt_inst); |
| 1278 | ci->eraseFromParent(); |
| 1279 | return true; |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 1280 | } else if (Op2V == 1.0) { |
Reid Spencer | ff5525d | 2005-04-29 09:39:47 +0000 | [diff] [blame] | 1281 | // pow(x,1.0) -> x |
| 1282 | ci->replaceAllUsesWith(base); |
| 1283 | ci->eraseFromParent(); |
| 1284 | return true; |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 1285 | } else if (Op2V == -1.0) { |
Reid Spencer | ff5525d | 2005-04-29 09:39:47 +0000 | [diff] [blame] | 1286 | // pow(x,-1.0) -> 1.0/x |
Reid Spencer | 1628cec | 2006-10-26 06:15:43 +0000 | [diff] [blame] | 1287 | BinaryOperator* div_inst= BinaryOperator::createFDiv( |
Reid Spencer | ff5525d | 2005-04-29 09:39:47 +0000 | [diff] [blame] | 1288 | ConstantFP::get(Ty,1.0), base, ci->getName()+".pow", ci); |
| 1289 | ci->replaceAllUsesWith(div_inst); |
| 1290 | ci->eraseFromParent(); |
| 1291 | return true; |
| 1292 | } |
| 1293 | } |
| 1294 | return false; // opt failed |
| 1295 | } |
| 1296 | } PowOptimizer; |
| 1297 | |
Evan Cheng | 21abac2 | 2006-06-16 08:36:35 +0000 | [diff] [blame] | 1298 | /// This LibCallOptimization will simplify calls to the "printf" library |
| 1299 | /// function. It looks for cases where the result of printf is not used and the |
| 1300 | /// operation can be reduced to something simpler. |
| 1301 | /// @brief Simplify the printf library function. |
| 1302 | struct PrintfOptimization : public LibCallOptimization { |
| 1303 | public: |
| 1304 | /// @brief Default Constructor |
| 1305 | PrintfOptimization() : LibCallOptimization("printf", |
| 1306 | "Number of 'printf' calls simplified") {} |
| 1307 | |
| 1308 | /// @brief Make sure that the "printf" function has the right prototype |
| 1309 | virtual bool ValidateCalledFunction(const Function* f, SimplifyLibCalls& SLC){ |
| 1310 | // Just make sure this has at least 1 arguments |
| 1311 | return (f->arg_size() >= 1); |
| 1312 | } |
| 1313 | |
| 1314 | /// @brief Perform the printf optimization. |
| 1315 | virtual bool OptimizeCall(CallInst* ci, SimplifyLibCalls& SLC) { |
| 1316 | // If the call has more than 2 operands, we can't optimize it |
| 1317 | if (ci->getNumOperands() > 3 || ci->getNumOperands() <= 2) |
| 1318 | return false; |
| 1319 | |
| 1320 | // If the result of the printf call is used, none of these optimizations |
| 1321 | // can be made. |
| 1322 | if (!ci->use_empty()) |
| 1323 | return false; |
| 1324 | |
| 1325 | // All the optimizations depend on the length of the first argument and the |
| 1326 | // fact that it is a constant string array. Check that now |
| 1327 | uint64_t len = 0; |
| 1328 | ConstantArray* CA = 0; |
| 1329 | if (!getConstantStringLength(ci->getOperand(1), len, &CA)) |
| 1330 | return false; |
| 1331 | |
| 1332 | if (len != 2 && len != 3) |
| 1333 | return false; |
| 1334 | |
| 1335 | // The first character has to be a % |
| 1336 | if (ConstantInt* CI = dyn_cast<ConstantInt>(CA->getOperand(0))) |
Reid Spencer | b83eb64 | 2006-10-20 07:07:24 +0000 | [diff] [blame] | 1337 | if (CI->getZExtValue() != '%') |
Evan Cheng | 21abac2 | 2006-06-16 08:36:35 +0000 | [diff] [blame] | 1338 | return false; |
| 1339 | |
| 1340 | // Get the second character and switch on its value |
| 1341 | ConstantInt* CI = dyn_cast<ConstantInt>(CA->getOperand(1)); |
Reid Spencer | b83eb64 | 2006-10-20 07:07:24 +0000 | [diff] [blame] | 1342 | switch (CI->getZExtValue()) { |
Evan Cheng | 21abac2 | 2006-06-16 08:36:35 +0000 | [diff] [blame] | 1343 | case 's': |
| 1344 | { |
| 1345 | if (len != 3 || |
Reid Spencer | b83eb64 | 2006-10-20 07:07:24 +0000 | [diff] [blame] | 1346 | dyn_cast<ConstantInt>(CA->getOperand(2))->getZExtValue() != '\n') |
Evan Cheng | 21abac2 | 2006-06-16 08:36:35 +0000 | [diff] [blame] | 1347 | return false; |
| 1348 | |
| 1349 | // printf("%s\n",str) -> puts(str) |
| 1350 | Function* puts_func = SLC.get_puts(); |
| 1351 | if (!puts_func) |
| 1352 | return false; |
| 1353 | std::vector<Value*> args; |
Evan Cheng | fb9d0dc | 2006-06-16 18:37:15 +0000 | [diff] [blame] | 1354 | args.push_back(CastToCStr(ci->getOperand(2), *ci)); |
Evan Cheng | 21abac2 | 2006-06-16 08:36:35 +0000 | [diff] [blame] | 1355 | new CallInst(puts_func,args,ci->getName(),ci); |
Reid Spencer | b83eb64 | 2006-10-20 07:07:24 +0000 | [diff] [blame] | 1356 | ci->replaceAllUsesWith(ConstantInt::get(Type::IntTy,len)); |
Evan Cheng | 21abac2 | 2006-06-16 08:36:35 +0000 | [diff] [blame] | 1357 | break; |
| 1358 | } |
| 1359 | case 'c': |
| 1360 | { |
| 1361 | // printf("%c",c) -> putchar(c) |
| 1362 | if (len != 2) |
| 1363 | return false; |
| 1364 | |
| 1365 | Function* putchar_func = SLC.get_putchar(); |
| 1366 | if (!putchar_func) |
| 1367 | return false; |
Reid Spencer | 3da59db | 2006-11-27 01:05:10 +0000 | [diff] [blame^] | 1368 | CastInst* cast = CastInst::createInferredCast( |
| 1369 | ci->getOperand(2), Type::IntTy, CI->getName()+".int", ci); |
Evan Cheng | 21abac2 | 2006-06-16 08:36:35 +0000 | [diff] [blame] | 1370 | new CallInst(putchar_func, cast, "", ci); |
Reid Spencer | b83eb64 | 2006-10-20 07:07:24 +0000 | [diff] [blame] | 1371 | ci->replaceAllUsesWith(ConstantInt::get(Type::IntTy, 1)); |
Evan Cheng | 21abac2 | 2006-06-16 08:36:35 +0000 | [diff] [blame] | 1372 | break; |
| 1373 | } |
| 1374 | default: |
| 1375 | return false; |
| 1376 | } |
| 1377 | ci->eraseFromParent(); |
| 1378 | return true; |
| 1379 | } |
| 1380 | } PrintfOptimizer; |
| 1381 | |
Jeff Cohen | 00b16889 | 2005-07-27 06:12:32 +0000 | [diff] [blame] | 1382 | /// This LibCallOptimization will simplify calls to the "fprintf" library |
Reid Spencer | a1b4390 | 2005-05-02 23:59:26 +0000 | [diff] [blame] | 1383 | /// function. It looks for cases where the result of fprintf is not used and the |
| 1384 | /// operation can be reduced to something simpler. |
Evan Cheng | 21abac2 | 2006-06-16 08:36:35 +0000 | [diff] [blame] | 1385 | /// @brief Simplify the fprintf library function. |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 1386 | struct FPrintFOptimization : public LibCallOptimization { |
Reid Spencer | a1b4390 | 2005-05-02 23:59:26 +0000 | [diff] [blame] | 1387 | public: |
| 1388 | /// @brief Default Constructor |
Reid Spencer | 9974dda | 2005-05-03 02:54:54 +0000 | [diff] [blame] | 1389 | FPrintFOptimization() : LibCallOptimization("fprintf", |
Reid Spencer | 789082a | 2005-05-07 20:15:59 +0000 | [diff] [blame] | 1390 | "Number of 'fprintf' calls simplified") {} |
Reid Spencer | a1b4390 | 2005-05-02 23:59:26 +0000 | [diff] [blame] | 1391 | |
Reid Spencer | a1b4390 | 2005-05-02 23:59:26 +0000 | [diff] [blame] | 1392 | /// @brief Make sure that the "fprintf" function has the right prototype |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 1393 | virtual bool ValidateCalledFunction(const Function* f, SimplifyLibCalls& SLC){ |
Reid Spencer | a1b4390 | 2005-05-02 23:59:26 +0000 | [diff] [blame] | 1394 | // Just make sure this has at least 2 arguments |
| 1395 | return (f->arg_size() >= 2); |
| 1396 | } |
| 1397 | |
| 1398 | /// @brief Perform the fprintf optimization. |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 1399 | virtual bool OptimizeCall(CallInst* ci, SimplifyLibCalls& SLC) { |
Reid Spencer | a1b4390 | 2005-05-02 23:59:26 +0000 | [diff] [blame] | 1400 | // If the call has more than 3 operands, we can't optimize it |
| 1401 | if (ci->getNumOperands() > 4 || ci->getNumOperands() <= 2) |
| 1402 | return false; |
| 1403 | |
Jeff Cohen | 00b16889 | 2005-07-27 06:12:32 +0000 | [diff] [blame] | 1404 | // If the result of the fprintf call is used, none of these optimizations |
Reid Spencer | a1b4390 | 2005-05-02 23:59:26 +0000 | [diff] [blame] | 1405 | // can be made. |
Chris Lattner | 5d735bf | 2005-09-24 22:17:06 +0000 | [diff] [blame] | 1406 | if (!ci->use_empty()) |
Reid Spencer | a1b4390 | 2005-05-02 23:59:26 +0000 | [diff] [blame] | 1407 | return false; |
| 1408 | |
| 1409 | // All the optimizations depend on the length of the second argument and the |
| 1410 | // fact that it is a constant string array. Check that now |
Jeff Cohen | 00b16889 | 2005-07-27 06:12:32 +0000 | [diff] [blame] | 1411 | uint64_t len = 0; |
Reid Spencer | a1b4390 | 2005-05-02 23:59:26 +0000 | [diff] [blame] | 1412 | ConstantArray* CA = 0; |
| 1413 | if (!getConstantStringLength(ci->getOperand(2), len, &CA)) |
| 1414 | return false; |
| 1415 | |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 1416 | if (ci->getNumOperands() == 3) { |
Reid Spencer | a1b4390 | 2005-05-02 23:59:26 +0000 | [diff] [blame] | 1417 | // Make sure there's no % in the constant array |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 1418 | for (unsigned i = 0; i < len; ++i) { |
| 1419 | if (ConstantInt* CI = dyn_cast<ConstantInt>(CA->getOperand(i))) { |
Reid Spencer | a1b4390 | 2005-05-02 23:59:26 +0000 | [diff] [blame] | 1420 | // Check for the null terminator |
Reid Spencer | b83eb64 | 2006-10-20 07:07:24 +0000 | [diff] [blame] | 1421 | if (CI->getZExtValue() == '%') |
Reid Spencer | a1b4390 | 2005-05-02 23:59:26 +0000 | [diff] [blame] | 1422 | return false; // we found end of string |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 1423 | } else { |
Reid Spencer | a1b4390 | 2005-05-02 23:59:26 +0000 | [diff] [blame] | 1424 | return false; |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 1425 | } |
Reid Spencer | a1b4390 | 2005-05-02 23:59:26 +0000 | [diff] [blame] | 1426 | } |
| 1427 | |
Jeff Cohen | 00b16889 | 2005-07-27 06:12:32 +0000 | [diff] [blame] | 1428 | // fprintf(file,fmt) -> fwrite(fmt,strlen(fmt),file) |
Reid Spencer | a1b4390 | 2005-05-02 23:59:26 +0000 | [diff] [blame] | 1429 | const Type* FILEptr_type = ci->getOperand(1)->getType(); |
| 1430 | Function* fwrite_func = SLC.get_fwrite(FILEptr_type); |
| 1431 | if (!fwrite_func) |
| 1432 | return false; |
John Criswell | 1d231ec | 2005-06-29 15:03:18 +0000 | [diff] [blame] | 1433 | |
| 1434 | // Make sure that the fprintf() and fwrite() functions both take the |
| 1435 | // same type of char pointer. |
| 1436 | if (ci->getOperand(2)->getType() != |
| 1437 | fwrite_func->getFunctionType()->getParamType(0)) |
John Criswell | 1d231ec | 2005-06-29 15:03:18 +0000 | [diff] [blame] | 1438 | return false; |
John Criswell | 1d231ec | 2005-06-29 15:03:18 +0000 | [diff] [blame] | 1439 | |
Reid Spencer | a1b4390 | 2005-05-02 23:59:26 +0000 | [diff] [blame] | 1440 | std::vector<Value*> args; |
| 1441 | args.push_back(ci->getOperand(2)); |
Reid Spencer | b83eb64 | 2006-10-20 07:07:24 +0000 | [diff] [blame] | 1442 | args.push_back(ConstantInt::get(SLC.getIntPtrType(),len)); |
| 1443 | args.push_back(ConstantInt::get(SLC.getIntPtrType(),1)); |
Reid Spencer | a1b4390 | 2005-05-02 23:59:26 +0000 | [diff] [blame] | 1444 | args.push_back(ci->getOperand(1)); |
Reid Spencer | 58b563c | 2005-05-04 03:20:21 +0000 | [diff] [blame] | 1445 | new CallInst(fwrite_func,args,ci->getName(),ci); |
Reid Spencer | b83eb64 | 2006-10-20 07:07:24 +0000 | [diff] [blame] | 1446 | ci->replaceAllUsesWith(ConstantInt::get(Type::IntTy,len)); |
Reid Spencer | a1b4390 | 2005-05-02 23:59:26 +0000 | [diff] [blame] | 1447 | ci->eraseFromParent(); |
| 1448 | return true; |
| 1449 | } |
| 1450 | |
| 1451 | // The remaining optimizations require the format string to be length 2 |
| 1452 | // "%s" or "%c". |
| 1453 | if (len != 2) |
| 1454 | return false; |
| 1455 | |
| 1456 | // The first character has to be a % |
| 1457 | if (ConstantInt* CI = dyn_cast<ConstantInt>(CA->getOperand(0))) |
Reid Spencer | b83eb64 | 2006-10-20 07:07:24 +0000 | [diff] [blame] | 1458 | if (CI->getZExtValue() != '%') |
Reid Spencer | a1b4390 | 2005-05-02 23:59:26 +0000 | [diff] [blame] | 1459 | return false; |
| 1460 | |
| 1461 | // Get the second character and switch on its value |
| 1462 | ConstantInt* CI = dyn_cast<ConstantInt>(CA->getOperand(1)); |
Reid Spencer | b83eb64 | 2006-10-20 07:07:24 +0000 | [diff] [blame] | 1463 | switch (CI->getZExtValue()) { |
Reid Spencer | a1b4390 | 2005-05-02 23:59:26 +0000 | [diff] [blame] | 1464 | case 's': |
| 1465 | { |
Jeff Cohen | 00b16889 | 2005-07-27 06:12:32 +0000 | [diff] [blame] | 1466 | uint64_t len = 0; |
Reid Spencer | a1b4390 | 2005-05-02 23:59:26 +0000 | [diff] [blame] | 1467 | ConstantArray* CA = 0; |
Evan Cheng | 9528952 | 2006-06-16 04:52:30 +0000 | [diff] [blame] | 1468 | if (getConstantStringLength(ci->getOperand(3), len, &CA)) { |
| 1469 | // fprintf(file,"%s",str) -> fwrite(str,strlen(str),1,file) |
| 1470 | const Type* FILEptr_type = ci->getOperand(1)->getType(); |
| 1471 | Function* fwrite_func = SLC.get_fwrite(FILEptr_type); |
| 1472 | if (!fwrite_func) |
| 1473 | return false; |
| 1474 | std::vector<Value*> args; |
| 1475 | args.push_back(CastToCStr(ci->getOperand(3), *ci)); |
Reid Spencer | b83eb64 | 2006-10-20 07:07:24 +0000 | [diff] [blame] | 1476 | args.push_back(ConstantInt::get(SLC.getIntPtrType(),len)); |
| 1477 | args.push_back(ConstantInt::get(SLC.getIntPtrType(),1)); |
Evan Cheng | 9528952 | 2006-06-16 04:52:30 +0000 | [diff] [blame] | 1478 | args.push_back(ci->getOperand(1)); |
| 1479 | new CallInst(fwrite_func,args,ci->getName(),ci); |
Reid Spencer | b83eb64 | 2006-10-20 07:07:24 +0000 | [diff] [blame] | 1480 | ci->replaceAllUsesWith(ConstantInt::get(Type::IntTy,len)); |
Evan Cheng | 9528952 | 2006-06-16 04:52:30 +0000 | [diff] [blame] | 1481 | } else { |
| 1482 | // fprintf(file,"%s",str) -> fputs(str,file) |
| 1483 | const Type* FILEptr_type = ci->getOperand(1)->getType(); |
| 1484 | Function* fputs_func = SLC.get_fputs(FILEptr_type); |
| 1485 | if (!fputs_func) |
| 1486 | return false; |
| 1487 | std::vector<Value*> args; |
Evan Cheng | fb9d0dc | 2006-06-16 18:37:15 +0000 | [diff] [blame] | 1488 | args.push_back(CastToCStr(ci->getOperand(3), *ci)); |
Evan Cheng | 9528952 | 2006-06-16 04:52:30 +0000 | [diff] [blame] | 1489 | args.push_back(ci->getOperand(1)); |
| 1490 | new CallInst(fputs_func,args,ci->getName(),ci); |
Reid Spencer | b83eb64 | 2006-10-20 07:07:24 +0000 | [diff] [blame] | 1491 | ci->replaceAllUsesWith(ConstantInt::get(Type::IntTy,len)); |
Evan Cheng | 9528952 | 2006-06-16 04:52:30 +0000 | [diff] [blame] | 1492 | } |
Reid Spencer | a1b4390 | 2005-05-02 23:59:26 +0000 | [diff] [blame] | 1493 | break; |
| 1494 | } |
| 1495 | case 'c': |
| 1496 | { |
Evan Cheng | 21abac2 | 2006-06-16 08:36:35 +0000 | [diff] [blame] | 1497 | // fprintf(file,"%c",c) -> fputc(c,file) |
Reid Spencer | a1b4390 | 2005-05-02 23:59:26 +0000 | [diff] [blame] | 1498 | const Type* FILEptr_type = ci->getOperand(1)->getType(); |
| 1499 | Function* fputc_func = SLC.get_fputc(FILEptr_type); |
| 1500 | if (!fputc_func) |
| 1501 | return false; |
Reid Spencer | 3da59db | 2006-11-27 01:05:10 +0000 | [diff] [blame^] | 1502 | CastInst* cast = CastInst::createInferredCast( |
| 1503 | ci->getOperand(3), Type::IntTy, CI->getName()+".int", ci); |
Reid Spencer | a1b4390 | 2005-05-02 23:59:26 +0000 | [diff] [blame] | 1504 | new CallInst(fputc_func,cast,ci->getOperand(1),"",ci); |
Reid Spencer | b83eb64 | 2006-10-20 07:07:24 +0000 | [diff] [blame] | 1505 | ci->replaceAllUsesWith(ConstantInt::get(Type::IntTy,1)); |
Reid Spencer | a1b4390 | 2005-05-02 23:59:26 +0000 | [diff] [blame] | 1506 | break; |
| 1507 | } |
| 1508 | default: |
| 1509 | return false; |
| 1510 | } |
| 1511 | ci->eraseFromParent(); |
| 1512 | return true; |
| 1513 | } |
| 1514 | } FPrintFOptimizer; |
| 1515 | |
Jeff Cohen | 00b16889 | 2005-07-27 06:12:32 +0000 | [diff] [blame] | 1516 | /// This LibCallOptimization will simplify calls to the "sprintf" library |
Reid Spencer | 58b563c | 2005-05-04 03:20:21 +0000 | [diff] [blame] | 1517 | /// function. It looks for cases where the result of sprintf is not used and the |
| 1518 | /// operation can be reduced to something simpler. |
Evan Cheng | 21abac2 | 2006-06-16 08:36:35 +0000 | [diff] [blame] | 1519 | /// @brief Simplify the sprintf library function. |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 1520 | struct SPrintFOptimization : public LibCallOptimization { |
Reid Spencer | 58b563c | 2005-05-04 03:20:21 +0000 | [diff] [blame] | 1521 | public: |
| 1522 | /// @brief Default Constructor |
| 1523 | SPrintFOptimization() : LibCallOptimization("sprintf", |
Reid Spencer | 789082a | 2005-05-07 20:15:59 +0000 | [diff] [blame] | 1524 | "Number of 'sprintf' calls simplified") {} |
Reid Spencer | 58b563c | 2005-05-04 03:20:21 +0000 | [diff] [blame] | 1525 | |
Reid Spencer | 58b563c | 2005-05-04 03:20:21 +0000 | [diff] [blame] | 1526 | /// @brief Make sure that the "fprintf" function has the right prototype |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 1527 | virtual bool ValidateCalledFunction(const Function *f, SimplifyLibCalls &SLC){ |
Reid Spencer | 58b563c | 2005-05-04 03:20:21 +0000 | [diff] [blame] | 1528 | // Just make sure this has at least 2 arguments |
| 1529 | return (f->getReturnType() == Type::IntTy && f->arg_size() >= 2); |
| 1530 | } |
| 1531 | |
| 1532 | /// @brief Perform the sprintf optimization. |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 1533 | virtual bool OptimizeCall(CallInst *ci, SimplifyLibCalls &SLC) { |
Reid Spencer | 58b563c | 2005-05-04 03:20:21 +0000 | [diff] [blame] | 1534 | // If the call has more than 3 operands, we can't optimize it |
| 1535 | if (ci->getNumOperands() > 4 || ci->getNumOperands() < 3) |
| 1536 | return false; |
| 1537 | |
| 1538 | // All the optimizations depend on the length of the second argument and the |
| 1539 | // fact that it is a constant string array. Check that now |
Jeff Cohen | 00b16889 | 2005-07-27 06:12:32 +0000 | [diff] [blame] | 1540 | uint64_t len = 0; |
Reid Spencer | 58b563c | 2005-05-04 03:20:21 +0000 | [diff] [blame] | 1541 | ConstantArray* CA = 0; |
| 1542 | if (!getConstantStringLength(ci->getOperand(2), len, &CA)) |
| 1543 | return false; |
| 1544 | |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 1545 | if (ci->getNumOperands() == 3) { |
| 1546 | if (len == 0) { |
Reid Spencer | 58b563c | 2005-05-04 03:20:21 +0000 | [diff] [blame] | 1547 | // If the length is 0, we just need to store a null byte |
| 1548 | new StoreInst(ConstantInt::get(Type::SByteTy,0),ci->getOperand(1),ci); |
Reid Spencer | b83eb64 | 2006-10-20 07:07:24 +0000 | [diff] [blame] | 1549 | ci->replaceAllUsesWith(ConstantInt::get(Type::IntTy,0)); |
Reid Spencer | 58b563c | 2005-05-04 03:20:21 +0000 | [diff] [blame] | 1550 | ci->eraseFromParent(); |
| 1551 | return true; |
| 1552 | } |
| 1553 | |
| 1554 | // Make sure there's no % in the constant array |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 1555 | for (unsigned i = 0; i < len; ++i) { |
| 1556 | if (ConstantInt* CI = dyn_cast<ConstantInt>(CA->getOperand(i))) { |
Reid Spencer | 58b563c | 2005-05-04 03:20:21 +0000 | [diff] [blame] | 1557 | // Check for the null terminator |
Reid Spencer | b83eb64 | 2006-10-20 07:07:24 +0000 | [diff] [blame] | 1558 | if (CI->getZExtValue() == '%') |
Reid Spencer | 58b563c | 2005-05-04 03:20:21 +0000 | [diff] [blame] | 1559 | return false; // we found a %, can't optimize |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 1560 | } else { |
Reid Spencer | 58b563c | 2005-05-04 03:20:21 +0000 | [diff] [blame] | 1561 | return false; // initializer is not constant int, can't optimize |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 1562 | } |
Reid Spencer | 58b563c | 2005-05-04 03:20:21 +0000 | [diff] [blame] | 1563 | } |
| 1564 | |
| 1565 | // Increment length because we want to copy the null byte too |
| 1566 | len++; |
| 1567 | |
Jeff Cohen | 00b16889 | 2005-07-27 06:12:32 +0000 | [diff] [blame] | 1568 | // sprintf(str,fmt) -> llvm.memcpy(str,fmt,strlen(fmt),1) |
Reid Spencer | 58b563c | 2005-05-04 03:20:21 +0000 | [diff] [blame] | 1569 | Function* memcpy_func = SLC.get_memcpy(); |
| 1570 | if (!memcpy_func) |
| 1571 | return false; |
| 1572 | std::vector<Value*> args; |
| 1573 | args.push_back(ci->getOperand(1)); |
| 1574 | args.push_back(ci->getOperand(2)); |
Reid Spencer | b83eb64 | 2006-10-20 07:07:24 +0000 | [diff] [blame] | 1575 | args.push_back(ConstantInt::get(SLC.getIntPtrType(),len)); |
| 1576 | args.push_back(ConstantInt::get(Type::UIntTy,1)); |
Reid Spencer | 58b563c | 2005-05-04 03:20:21 +0000 | [diff] [blame] | 1577 | new CallInst(memcpy_func,args,"",ci); |
Reid Spencer | b83eb64 | 2006-10-20 07:07:24 +0000 | [diff] [blame] | 1578 | ci->replaceAllUsesWith(ConstantInt::get(Type::IntTy,len)); |
Reid Spencer | 58b563c | 2005-05-04 03:20:21 +0000 | [diff] [blame] | 1579 | ci->eraseFromParent(); |
| 1580 | return true; |
| 1581 | } |
| 1582 | |
| 1583 | // The remaining optimizations require the format string to be length 2 |
| 1584 | // "%s" or "%c". |
| 1585 | if (len != 2) |
| 1586 | return false; |
| 1587 | |
| 1588 | // The first character has to be a % |
| 1589 | if (ConstantInt* CI = dyn_cast<ConstantInt>(CA->getOperand(0))) |
Reid Spencer | b83eb64 | 2006-10-20 07:07:24 +0000 | [diff] [blame] | 1590 | if (CI->getZExtValue() != '%') |
Reid Spencer | 58b563c | 2005-05-04 03:20:21 +0000 | [diff] [blame] | 1591 | return false; |
| 1592 | |
| 1593 | // Get the second character and switch on its value |
| 1594 | ConstantInt* CI = dyn_cast<ConstantInt>(CA->getOperand(1)); |
Reid Spencer | b83eb64 | 2006-10-20 07:07:24 +0000 | [diff] [blame] | 1595 | switch (CI->getZExtValue()) { |
Chris Lattner | 5d735bf | 2005-09-24 22:17:06 +0000 | [diff] [blame] | 1596 | case 's': { |
| 1597 | // sprintf(dest,"%s",str) -> llvm.memcpy(dest, str, strlen(str)+1, 1) |
| 1598 | Function* strlen_func = SLC.get_strlen(); |
| 1599 | Function* memcpy_func = SLC.get_memcpy(); |
| 1600 | if (!strlen_func || !memcpy_func) |
Reid Spencer | 58b563c | 2005-05-04 03:20:21 +0000 | [diff] [blame] | 1601 | return false; |
Chris Lattner | 5d735bf | 2005-09-24 22:17:06 +0000 | [diff] [blame] | 1602 | |
| 1603 | Value *Len = new CallInst(strlen_func, CastToCStr(ci->getOperand(3), *ci), |
| 1604 | ci->getOperand(3)->getName()+".len", ci); |
| 1605 | Value *Len1 = BinaryOperator::createAdd(Len, |
| 1606 | ConstantInt::get(Len->getType(), 1), |
| 1607 | Len->getName()+"1", ci); |
Andrew Lenharth | 2f98594 | 2006-02-15 21:13:37 +0000 | [diff] [blame] | 1608 | if (Len1->getType() != SLC.getIntPtrType()) |
Reid Spencer | 3da59db | 2006-11-27 01:05:10 +0000 | [diff] [blame^] | 1609 | Len1 = CastInst::createInferredCast( |
| 1610 | Len1, SLC.getIntPtrType(), Len1->getName(), ci); |
Chris Lattner | 5d735bf | 2005-09-24 22:17:06 +0000 | [diff] [blame] | 1611 | std::vector<Value*> args; |
| 1612 | args.push_back(CastToCStr(ci->getOperand(1), *ci)); |
| 1613 | args.push_back(CastToCStr(ci->getOperand(3), *ci)); |
| 1614 | args.push_back(Len1); |
Reid Spencer | b83eb64 | 2006-10-20 07:07:24 +0000 | [diff] [blame] | 1615 | args.push_back(ConstantInt::get(Type::UIntTy,1)); |
Chris Lattner | 5d735bf | 2005-09-24 22:17:06 +0000 | [diff] [blame] | 1616 | new CallInst(memcpy_func, args, "", ci); |
| 1617 | |
| 1618 | // The strlen result is the unincremented number of bytes in the string. |
Chris Lattner | aebac50 | 2005-09-25 07:06:48 +0000 | [diff] [blame] | 1619 | if (!ci->use_empty()) { |
| 1620 | if (Len->getType() != ci->getType()) |
Reid Spencer | 3da59db | 2006-11-27 01:05:10 +0000 | [diff] [blame^] | 1621 | Len = CastInst::createInferredCast( |
| 1622 | Len, ci->getType(), Len->getName(), ci); |
Chris Lattner | aebac50 | 2005-09-25 07:06:48 +0000 | [diff] [blame] | 1623 | ci->replaceAllUsesWith(Len); |
| 1624 | } |
Chris Lattner | 5d735bf | 2005-09-24 22:17:06 +0000 | [diff] [blame] | 1625 | ci->eraseFromParent(); |
| 1626 | return true; |
Reid Spencer | 58b563c | 2005-05-04 03:20:21 +0000 | [diff] [blame] | 1627 | } |
Chris Lattner | 5d735bf | 2005-09-24 22:17:06 +0000 | [diff] [blame] | 1628 | case 'c': { |
| 1629 | // sprintf(dest,"%c",chr) -> store chr, dest |
Reid Spencer | 3da59db | 2006-11-27 01:05:10 +0000 | [diff] [blame^] | 1630 | CastInst* cast = CastInst::createInferredCast( |
| 1631 | ci->getOperand(3), Type::SByteTy, "char", ci); |
Chris Lattner | 5d735bf | 2005-09-24 22:17:06 +0000 | [diff] [blame] | 1632 | new StoreInst(cast, ci->getOperand(1), ci); |
| 1633 | GetElementPtrInst* gep = new GetElementPtrInst(ci->getOperand(1), |
Reid Spencer | b83eb64 | 2006-10-20 07:07:24 +0000 | [diff] [blame] | 1634 | ConstantInt::get(Type::UIntTy,1),ci->getOperand(1)->getName()+".end", |
Chris Lattner | 5d735bf | 2005-09-24 22:17:06 +0000 | [diff] [blame] | 1635 | ci); |
| 1636 | new StoreInst(ConstantInt::get(Type::SByteTy,0),gep,ci); |
Reid Spencer | b83eb64 | 2006-10-20 07:07:24 +0000 | [diff] [blame] | 1637 | ci->replaceAllUsesWith(ConstantInt::get(Type::IntTy,1)); |
Chris Lattner | 5d735bf | 2005-09-24 22:17:06 +0000 | [diff] [blame] | 1638 | ci->eraseFromParent(); |
| 1639 | return true; |
| 1640 | } |
| 1641 | } |
| 1642 | return false; |
Reid Spencer | 58b563c | 2005-05-04 03:20:21 +0000 | [diff] [blame] | 1643 | } |
| 1644 | } SPrintFOptimizer; |
| 1645 | |
Jeff Cohen | 00b16889 | 2005-07-27 06:12:32 +0000 | [diff] [blame] | 1646 | /// This LibCallOptimization will simplify calls to the "fputs" library |
Reid Spencer | ff5525d | 2005-04-29 09:39:47 +0000 | [diff] [blame] | 1647 | /// function. It looks for cases where the result of fputs is not used and the |
| 1648 | /// operation can be reduced to something simpler. |
Evan Cheng | 21abac2 | 2006-06-16 08:36:35 +0000 | [diff] [blame] | 1649 | /// @brief Simplify the puts library function. |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 1650 | struct PutsOptimization : public LibCallOptimization { |
Reid Spencer | ff5525d | 2005-04-29 09:39:47 +0000 | [diff] [blame] | 1651 | public: |
| 1652 | /// @brief Default Constructor |
Reid Spencer | 9974dda | 2005-05-03 02:54:54 +0000 | [diff] [blame] | 1653 | PutsOptimization() : LibCallOptimization("fputs", |
Reid Spencer | 789082a | 2005-05-07 20:15:59 +0000 | [diff] [blame] | 1654 | "Number of 'fputs' calls simplified") {} |
Reid Spencer | ff5525d | 2005-04-29 09:39:47 +0000 | [diff] [blame] | 1655 | |
Reid Spencer | ff5525d | 2005-04-29 09:39:47 +0000 | [diff] [blame] | 1656 | /// @brief Make sure that the "fputs" function has the right prototype |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 1657 | virtual bool ValidateCalledFunction(const Function *F, SimplifyLibCalls &SLC){ |
Reid Spencer | ff5525d | 2005-04-29 09:39:47 +0000 | [diff] [blame] | 1658 | // Just make sure this has 2 arguments |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 1659 | return F->arg_size() == 2; |
Reid Spencer | ff5525d | 2005-04-29 09:39:47 +0000 | [diff] [blame] | 1660 | } |
| 1661 | |
| 1662 | /// @brief Perform the fputs optimization. |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 1663 | virtual bool OptimizeCall(CallInst* ci, SimplifyLibCalls& SLC) { |
Reid Spencer | ff5525d | 2005-04-29 09:39:47 +0000 | [diff] [blame] | 1664 | // If the result is used, none of these optimizations work |
Chris Lattner | 5d735bf | 2005-09-24 22:17:06 +0000 | [diff] [blame] | 1665 | if (!ci->use_empty()) |
Reid Spencer | ff5525d | 2005-04-29 09:39:47 +0000 | [diff] [blame] | 1666 | return false; |
| 1667 | |
| 1668 | // All the optimizations depend on the length of the first argument and the |
| 1669 | // fact that it is a constant string array. Check that now |
Jeff Cohen | 00b16889 | 2005-07-27 06:12:32 +0000 | [diff] [blame] | 1670 | uint64_t len = 0; |
Reid Spencer | ff5525d | 2005-04-29 09:39:47 +0000 | [diff] [blame] | 1671 | if (!getConstantStringLength(ci->getOperand(1), len)) |
| 1672 | return false; |
| 1673 | |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 1674 | switch (len) { |
Reid Spencer | ff5525d | 2005-04-29 09:39:47 +0000 | [diff] [blame] | 1675 | case 0: |
| 1676 | // fputs("",F) -> noop |
| 1677 | break; |
| 1678 | case 1: |
| 1679 | { |
| 1680 | // fputs(s,F) -> fputc(s[0],F) (if s is constant and strlen(s) == 1) |
Reid Spencer | 9f56b1f | 2005-04-30 03:17:54 +0000 | [diff] [blame] | 1681 | const Type* FILEptr_type = ci->getOperand(2)->getType(); |
| 1682 | Function* fputc_func = SLC.get_fputc(FILEptr_type); |
Reid Spencer | ff5525d | 2005-04-29 09:39:47 +0000 | [diff] [blame] | 1683 | if (!fputc_func) |
| 1684 | return false; |
| 1685 | LoadInst* loadi = new LoadInst(ci->getOperand(1), |
| 1686 | ci->getOperand(1)->getName()+".byte",ci); |
Reid Spencer | 3da59db | 2006-11-27 01:05:10 +0000 | [diff] [blame^] | 1687 | CastInst* casti = CastInst::createInferredCast( |
| 1688 | loadi, Type::IntTy, loadi->getName()+".int", ci); |
Reid Spencer | ff5525d | 2005-04-29 09:39:47 +0000 | [diff] [blame] | 1689 | new CallInst(fputc_func,casti,ci->getOperand(2),"",ci); |
| 1690 | break; |
| 1691 | } |
| 1692 | default: |
Jeff Cohen | 00b16889 | 2005-07-27 06:12:32 +0000 | [diff] [blame] | 1693 | { |
Reid Spencer | ff5525d | 2005-04-29 09:39:47 +0000 | [diff] [blame] | 1694 | // fputs(s,F) -> fwrite(s,1,len,F) (if s is constant and strlen(s) > 1) |
Reid Spencer | 9f56b1f | 2005-04-30 03:17:54 +0000 | [diff] [blame] | 1695 | const Type* FILEptr_type = ci->getOperand(2)->getType(); |
| 1696 | Function* fwrite_func = SLC.get_fwrite(FILEptr_type); |
Reid Spencer | ff5525d | 2005-04-29 09:39:47 +0000 | [diff] [blame] | 1697 | if (!fwrite_func) |
| 1698 | return false; |
| 1699 | std::vector<Value*> parms; |
| 1700 | parms.push_back(ci->getOperand(1)); |
Reid Spencer | b83eb64 | 2006-10-20 07:07:24 +0000 | [diff] [blame] | 1701 | parms.push_back(ConstantInt::get(SLC.getIntPtrType(),len)); |
| 1702 | parms.push_back(ConstantInt::get(SLC.getIntPtrType(),1)); |
Reid Spencer | ff5525d | 2005-04-29 09:39:47 +0000 | [diff] [blame] | 1703 | parms.push_back(ci->getOperand(2)); |
| 1704 | new CallInst(fwrite_func,parms,"",ci); |
| 1705 | break; |
| 1706 | } |
| 1707 | } |
| 1708 | ci->eraseFromParent(); |
| 1709 | return true; // success |
| 1710 | } |
| 1711 | } PutsOptimizer; |
| 1712 | |
Jeff Cohen | 00b16889 | 2005-07-27 06:12:32 +0000 | [diff] [blame] | 1713 | /// This LibCallOptimization will simplify calls to the "isdigit" library |
Reid Spencer | cea6559 | 2005-05-04 18:58:28 +0000 | [diff] [blame] | 1714 | /// function. It simply does range checks the parameter explicitly. |
| 1715 | /// @brief Simplify the isdigit library function. |
Chris Lattner | e9b6242 | 2005-09-29 06:16:11 +0000 | [diff] [blame] | 1716 | struct isdigitOptimization : public LibCallOptimization { |
Reid Spencer | cea6559 | 2005-05-04 18:58:28 +0000 | [diff] [blame] | 1717 | public: |
Chris Lattner | e9b6242 | 2005-09-29 06:16:11 +0000 | [diff] [blame] | 1718 | isdigitOptimization() : LibCallOptimization("isdigit", |
Reid Spencer | 789082a | 2005-05-07 20:15:59 +0000 | [diff] [blame] | 1719 | "Number of 'isdigit' calls simplified") {} |
Reid Spencer | cea6559 | 2005-05-04 18:58:28 +0000 | [diff] [blame] | 1720 | |
Chris Lattner | e9b6242 | 2005-09-29 06:16:11 +0000 | [diff] [blame] | 1721 | /// @brief Make sure that the "isdigit" function has the right prototype |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 1722 | virtual bool ValidateCalledFunction(const Function* f, SimplifyLibCalls& SLC){ |
Reid Spencer | cea6559 | 2005-05-04 18:58:28 +0000 | [diff] [blame] | 1723 | // Just make sure this has 1 argument |
| 1724 | return (f->arg_size() == 1); |
| 1725 | } |
| 1726 | |
| 1727 | /// @brief Perform the toascii optimization. |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 1728 | virtual bool OptimizeCall(CallInst *ci, SimplifyLibCalls &SLC) { |
| 1729 | if (ConstantInt* CI = dyn_cast<ConstantInt>(ci->getOperand(1))) { |
Reid Spencer | cea6559 | 2005-05-04 18:58:28 +0000 | [diff] [blame] | 1730 | // isdigit(c) -> 0 or 1, if 'c' is constant |
Reid Spencer | b83eb64 | 2006-10-20 07:07:24 +0000 | [diff] [blame] | 1731 | uint64_t val = CI->getZExtValue(); |
Reid Spencer | cea6559 | 2005-05-04 18:58:28 +0000 | [diff] [blame] | 1732 | if (val >= '0' && val <='9') |
Reid Spencer | b83eb64 | 2006-10-20 07:07:24 +0000 | [diff] [blame] | 1733 | ci->replaceAllUsesWith(ConstantInt::get(Type::IntTy,1)); |
Reid Spencer | cea6559 | 2005-05-04 18:58:28 +0000 | [diff] [blame] | 1734 | else |
Reid Spencer | b83eb64 | 2006-10-20 07:07:24 +0000 | [diff] [blame] | 1735 | ci->replaceAllUsesWith(ConstantInt::get(Type::IntTy,0)); |
Reid Spencer | cea6559 | 2005-05-04 18:58:28 +0000 | [diff] [blame] | 1736 | ci->eraseFromParent(); |
| 1737 | return true; |
| 1738 | } |
| 1739 | |
| 1740 | // isdigit(c) -> (unsigned)c - '0' <= 9 |
Reid Spencer | 3da59db | 2006-11-27 01:05:10 +0000 | [diff] [blame^] | 1741 | CastInst* cast = CastInst::createInferredCast(ci->getOperand(1), |
| 1742 | Type::UIntTy, ci->getOperand(1)->getName()+".uint", ci); |
Chris Lattner | 5324986 | 2005-08-24 17:22:17 +0000 | [diff] [blame] | 1743 | BinaryOperator* sub_inst = BinaryOperator::createSub(cast, |
Reid Spencer | b83eb64 | 2006-10-20 07:07:24 +0000 | [diff] [blame] | 1744 | ConstantInt::get(Type::UIntTy,0x30), |
Reid Spencer | cea6559 | 2005-05-04 18:58:28 +0000 | [diff] [blame] | 1745 | ci->getOperand(1)->getName()+".sub",ci); |
| 1746 | SetCondInst* setcond_inst = new SetCondInst(Instruction::SetLE,sub_inst, |
Reid Spencer | b83eb64 | 2006-10-20 07:07:24 +0000 | [diff] [blame] | 1747 | ConstantInt::get(Type::UIntTy,9), |
Reid Spencer | cea6559 | 2005-05-04 18:58:28 +0000 | [diff] [blame] | 1748 | ci->getOperand(1)->getName()+".cmp",ci); |
Reid Spencer | 3da59db | 2006-11-27 01:05:10 +0000 | [diff] [blame^] | 1749 | CastInst* c2 = CastInst::createInferredCast( |
| 1750 | setcond_inst, Type::IntTy, ci->getOperand(1)->getName()+".isdigit", ci); |
Reid Spencer | cea6559 | 2005-05-04 18:58:28 +0000 | [diff] [blame] | 1751 | ci->replaceAllUsesWith(c2); |
| 1752 | ci->eraseFromParent(); |
| 1753 | return true; |
| 1754 | } |
Chris Lattner | e9b6242 | 2005-09-29 06:16:11 +0000 | [diff] [blame] | 1755 | } isdigitOptimizer; |
| 1756 | |
Chris Lattner | a48bc53 | 2005-09-29 06:17:27 +0000 | [diff] [blame] | 1757 | struct isasciiOptimization : public LibCallOptimization { |
| 1758 | public: |
| 1759 | isasciiOptimization() |
| 1760 | : LibCallOptimization("isascii", "Number of 'isascii' calls simplified") {} |
| 1761 | |
| 1762 | virtual bool ValidateCalledFunction(const Function *F, SimplifyLibCalls &SLC){ |
| 1763 | return F->arg_size() == 1 && F->arg_begin()->getType()->isInteger() && |
| 1764 | F->getReturnType()->isInteger(); |
| 1765 | } |
| 1766 | |
| 1767 | /// @brief Perform the isascii optimization. |
| 1768 | virtual bool OptimizeCall(CallInst *CI, SimplifyLibCalls &SLC) { |
| 1769 | // isascii(c) -> (unsigned)c < 128 |
| 1770 | Value *V = CI->getOperand(1); |
| 1771 | if (V->getType()->isSigned()) |
Reid Spencer | 3da59db | 2006-11-27 01:05:10 +0000 | [diff] [blame^] | 1772 | V = CastInst::createInferredCast(V, V->getType()->getUnsignedVersion(), |
| 1773 | V->getName(), CI); |
Reid Spencer | b83eb64 | 2006-10-20 07:07:24 +0000 | [diff] [blame] | 1774 | Value *Cmp = BinaryOperator::createSetLT(V, ConstantInt::get(V->getType(), |
Chris Lattner | a48bc53 | 2005-09-29 06:17:27 +0000 | [diff] [blame] | 1775 | 128), |
| 1776 | V->getName()+".isascii", CI); |
| 1777 | if (Cmp->getType() != CI->getType()) |
Reid Spencer | 3da59db | 2006-11-27 01:05:10 +0000 | [diff] [blame^] | 1778 | Cmp = CastInst::createInferredCast( |
| 1779 | Cmp, CI->getType(), Cmp->getName(), CI); |
Chris Lattner | a48bc53 | 2005-09-29 06:17:27 +0000 | [diff] [blame] | 1780 | CI->replaceAllUsesWith(Cmp); |
| 1781 | CI->eraseFromParent(); |
| 1782 | return true; |
| 1783 | } |
| 1784 | } isasciiOptimizer; |
Chris Lattner | e9b6242 | 2005-09-29 06:16:11 +0000 | [diff] [blame] | 1785 | |
Reid Spencer | cea6559 | 2005-05-04 18:58:28 +0000 | [diff] [blame] | 1786 | |
Jeff Cohen | 00b16889 | 2005-07-27 06:12:32 +0000 | [diff] [blame] | 1787 | /// This LibCallOptimization will simplify calls to the "toascii" library |
Reid Spencer | 9f56b1f | 2005-04-30 03:17:54 +0000 | [diff] [blame] | 1788 | /// function. It simply does the corresponding and operation to restrict the |
| 1789 | /// range of values to the ASCII character set (0-127). |
| 1790 | /// @brief Simplify the toascii library function. |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 1791 | struct ToAsciiOptimization : public LibCallOptimization { |
Reid Spencer | 9f56b1f | 2005-04-30 03:17:54 +0000 | [diff] [blame] | 1792 | public: |
| 1793 | /// @brief Default Constructor |
Reid Spencer | 9974dda | 2005-05-03 02:54:54 +0000 | [diff] [blame] | 1794 | ToAsciiOptimization() : LibCallOptimization("toascii", |
Reid Spencer | 789082a | 2005-05-07 20:15:59 +0000 | [diff] [blame] | 1795 | "Number of 'toascii' calls simplified") {} |
Reid Spencer | 9f56b1f | 2005-04-30 03:17:54 +0000 | [diff] [blame] | 1796 | |
Reid Spencer | 9f56b1f | 2005-04-30 03:17:54 +0000 | [diff] [blame] | 1797 | /// @brief Make sure that the "fputs" function has the right prototype |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 1798 | virtual bool ValidateCalledFunction(const Function* f, SimplifyLibCalls& SLC){ |
Reid Spencer | 9f56b1f | 2005-04-30 03:17:54 +0000 | [diff] [blame] | 1799 | // Just make sure this has 2 arguments |
| 1800 | return (f->arg_size() == 1); |
| 1801 | } |
| 1802 | |
| 1803 | /// @brief Perform the toascii optimization. |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 1804 | virtual bool OptimizeCall(CallInst *ci, SimplifyLibCalls &SLC) { |
Reid Spencer | 9f56b1f | 2005-04-30 03:17:54 +0000 | [diff] [blame] | 1805 | // toascii(c) -> (c & 0x7f) |
| 1806 | Value* chr = ci->getOperand(1); |
Chris Lattner | 5324986 | 2005-08-24 17:22:17 +0000 | [diff] [blame] | 1807 | BinaryOperator* and_inst = BinaryOperator::createAnd(chr, |
Reid Spencer | 9f56b1f | 2005-04-30 03:17:54 +0000 | [diff] [blame] | 1808 | ConstantInt::get(chr->getType(),0x7F),ci->getName()+".toascii",ci); |
| 1809 | ci->replaceAllUsesWith(and_inst); |
| 1810 | ci->eraseFromParent(); |
| 1811 | return true; |
| 1812 | } |
| 1813 | } ToAsciiOptimizer; |
| 1814 | |
Reid Spencer | c29b13d | 2005-05-14 16:42:52 +0000 | [diff] [blame] | 1815 | /// This LibCallOptimization will simplify calls to the "ffs" library |
Jeff Cohen | 00b16889 | 2005-07-27 06:12:32 +0000 | [diff] [blame] | 1816 | /// calls which find the first set bit in an int, long, or long long. The |
Reid Spencer | c29b13d | 2005-05-14 16:42:52 +0000 | [diff] [blame] | 1817 | /// optimization is to compute the result at compile time if the argument is |
| 1818 | /// a constant. |
| 1819 | /// @brief Simplify the ffs library function. |
Chris Lattner | f91e97a | 2006-01-17 18:27:17 +0000 | [diff] [blame] | 1820 | struct FFSOptimization : public LibCallOptimization { |
Reid Spencer | c29b13d | 2005-05-14 16:42:52 +0000 | [diff] [blame] | 1821 | protected: |
| 1822 | /// @brief Subclass Constructor |
| 1823 | FFSOptimization(const char* funcName, const char* description) |
Chris Lattner | f91e97a | 2006-01-17 18:27:17 +0000 | [diff] [blame] | 1824 | : LibCallOptimization(funcName, description) {} |
Reid Spencer | c29b13d | 2005-05-14 16:42:52 +0000 | [diff] [blame] | 1825 | |
| 1826 | public: |
| 1827 | /// @brief Default Constructor |
| 1828 | FFSOptimization() : LibCallOptimization("ffs", |
| 1829 | "Number of 'ffs' calls simplified") {} |
| 1830 | |
Chris Lattner | f91e97a | 2006-01-17 18:27:17 +0000 | [diff] [blame] | 1831 | /// @brief Make sure that the "ffs" function has the right prototype |
| 1832 | virtual bool ValidateCalledFunction(const Function *F, SimplifyLibCalls &SLC){ |
Reid Spencer | c29b13d | 2005-05-14 16:42:52 +0000 | [diff] [blame] | 1833 | // Just make sure this has 2 arguments |
Chris Lattner | f91e97a | 2006-01-17 18:27:17 +0000 | [diff] [blame] | 1834 | return F->arg_size() == 1 && F->getReturnType() == Type::IntTy; |
Reid Spencer | c29b13d | 2005-05-14 16:42:52 +0000 | [diff] [blame] | 1835 | } |
| 1836 | |
| 1837 | /// @brief Perform the ffs optimization. |
Chris Lattner | f91e97a | 2006-01-17 18:27:17 +0000 | [diff] [blame] | 1838 | virtual bool OptimizeCall(CallInst *TheCall, SimplifyLibCalls &SLC) { |
| 1839 | if (ConstantInt *CI = dyn_cast<ConstantInt>(TheCall->getOperand(1))) { |
Reid Spencer | c29b13d | 2005-05-14 16:42:52 +0000 | [diff] [blame] | 1840 | // ffs(cnst) -> bit# |
| 1841 | // ffsl(cnst) -> bit# |
Reid Spencer | f74eb3f | 2005-05-15 21:19:45 +0000 | [diff] [blame] | 1842 | // ffsll(cnst) -> bit# |
Reid Spencer | b83eb64 | 2006-10-20 07:07:24 +0000 | [diff] [blame] | 1843 | uint64_t val = CI->getZExtValue(); |
Reid Spencer | f74eb3f | 2005-05-15 21:19:45 +0000 | [diff] [blame] | 1844 | int result = 0; |
Chris Lattner | f91e97a | 2006-01-17 18:27:17 +0000 | [diff] [blame] | 1845 | if (val) { |
| 1846 | ++result; |
| 1847 | while ((val & 1) == 0) { |
| 1848 | ++result; |
| 1849 | val >>= 1; |
| 1850 | } |
Reid Spencer | f74eb3f | 2005-05-15 21:19:45 +0000 | [diff] [blame] | 1851 | } |
Reid Spencer | b83eb64 | 2006-10-20 07:07:24 +0000 | [diff] [blame] | 1852 | TheCall->replaceAllUsesWith(ConstantInt::get(Type::IntTy, result)); |
Chris Lattner | f91e97a | 2006-01-17 18:27:17 +0000 | [diff] [blame] | 1853 | TheCall->eraseFromParent(); |
Reid Spencer | c29b13d | 2005-05-14 16:42:52 +0000 | [diff] [blame] | 1854 | return true; |
| 1855 | } |
Reid Spencer | f74eb3f | 2005-05-15 21:19:45 +0000 | [diff] [blame] | 1856 | |
Chris Lattner | f91e97a | 2006-01-17 18:27:17 +0000 | [diff] [blame] | 1857 | // ffs(x) -> x == 0 ? 0 : llvm.cttz(x)+1 |
| 1858 | // ffsl(x) -> x == 0 ? 0 : llvm.cttz(x)+1 |
| 1859 | // ffsll(x) -> x == 0 ? 0 : llvm.cttz(x)+1 |
| 1860 | const Type *ArgType = TheCall->getOperand(1)->getType(); |
| 1861 | ArgType = ArgType->getUnsignedVersion(); |
| 1862 | const char *CTTZName; |
| 1863 | switch (ArgType->getTypeID()) { |
| 1864 | default: assert(0 && "Unknown unsigned type!"); |
| 1865 | case Type::UByteTyID : CTTZName = "llvm.cttz.i8" ; break; |
| 1866 | case Type::UShortTyID: CTTZName = "llvm.cttz.i16"; break; |
| 1867 | case Type::UIntTyID : CTTZName = "llvm.cttz.i32"; break; |
| 1868 | case Type::ULongTyID : CTTZName = "llvm.cttz.i64"; break; |
| 1869 | } |
| 1870 | |
| 1871 | Function *F = SLC.getModule()->getOrInsertFunction(CTTZName, ArgType, |
| 1872 | ArgType, NULL); |
Reid Spencer | 3da59db | 2006-11-27 01:05:10 +0000 | [diff] [blame^] | 1873 | Value *V = CastInst::createInferredCast( |
| 1874 | TheCall->getOperand(1), ArgType, "tmp", TheCall); |
Chris Lattner | f91e97a | 2006-01-17 18:27:17 +0000 | [diff] [blame] | 1875 | Value *V2 = new CallInst(F, V, "tmp", TheCall); |
Reid Spencer | 3da59db | 2006-11-27 01:05:10 +0000 | [diff] [blame^] | 1876 | V2 = CastInst::createInferredCast(V2, Type::IntTy, "tmp", TheCall); |
Reid Spencer | b83eb64 | 2006-10-20 07:07:24 +0000 | [diff] [blame] | 1877 | V2 = BinaryOperator::createAdd(V2, ConstantInt::get(Type::IntTy, 1), |
Chris Lattner | f91e97a | 2006-01-17 18:27:17 +0000 | [diff] [blame] | 1878 | "tmp", TheCall); |
| 1879 | Value *Cond = |
| 1880 | BinaryOperator::createSetEQ(V, Constant::getNullValue(V->getType()), |
| 1881 | "tmp", TheCall); |
| 1882 | V2 = new SelectInst(Cond, ConstantInt::get(Type::IntTy, 0), V2, |
| 1883 | TheCall->getName(), TheCall); |
| 1884 | TheCall->replaceAllUsesWith(V2); |
| 1885 | TheCall->eraseFromParent(); |
Reid Spencer | f74eb3f | 2005-05-15 21:19:45 +0000 | [diff] [blame] | 1886 | return true; |
Reid Spencer | c29b13d | 2005-05-14 16:42:52 +0000 | [diff] [blame] | 1887 | } |
| 1888 | } FFSOptimizer; |
| 1889 | |
| 1890 | /// This LibCallOptimization will simplify calls to the "ffsl" library |
| 1891 | /// calls. It simply uses FFSOptimization for which the transformation is |
| 1892 | /// identical. |
| 1893 | /// @brief Simplify the ffsl library function. |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 1894 | struct FFSLOptimization : public FFSOptimization { |
Reid Spencer | c29b13d | 2005-05-14 16:42:52 +0000 | [diff] [blame] | 1895 | public: |
| 1896 | /// @brief Default Constructor |
| 1897 | FFSLOptimization() : FFSOptimization("ffsl", |
| 1898 | "Number of 'ffsl' calls simplified") {} |
| 1899 | |
| 1900 | } FFSLOptimizer; |
| 1901 | |
| 1902 | /// This LibCallOptimization will simplify calls to the "ffsll" library |
| 1903 | /// calls. It simply uses FFSOptimization for which the transformation is |
| 1904 | /// identical. |
| 1905 | /// @brief Simplify the ffsl library function. |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 1906 | struct FFSLLOptimization : public FFSOptimization { |
Reid Spencer | c29b13d | 2005-05-14 16:42:52 +0000 | [diff] [blame] | 1907 | public: |
| 1908 | /// @brief Default Constructor |
| 1909 | FFSLLOptimization() : FFSOptimization("ffsll", |
| 1910 | "Number of 'ffsll' calls simplified") {} |
| 1911 | |
| 1912 | } FFSLLOptimizer; |
| 1913 | |
Chris Lattner | 7070c5f | 2006-01-23 05:57:36 +0000 | [diff] [blame] | 1914 | /// This optimizes unary functions that take and return doubles. |
| 1915 | struct UnaryDoubleFPOptimizer : public LibCallOptimization { |
| 1916 | UnaryDoubleFPOptimizer(const char *Fn, const char *Desc) |
| 1917 | : LibCallOptimization(Fn, Desc) {} |
Chris Lattner | 5324986 | 2005-08-24 17:22:17 +0000 | [diff] [blame] | 1918 | |
Chris Lattner | 7070c5f | 2006-01-23 05:57:36 +0000 | [diff] [blame] | 1919 | // Make sure that this function has the right prototype |
Chris Lattner | 5324986 | 2005-08-24 17:22:17 +0000 | [diff] [blame] | 1920 | virtual bool ValidateCalledFunction(const Function *F, SimplifyLibCalls &SLC){ |
| 1921 | return F->arg_size() == 1 && F->arg_begin()->getType() == Type::DoubleTy && |
| 1922 | F->getReturnType() == Type::DoubleTy; |
| 1923 | } |
Chris Lattner | 7070c5f | 2006-01-23 05:57:36 +0000 | [diff] [blame] | 1924 | |
| 1925 | /// ShrinkFunctionToFloatVersion - If the input to this function is really a |
| 1926 | /// float, strength reduce this to a float version of the function, |
| 1927 | /// e.g. floor((double)FLT) -> (double)floorf(FLT). This can only be called |
| 1928 | /// when the target supports the destination function and where there can be |
| 1929 | /// no precision loss. |
| 1930 | static bool ShrinkFunctionToFloatVersion(CallInst *CI, SimplifyLibCalls &SLC, |
| 1931 | Function *(SimplifyLibCalls::*FP)()){ |
Chris Lattner | 5324986 | 2005-08-24 17:22:17 +0000 | [diff] [blame] | 1932 | if (CastInst *Cast = dyn_cast<CastInst>(CI->getOperand(1))) |
| 1933 | if (Cast->getOperand(0)->getType() == Type::FloatTy) { |
Chris Lattner | 7070c5f | 2006-01-23 05:57:36 +0000 | [diff] [blame] | 1934 | Value *New = new CallInst((SLC.*FP)(), Cast->getOperand(0), |
Chris Lattner | 5324986 | 2005-08-24 17:22:17 +0000 | [diff] [blame] | 1935 | CI->getName(), CI); |
Reid Spencer | 3da59db | 2006-11-27 01:05:10 +0000 | [diff] [blame^] | 1936 | New = new FPExtInst(New, Type::DoubleTy, CI->getName(), CI); |
Chris Lattner | 5324986 | 2005-08-24 17:22:17 +0000 | [diff] [blame] | 1937 | CI->replaceAllUsesWith(New); |
| 1938 | CI->eraseFromParent(); |
| 1939 | if (Cast->use_empty()) |
| 1940 | Cast->eraseFromParent(); |
| 1941 | return true; |
| 1942 | } |
Chris Lattner | 7070c5f | 2006-01-23 05:57:36 +0000 | [diff] [blame] | 1943 | return false; |
Chris Lattner | 5324986 | 2005-08-24 17:22:17 +0000 | [diff] [blame] | 1944 | } |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 1945 | }; |
| 1946 | |
Chris Lattner | 7070c5f | 2006-01-23 05:57:36 +0000 | [diff] [blame] | 1947 | |
Chris Lattner | 7070c5f | 2006-01-23 05:57:36 +0000 | [diff] [blame] | 1948 | struct FloorOptimization : public UnaryDoubleFPOptimizer { |
| 1949 | FloorOptimization() |
| 1950 | : UnaryDoubleFPOptimizer("floor", "Number of 'floor' calls simplified") {} |
| 1951 | |
| 1952 | virtual bool OptimizeCall(CallInst *CI, SimplifyLibCalls &SLC) { |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 1953 | #ifdef HAVE_FLOORF |
Chris Lattner | 7070c5f | 2006-01-23 05:57:36 +0000 | [diff] [blame] | 1954 | // If this is a float argument passed in, convert to floorf. |
| 1955 | if (ShrinkFunctionToFloatVersion(CI, SLC, &SimplifyLibCalls::get_floorf)) |
| 1956 | return true; |
Reid Spencer | aa87e05 | 2006-01-19 08:36:56 +0000 | [diff] [blame] | 1957 | #endif |
Chris Lattner | 7070c5f | 2006-01-23 05:57:36 +0000 | [diff] [blame] | 1958 | return false; // opt failed |
| 1959 | } |
| 1960 | } FloorOptimizer; |
Chris Lattner | 5324986 | 2005-08-24 17:22:17 +0000 | [diff] [blame] | 1961 | |
Chris Lattner | e46f6e9 | 2006-01-23 06:24:46 +0000 | [diff] [blame] | 1962 | struct CeilOptimization : public UnaryDoubleFPOptimizer { |
| 1963 | CeilOptimization() |
| 1964 | : UnaryDoubleFPOptimizer("ceil", "Number of 'ceil' calls simplified") {} |
| 1965 | |
| 1966 | virtual bool OptimizeCall(CallInst *CI, SimplifyLibCalls &SLC) { |
| 1967 | #ifdef HAVE_CEILF |
| 1968 | // If this is a float argument passed in, convert to ceilf. |
| 1969 | if (ShrinkFunctionToFloatVersion(CI, SLC, &SimplifyLibCalls::get_ceilf)) |
| 1970 | return true; |
| 1971 | #endif |
| 1972 | return false; // opt failed |
| 1973 | } |
| 1974 | } CeilOptimizer; |
Chris Lattner | 5324986 | 2005-08-24 17:22:17 +0000 | [diff] [blame] | 1975 | |
Chris Lattner | e46f6e9 | 2006-01-23 06:24:46 +0000 | [diff] [blame] | 1976 | struct RoundOptimization : public UnaryDoubleFPOptimizer { |
| 1977 | RoundOptimization() |
| 1978 | : UnaryDoubleFPOptimizer("round", "Number of 'round' calls simplified") {} |
| 1979 | |
| 1980 | virtual bool OptimizeCall(CallInst *CI, SimplifyLibCalls &SLC) { |
| 1981 | #ifdef HAVE_ROUNDF |
| 1982 | // If this is a float argument passed in, convert to roundf. |
| 1983 | if (ShrinkFunctionToFloatVersion(CI, SLC, &SimplifyLibCalls::get_roundf)) |
| 1984 | return true; |
| 1985 | #endif |
| 1986 | return false; // opt failed |
| 1987 | } |
| 1988 | } RoundOptimizer; |
| 1989 | |
| 1990 | struct RintOptimization : public UnaryDoubleFPOptimizer { |
| 1991 | RintOptimization() |
| 1992 | : UnaryDoubleFPOptimizer("rint", "Number of 'rint' calls simplified") {} |
| 1993 | |
| 1994 | virtual bool OptimizeCall(CallInst *CI, SimplifyLibCalls &SLC) { |
| 1995 | #ifdef HAVE_RINTF |
| 1996 | // If this is a float argument passed in, convert to rintf. |
| 1997 | if (ShrinkFunctionToFloatVersion(CI, SLC, &SimplifyLibCalls::get_rintf)) |
| 1998 | return true; |
| 1999 | #endif |
| 2000 | return false; // opt failed |
| 2001 | } |
| 2002 | } RintOptimizer; |
| 2003 | |
| 2004 | struct NearByIntOptimization : public UnaryDoubleFPOptimizer { |
| 2005 | NearByIntOptimization() |
| 2006 | : UnaryDoubleFPOptimizer("nearbyint", |
| 2007 | "Number of 'nearbyint' calls simplified") {} |
| 2008 | |
| 2009 | virtual bool OptimizeCall(CallInst *CI, SimplifyLibCalls &SLC) { |
| 2010 | #ifdef HAVE_NEARBYINTF |
| 2011 | // If this is a float argument passed in, convert to nearbyintf. |
| 2012 | if (ShrinkFunctionToFloatVersion(CI, SLC,&SimplifyLibCalls::get_nearbyintf)) |
| 2013 | return true; |
| 2014 | #endif |
| 2015 | return false; // opt failed |
| 2016 | } |
| 2017 | } NearByIntOptimizer; |
Chris Lattner | 5324986 | 2005-08-24 17:22:17 +0000 | [diff] [blame] | 2018 | |
Reid Spencer | 716f49e | 2005-04-27 21:29:20 +0000 | [diff] [blame] | 2019 | /// A function to compute the length of a null-terminated constant array of |
Jeff Cohen | 00b16889 | 2005-07-27 06:12:32 +0000 | [diff] [blame] | 2020 | /// integers. This function can't rely on the size of the constant array |
| 2021 | /// because there could be a null terminator in the middle of the array. |
| 2022 | /// We also have to bail out if we find a non-integer constant initializer |
| 2023 | /// of one of the elements or if there is no null-terminator. The logic |
Reid Spencer | 716f49e | 2005-04-27 21:29:20 +0000 | [diff] [blame] | 2024 | /// below checks each of these conditions and will return true only if all |
| 2025 | /// conditions are met. In that case, the \p len parameter is set to the length |
| 2026 | /// of the null-terminated string. If false is returned, the conditions were |
| 2027 | /// not met and len is set to 0. |
| 2028 | /// @brief Get the length of a constant string (null-terminated array). |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 2029 | bool getConstantStringLength(Value *V, uint64_t &len, ConstantArray **CA) { |
Reid Spencer | a16d5a5 | 2005-04-27 07:54:40 +0000 | [diff] [blame] | 2030 | assert(V != 0 && "Invalid args to getConstantStringLength"); |
Jeff Cohen | 00b16889 | 2005-07-27 06:12:32 +0000 | [diff] [blame] | 2031 | len = 0; // make sure we initialize this |
Reid Spencer | a16d5a5 | 2005-04-27 07:54:40 +0000 | [diff] [blame] | 2032 | User* GEP = 0; |
Jeff Cohen | 00b16889 | 2005-07-27 06:12:32 +0000 | [diff] [blame] | 2033 | // If the value is not a GEP instruction nor a constant expression with a |
| 2034 | // GEP instruction, then return false because ConstantArray can't occur |
Reid Spencer | a16d5a5 | 2005-04-27 07:54:40 +0000 | [diff] [blame] | 2035 | // any other way |
| 2036 | if (GetElementPtrInst* GEPI = dyn_cast<GetElementPtrInst>(V)) |
| 2037 | GEP = GEPI; |
| 2038 | else if (ConstantExpr* CE = dyn_cast<ConstantExpr>(V)) |
| 2039 | if (CE->getOpcode() == Instruction::GetElementPtr) |
| 2040 | GEP = CE; |
| 2041 | else |
| 2042 | return false; |
| 2043 | else |
| 2044 | return false; |
| 2045 | |
| 2046 | // Make sure the GEP has exactly three arguments. |
| 2047 | if (GEP->getNumOperands() != 3) |
| 2048 | return false; |
| 2049 | |
| 2050 | // Check to make sure that the first operand of the GEP is an integer and |
Jeff Cohen | 00b16889 | 2005-07-27 06:12:32 +0000 | [diff] [blame] | 2051 | // has value 0 so that we are sure we're indexing into the initializer. |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 2052 | if (ConstantInt* op1 = dyn_cast<ConstantInt>(GEP->getOperand(1))) { |
Reid Spencer | a16d5a5 | 2005-04-27 07:54:40 +0000 | [diff] [blame] | 2053 | if (!op1->isNullValue()) |
| 2054 | return false; |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 2055 | } else |
Reid Spencer | a16d5a5 | 2005-04-27 07:54:40 +0000 | [diff] [blame] | 2056 | return false; |
| 2057 | |
| 2058 | // Ensure that the second operand is a ConstantInt. If it isn't then this |
Jeff Cohen | 00b16889 | 2005-07-27 06:12:32 +0000 | [diff] [blame] | 2059 | // GEP is wonky and we're not really sure what were referencing into and |
Reid Spencer | a16d5a5 | 2005-04-27 07:54:40 +0000 | [diff] [blame] | 2060 | // better of not optimizing it. While we're at it, get the second index |
| 2061 | // value. We'll need this later for indexing the ConstantArray. |
| 2062 | uint64_t start_idx = 0; |
| 2063 | if (ConstantInt* CI = dyn_cast<ConstantInt>(GEP->getOperand(2))) |
Reid Spencer | b83eb64 | 2006-10-20 07:07:24 +0000 | [diff] [blame] | 2064 | start_idx = CI->getZExtValue(); |
Reid Spencer | a16d5a5 | 2005-04-27 07:54:40 +0000 | [diff] [blame] | 2065 | else |
| 2066 | return false; |
| 2067 | |
| 2068 | // The GEP instruction, constant or instruction, must reference a global |
| 2069 | // variable that is a constant and is initialized. The referenced constant |
| 2070 | // initializer is the array that we'll use for optimization. |
| 2071 | GlobalVariable* GV = dyn_cast<GlobalVariable>(GEP->getOperand(0)); |
| 2072 | if (!GV || !GV->isConstant() || !GV->hasInitializer()) |
| 2073 | return false; |
| 2074 | |
| 2075 | // Get the initializer. |
| 2076 | Constant* INTLZR = GV->getInitializer(); |
| 2077 | |
| 2078 | // Handle the ConstantAggregateZero case |
Reid Spencer | 3ed469c | 2006-11-02 20:25:50 +0000 | [diff] [blame] | 2079 | if (isa<ConstantAggregateZero>(INTLZR)) { |
Reid Spencer | a16d5a5 | 2005-04-27 07:54:40 +0000 | [diff] [blame] | 2080 | // This is a degenerate case. The initializer is constant zero so the |
| 2081 | // length of the string must be zero. |
| 2082 | len = 0; |
| 2083 | return true; |
| 2084 | } |
| 2085 | |
| 2086 | // Must be a Constant Array |
| 2087 | ConstantArray* A = dyn_cast<ConstantArray>(INTLZR); |
| 2088 | if (!A) |
| 2089 | return false; |
| 2090 | |
| 2091 | // Get the number of elements in the array |
| 2092 | uint64_t max_elems = A->getType()->getNumElements(); |
| 2093 | |
| 2094 | // Traverse the constant array from start_idx (derived above) which is |
Jeff Cohen | 00b16889 | 2005-07-27 06:12:32 +0000 | [diff] [blame] | 2095 | // the place the GEP refers to in the array. |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 2096 | for (len = start_idx; len < max_elems; len++) { |
| 2097 | if (ConstantInt *CI = dyn_cast<ConstantInt>(A->getOperand(len))) { |
Reid Spencer | a16d5a5 | 2005-04-27 07:54:40 +0000 | [diff] [blame] | 2098 | // Check for the null terminator |
| 2099 | if (CI->isNullValue()) |
| 2100 | break; // we found end of string |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 2101 | } else |
Reid Spencer | a16d5a5 | 2005-04-27 07:54:40 +0000 | [diff] [blame] | 2102 | return false; // This array isn't suitable, non-int initializer |
| 2103 | } |
Chris Lattner | 0f9f8c3 | 2006-01-22 22:35:08 +0000 | [diff] [blame] | 2104 | |
Reid Spencer | a16d5a5 | 2005-04-27 07:54:40 +0000 | [diff] [blame] | 2105 | if (len >= max_elems) |
| 2106 | return false; // This array isn't null terminated |
| 2107 | |
| 2108 | // Subtract out the initial value from the length |
| 2109 | len -= start_idx; |
Reid Spencer | 9f56b1f | 2005-04-30 03:17:54 +0000 | [diff] [blame] | 2110 | if (CA) |
| 2111 | *CA = A; |
Reid Spencer | a16d5a5 | 2005-04-27 07:54:40 +0000 | [diff] [blame] | 2112 | return true; // success! |
| 2113 | } |
| 2114 | |
Reid Spencer | 134d2e4 | 2005-06-18 17:46:28 +0000 | [diff] [blame] | 2115 | /// CastToCStr - Return V if it is an sbyte*, otherwise cast it to sbyte*, |
| 2116 | /// inserting the cast before IP, and return the cast. |
| 2117 | /// @brief Cast a value to a "C" string. |
| 2118 | Value *CastToCStr(Value *V, Instruction &IP) { |
| 2119 | const Type *SBPTy = PointerType::get(Type::SByteTy); |
| 2120 | if (V->getType() != SBPTy) |
Reid Spencer | 3da59db | 2006-11-27 01:05:10 +0000 | [diff] [blame^] | 2121 | return CastInst::createInferredCast(V, SBPTy, V->getName(), &IP); |
Reid Spencer | 134d2e4 | 2005-06-18 17:46:28 +0000 | [diff] [blame] | 2122 | return V; |
| 2123 | } |
| 2124 | |
Jeff Cohen | 00b16889 | 2005-07-27 06:12:32 +0000 | [diff] [blame] | 2125 | // TODO: |
Reid Spencer | 8441a01 | 2005-04-28 04:40:06 +0000 | [diff] [blame] | 2126 | // Additional cases that we need to add to this file: |
| 2127 | // |
Reid Spencer | 8441a01 | 2005-04-28 04:40:06 +0000 | [diff] [blame] | 2128 | // cbrt: |
Reid Spencer | 8441a01 | 2005-04-28 04:40:06 +0000 | [diff] [blame] | 2129 | // * cbrt(expN(X)) -> expN(x/3) |
| 2130 | // * cbrt(sqrt(x)) -> pow(x,1/6) |
| 2131 | // * cbrt(sqrt(x)) -> pow(x,1/9) |
| 2132 | // |
Reid Spencer | 8441a01 | 2005-04-28 04:40:06 +0000 | [diff] [blame] | 2133 | // cos, cosf, cosl: |
Reid Spencer | 5624c75 | 2005-04-28 18:05:16 +0000 | [diff] [blame] | 2134 | // * cos(-x) -> cos(x) |
Reid Spencer | 8441a01 | 2005-04-28 04:40:06 +0000 | [diff] [blame] | 2135 | // |
| 2136 | // exp, expf, expl: |
Reid Spencer | 8441a01 | 2005-04-28 04:40:06 +0000 | [diff] [blame] | 2137 | // * exp(log(x)) -> x |
| 2138 | // |
Reid Spencer | 8441a01 | 2005-04-28 04:40:06 +0000 | [diff] [blame] | 2139 | // log, logf, logl: |
Reid Spencer | 8441a01 | 2005-04-28 04:40:06 +0000 | [diff] [blame] | 2140 | // * log(exp(x)) -> x |
| 2141 | // * log(x**y) -> y*log(x) |
| 2142 | // * log(exp(y)) -> y*log(e) |
| 2143 | // * log(exp2(y)) -> y*log(2) |
| 2144 | // * log(exp10(y)) -> y*log(10) |
| 2145 | // * log(sqrt(x)) -> 0.5*log(x) |
| 2146 | // * log(pow(x,y)) -> y*log(x) |
| 2147 | // |
| 2148 | // lround, lroundf, lroundl: |
| 2149 | // * lround(cnst) -> cnst' |
| 2150 | // |
| 2151 | // memcmp: |
Reid Spencer | 8441a01 | 2005-04-28 04:40:06 +0000 | [diff] [blame] | 2152 | // * memcmp(x,y,l) -> cnst |
| 2153 | // (if all arguments are constant and strlen(x) <= l and strlen(y) <= l) |
Reid Spencer | 8441a01 | 2005-04-28 04:40:06 +0000 | [diff] [blame] | 2154 | // |
Reid Spencer | 8441a01 | 2005-04-28 04:40:06 +0000 | [diff] [blame] | 2155 | // memmove: |
Jeff Cohen | 00b16889 | 2005-07-27 06:12:32 +0000 | [diff] [blame] | 2156 | // * memmove(d,s,l,a) -> memcpy(d,s,l,a) |
Reid Spencer | 8441a01 | 2005-04-28 04:40:06 +0000 | [diff] [blame] | 2157 | // (if s is a global constant array) |
| 2158 | // |
Reid Spencer | 8441a01 | 2005-04-28 04:40:06 +0000 | [diff] [blame] | 2159 | // pow, powf, powl: |
Reid Spencer | 8441a01 | 2005-04-28 04:40:06 +0000 | [diff] [blame] | 2160 | // * pow(exp(x),y) -> exp(x*y) |
| 2161 | // * pow(sqrt(x),y) -> pow(x,y*0.5) |
| 2162 | // * pow(pow(x,y),z)-> pow(x,y*z) |
| 2163 | // |
| 2164 | // puts: |
| 2165 | // * puts("") -> fputc("\n",stdout) (how do we get "stdout"?) |
| 2166 | // |
| 2167 | // round, roundf, roundl: |
| 2168 | // * round(cnst) -> cnst' |
| 2169 | // |
| 2170 | // signbit: |
| 2171 | // * signbit(cnst) -> cnst' |
| 2172 | // * signbit(nncst) -> 0 (if pstv is a non-negative constant) |
| 2173 | // |
Reid Spencer | 8441a01 | 2005-04-28 04:40:06 +0000 | [diff] [blame] | 2174 | // sqrt, sqrtf, sqrtl: |
Reid Spencer | 8441a01 | 2005-04-28 04:40:06 +0000 | [diff] [blame] | 2175 | // * sqrt(expN(x)) -> expN(x*0.5) |
| 2176 | // * sqrt(Nroot(x)) -> pow(x,1/(2*N)) |
| 2177 | // * sqrt(pow(x,y)) -> pow(|x|,y*0.5) |
| 2178 | // |
Reid Spencer | 789082a | 2005-05-07 20:15:59 +0000 | [diff] [blame] | 2179 | // stpcpy: |
| 2180 | // * stpcpy(str, "literal") -> |
| 2181 | // llvm.memcpy(str,"literal",strlen("literal")+1,1) |
Reid Spencer | 21506ff | 2005-05-03 07:23:44 +0000 | [diff] [blame] | 2182 | // strrchr: |
Reid Spencer | 8441a01 | 2005-04-28 04:40:06 +0000 | [diff] [blame] | 2183 | // * strrchr(s,c) -> reverse_offset_of_in(c,s) |
| 2184 | // (if c is a constant integer and s is a constant string) |
| 2185 | // * strrchr(s1,0) -> strchr(s1,0) |
| 2186 | // |
Reid Spencer | 8441a01 | 2005-04-28 04:40:06 +0000 | [diff] [blame] | 2187 | // strncat: |
| 2188 | // * strncat(x,y,0) -> x |
| 2189 | // * strncat(x,y,0) -> x (if strlen(y) = 0) |
| 2190 | // * strncat(x,y,l) -> strcat(x,y) (if y and l are constants an l > strlen(y)) |
| 2191 | // |
Reid Spencer | 8441a01 | 2005-04-28 04:40:06 +0000 | [diff] [blame] | 2192 | // strncpy: |
| 2193 | // * strncpy(d,s,0) -> d |
| 2194 | // * strncpy(d,s,l) -> memcpy(d,s,l,1) |
| 2195 | // (if s and l are constants) |
| 2196 | // |
| 2197 | // strpbrk: |
| 2198 | // * strpbrk(s,a) -> offset_in_for(s,a) |
| 2199 | // (if s and a are both constant strings) |
| 2200 | // * strpbrk(s,"") -> 0 |
| 2201 | // * strpbrk(s,a) -> strchr(s,a[0]) (if a is constant string of length 1) |
| 2202 | // |
| 2203 | // strspn, strcspn: |
| 2204 | // * strspn(s,a) -> const_int (if both args are constant) |
| 2205 | // * strspn("",a) -> 0 |
| 2206 | // * strspn(s,"") -> 0 |
| 2207 | // * strcspn(s,a) -> const_int (if both args are constant) |
| 2208 | // * strcspn("",a) -> 0 |
| 2209 | // * strcspn(s,"") -> strlen(a) |
| 2210 | // |
| 2211 | // strstr: |
| 2212 | // * strstr(x,x) -> x |
Jeff Cohen | 00b16889 | 2005-07-27 06:12:32 +0000 | [diff] [blame] | 2213 | // * strstr(s1,s2) -> offset_of_s2_in(s1) |
Reid Spencer | 8441a01 | 2005-04-28 04:40:06 +0000 | [diff] [blame] | 2214 | // (if s1 and s2 are constant strings) |
Jeff Cohen | 00b16889 | 2005-07-27 06:12:32 +0000 | [diff] [blame] | 2215 | // |
Reid Spencer | 8441a01 | 2005-04-28 04:40:06 +0000 | [diff] [blame] | 2216 | // tan, tanf, tanl: |
Reid Spencer | 8441a01 | 2005-04-28 04:40:06 +0000 | [diff] [blame] | 2217 | // * tan(atan(x)) -> x |
Jeff Cohen | 00b16889 | 2005-07-27 06:12:32 +0000 | [diff] [blame] | 2218 | // |
Reid Spencer | 8441a01 | 2005-04-28 04:40:06 +0000 | [diff] [blame] | 2219 | // trunc, truncf, truncl: |
| 2220 | // * trunc(cnst) -> cnst' |
| 2221 | // |
Jeff Cohen | 00b16889 | 2005-07-27 06:12:32 +0000 | [diff] [blame] | 2222 | // |
Reid Spencer | a7c049b | 2005-04-25 02:53:12 +0000 | [diff] [blame] | 2223 | } |