Gitiles
Code Review Sign In
gerrit-public.fairphone.software / toolchain / llvm-project / d765a82b54c63c4d4d1c98ca55c189366f50043a / . / llvm / lib / Transforms / IPO / InferFunctionAttrs.cpp
blob: 3c46c4968cc6f520fde62319d3a57500e4a49f9b [file] [log] [blame]
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]1//===- InferFunctionAttrs.cpp - Infer implicit function attributes --------===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9
10#include "llvm/Transforms/IPO/InferFunctionAttrs.h"
11#include "llvm/ADT/Statistic.h"
12#include "llvm/Analysis/TargetLibraryInfo.h"
Philip Reames24667192016-01-04 22:49:23 +0000[diff] [blame]13#include "llvm/Analysis/MemoryBuiltins.h"
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]14#include "llvm/IR/Function.h"
15#include "llvm/IR/LLVMContext.h"
16#include "llvm/IR/Module.h"
17#include "llvm/Support/Debug.h"
18#include "llvm/Support/raw_ostream.h"
19using namespace llvm;
20
21#define DEBUG_TYPE "inferattrs"
22
23STATISTIC(NumReadNone, "Number of functions inferred as readnone");
24STATISTIC(NumReadOnly, "Number of functions inferred as readonly");
Philip Reamesae050a52016-01-06 04:53:16 +0000[diff] [blame]25STATISTIC(NumArgMemOnly, "Number of functions inferred as argmemonly");
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]26STATISTIC(NumNoUnwind, "Number of functions inferred as nounwind");
27STATISTIC(NumNoCapture, "Number of arguments inferred as nocapture");
28STATISTIC(NumReadOnlyArg, "Number of arguments inferred as readonly");
29STATISTIC(NumNoAlias, "Number of function returns inferred as noalias");
Philip Reames24667192016-01-04 22:49:23 +0000[diff] [blame]30STATISTIC(NumNonNull, "Number of function returns inferred as nonnull returns");
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]31
32static bool setDoesNotAccessMemory(Function &F) {
33 if (F.doesNotAccessMemory())
34 return false;
35 F.setDoesNotAccessMemory();
36 ++NumReadNone;
37 return true;
38}
39
40static bool setOnlyReadsMemory(Function &F) {
41 if (F.onlyReadsMemory())
42 return false;
43 F.setOnlyReadsMemory();
44 ++NumReadOnly;
45 return true;
46}
47
Philip Reamesae050a52016-01-06 04:53:16 +0000[diff] [blame]48static bool setOnlyAccessesArgMemory(Function &F) {
49 if (F.onlyAccessesArgMemory())
50 return false;
51 F.setOnlyAccessesArgMemory ();
52 ++NumArgMemOnly;
53 return true;
54}
55
56
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]57static bool setDoesNotThrow(Function &F) {
58 if (F.doesNotThrow())
59 return false;
60 F.setDoesNotThrow();
61 ++NumNoUnwind;
62 return true;
63}
64
65static bool setDoesNotCapture(Function &F, unsigned n) {
66 if (F.doesNotCapture(n))
67 return false;
68 F.setDoesNotCapture(n);
69 ++NumNoCapture;
70 return true;
71}
72
73static bool setOnlyReadsMemory(Function &F, unsigned n) {
74 if (F.onlyReadsMemory(n))
75 return false;
76 F.setOnlyReadsMemory(n);
77 ++NumReadOnlyArg;
78 return true;
79}
80
81static bool setDoesNotAlias(Function &F, unsigned n) {
82 if (F.doesNotAlias(n))
83 return false;
84 F.setDoesNotAlias(n);
85 ++NumNoAlias;
86 return true;
87}
88
Philip Reames24667192016-01-04 22:49:23 +0000[diff] [blame]89static bool setNonNull(Function &F, unsigned n) {
90 assert((n != AttributeSet::ReturnIndex ||
91 F.getReturnType()->isPointerTy()) &&
92 "nonnull applies only to pointers");
93 if (F.getAttributes().hasAttribute(n, Attribute::NonNull))
94 return false;
95 F.addAttribute(n, Attribute::NonNull);
96 ++NumNonNull;
97 return true;
98}
99
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]100/// Analyze the name and prototype of the given function and set any applicable
101/// attributes.
102///
103/// Returns true if any attributes were set and false otherwise.
104static bool inferPrototypeAttributes(Function &F,
105 const TargetLibraryInfo &TLI) {
106 if (F.hasFnAttribute(Attribute::OptimizeNone))
107 return false;
108
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]109 LibFunc::Func TheLibFunc;
Ahmed Bougachad765a822016-04-27 19:04:35 +0000[diff] [blame^]110 if (!(TLI.getLibFunc(F, TheLibFunc) && TLI.has(TheLibFunc)))
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]111 return false;
112
113 bool Changed = false;
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]114 switch (TheLibFunc) {
115 case LibFunc::strlen:
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]116 Changed |= setOnlyReadsMemory(F);
117 Changed |= setDoesNotThrow(F);
118 Changed |= setDoesNotCapture(F, 1);
119 return Changed;
120 case LibFunc::strchr:
121 case LibFunc::strrchr:
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]122 Changed |= setOnlyReadsMemory(F);
123 Changed |= setDoesNotThrow(F);
124 return Changed;
125 case LibFunc::strtol:
126 case LibFunc::strtod:
127 case LibFunc::strtof:
128 case LibFunc::strtoul:
129 case LibFunc::strtoll:
130 case LibFunc::strtold:
131 case LibFunc::strtoull:
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]132 Changed |= setDoesNotThrow(F);
133 Changed |= setDoesNotCapture(F, 2);
134 Changed |= setOnlyReadsMemory(F, 1);
135 return Changed;
136 case LibFunc::strcpy:
137 case LibFunc::stpcpy:
138 case LibFunc::strcat:
139 case LibFunc::strncat:
140 case LibFunc::strncpy:
141 case LibFunc::stpncpy:
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]142 Changed |= setDoesNotThrow(F);
143 Changed |= setDoesNotCapture(F, 2);
144 Changed |= setOnlyReadsMemory(F, 2);
145 return Changed;
146 case LibFunc::strxfrm:
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]147 Changed |= setDoesNotThrow(F);
148 Changed |= setDoesNotCapture(F, 1);
149 Changed |= setDoesNotCapture(F, 2);
150 Changed |= setOnlyReadsMemory(F, 2);
151 return Changed;
152 case LibFunc::strcmp: // 0,1
153 case LibFunc::strspn: // 0,1
154 case LibFunc::strncmp: // 0,1
155 case LibFunc::strcspn: // 0,1
156 case LibFunc::strcoll: // 0,1
157 case LibFunc::strcasecmp: // 0,1
158 case LibFunc::strncasecmp: //
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]159 Changed |= setOnlyReadsMemory(F);
160 Changed |= setDoesNotThrow(F);
161 Changed |= setDoesNotCapture(F, 1);
162 Changed |= setDoesNotCapture(F, 2);
163 return Changed;
164 case LibFunc::strstr:
165 case LibFunc::strpbrk:
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]166 Changed |= setOnlyReadsMemory(F);
167 Changed |= setDoesNotThrow(F);
168 Changed |= setDoesNotCapture(F, 2);
169 return Changed;
170 case LibFunc::strtok:
171 case LibFunc::strtok_r:
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]172 Changed |= setDoesNotThrow(F);
173 Changed |= setDoesNotCapture(F, 2);
174 Changed |= setOnlyReadsMemory(F, 2);
175 return Changed;
176 case LibFunc::scanf:
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]177 Changed |= setDoesNotThrow(F);
178 Changed |= setDoesNotCapture(F, 1);
179 Changed |= setOnlyReadsMemory(F, 1);
180 return Changed;
181 case LibFunc::setbuf:
182 case LibFunc::setvbuf:
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]183 Changed |= setDoesNotThrow(F);
184 Changed |= setDoesNotCapture(F, 1);
185 return Changed;
186 case LibFunc::strdup:
187 case LibFunc::strndup:
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]188 Changed |= setDoesNotThrow(F);
189 Changed |= setDoesNotAlias(F, 0);
190 Changed |= setDoesNotCapture(F, 1);
191 Changed |= setOnlyReadsMemory(F, 1);
192 return Changed;
193 case LibFunc::stat:
194 case LibFunc::statvfs:
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]195 Changed |= setDoesNotThrow(F);
196 Changed |= setDoesNotCapture(F, 1);
197 Changed |= setDoesNotCapture(F, 2);
198 Changed |= setOnlyReadsMemory(F, 1);
199 return Changed;
200 case LibFunc::sscanf:
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]201 Changed |= setDoesNotThrow(F);
202 Changed |= setDoesNotCapture(F, 1);
203 Changed |= setDoesNotCapture(F, 2);
204 Changed |= setOnlyReadsMemory(F, 1);
205 Changed |= setOnlyReadsMemory(F, 2);
206 return Changed;
207 case LibFunc::sprintf:
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]208 Changed |= setDoesNotThrow(F);
209 Changed |= setDoesNotCapture(F, 1);
210 Changed |= setDoesNotCapture(F, 2);
211 Changed |= setOnlyReadsMemory(F, 2);
212 return Changed;
213 case LibFunc::snprintf:
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]214 Changed |= setDoesNotThrow(F);
215 Changed |= setDoesNotCapture(F, 1);
216 Changed |= setDoesNotCapture(F, 3);
217 Changed |= setOnlyReadsMemory(F, 3);
218 return Changed;
219 case LibFunc::setitimer:
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]220 Changed |= setDoesNotThrow(F);
221 Changed |= setDoesNotCapture(F, 2);
222 Changed |= setDoesNotCapture(F, 3);
223 Changed |= setOnlyReadsMemory(F, 2);
224 return Changed;
225 case LibFunc::system:
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]226 // May throw; "system" is a valid pthread cancellation point.
227 Changed |= setDoesNotCapture(F, 1);
228 Changed |= setOnlyReadsMemory(F, 1);
229 return Changed;
230 case LibFunc::malloc:
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]231 Changed |= setDoesNotThrow(F);
232 Changed |= setDoesNotAlias(F, 0);
233 return Changed;
234 case LibFunc::memcmp:
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]235 Changed |= setOnlyReadsMemory(F);
236 Changed |= setDoesNotThrow(F);
237 Changed |= setDoesNotCapture(F, 1);
238 Changed |= setDoesNotCapture(F, 2);
239 return Changed;
240 case LibFunc::memchr:
241 case LibFunc::memrchr:
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]242 Changed |= setOnlyReadsMemory(F);
243 Changed |= setDoesNotThrow(F);
244 return Changed;
245 case LibFunc::modf:
246 case LibFunc::modff:
247 case LibFunc::modfl:
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]248 Changed |= setDoesNotThrow(F);
249 Changed |= setDoesNotCapture(F, 2);
250 return Changed;
251 case LibFunc::memcpy:
252 case LibFunc::memccpy:
253 case LibFunc::memmove:
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]254 Changed |= setDoesNotThrow(F);
255 Changed |= setDoesNotCapture(F, 2);
256 Changed |= setOnlyReadsMemory(F, 2);
257 return Changed;
258 case LibFunc::memalign:
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]259 Changed |= setDoesNotAlias(F, 0);
260 return Changed;
261 case LibFunc::mkdir:
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]262 Changed |= setDoesNotThrow(F);
263 Changed |= setDoesNotCapture(F, 1);
264 Changed |= setOnlyReadsMemory(F, 1);
265 return Changed;
266 case LibFunc::mktime:
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]267 Changed |= setDoesNotThrow(F);
268 Changed |= setDoesNotCapture(F, 1);
269 return Changed;
270 case LibFunc::realloc:
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]271 Changed |= setDoesNotThrow(F);
272 Changed |= setDoesNotAlias(F, 0);
273 Changed |= setDoesNotCapture(F, 1);
274 return Changed;
275 case LibFunc::read:
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]276 // May throw; "read" is a valid pthread cancellation point.
277 Changed |= setDoesNotCapture(F, 2);
278 return Changed;
279 case LibFunc::rewind:
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]280 Changed |= setDoesNotThrow(F);
281 Changed |= setDoesNotCapture(F, 1);
282 return Changed;
283 case LibFunc::rmdir:
284 case LibFunc::remove:
285 case LibFunc::realpath:
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]286 Changed |= setDoesNotThrow(F);
287 Changed |= setDoesNotCapture(F, 1);
288 Changed |= setOnlyReadsMemory(F, 1);
289 return Changed;
290 case LibFunc::rename:
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]291 Changed |= setDoesNotThrow(F);
292 Changed |= setDoesNotCapture(F, 1);
293 Changed |= setDoesNotCapture(F, 2);
294 Changed |= setOnlyReadsMemory(F, 1);
295 Changed |= setOnlyReadsMemory(F, 2);
296 return Changed;
297 case LibFunc::readlink:
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]298 Changed |= setDoesNotThrow(F);
299 Changed |= setDoesNotCapture(F, 1);
300 Changed |= setDoesNotCapture(F, 2);
301 Changed |= setOnlyReadsMemory(F, 1);
302 return Changed;
303 case LibFunc::write:
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]304 // May throw; "write" is a valid pthread cancellation point.
305 Changed |= setDoesNotCapture(F, 2);
306 Changed |= setOnlyReadsMemory(F, 2);
307 return Changed;
308 case LibFunc::bcopy:
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]309 Changed |= setDoesNotThrow(F);
310 Changed |= setDoesNotCapture(F, 1);
311 Changed |= setDoesNotCapture(F, 2);
312 Changed |= setOnlyReadsMemory(F, 1);
313 return Changed;
314 case LibFunc::bcmp:
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]315 Changed |= setDoesNotThrow(F);
316 Changed |= setOnlyReadsMemory(F);
317 Changed |= setDoesNotCapture(F, 1);
318 Changed |= setDoesNotCapture(F, 2);
319 return Changed;
320 case LibFunc::bzero:
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]321 Changed |= setDoesNotThrow(F);
322 Changed |= setDoesNotCapture(F, 1);
323 return Changed;
324 case LibFunc::calloc:
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]325 Changed |= setDoesNotThrow(F);
326 Changed |= setDoesNotAlias(F, 0);
327 return Changed;
328 case LibFunc::chmod:
329 case LibFunc::chown:
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]330 Changed |= setDoesNotThrow(F);
331 Changed |= setDoesNotCapture(F, 1);
332 Changed |= setOnlyReadsMemory(F, 1);
333 return Changed;
334 case LibFunc::ctermid:
335 case LibFunc::clearerr:
336 case LibFunc::closedir:
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]337 Changed |= setDoesNotThrow(F);
338 Changed |= setDoesNotCapture(F, 1);
339 return Changed;
340 case LibFunc::atoi:
341 case LibFunc::atol:
342 case LibFunc::atof:
343 case LibFunc::atoll:
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]344 Changed |= setDoesNotThrow(F);
345 Changed |= setOnlyReadsMemory(F);
346 Changed |= setDoesNotCapture(F, 1);
347 return Changed;
348 case LibFunc::access:
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]349 Changed |= setDoesNotThrow(F);
350 Changed |= setDoesNotCapture(F, 1);
351 Changed |= setOnlyReadsMemory(F, 1);
352 return Changed;
353 case LibFunc::fopen:
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]354 Changed |= setDoesNotThrow(F);
355 Changed |= setDoesNotAlias(F, 0);
356 Changed |= setDoesNotCapture(F, 1);
357 Changed |= setDoesNotCapture(F, 2);
358 Changed |= setOnlyReadsMemory(F, 1);
359 Changed |= setOnlyReadsMemory(F, 2);
360 return Changed;
361 case LibFunc::fdopen:
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]362 Changed |= setDoesNotThrow(F);
363 Changed |= setDoesNotAlias(F, 0);
364 Changed |= setDoesNotCapture(F, 2);
365 Changed |= setOnlyReadsMemory(F, 2);
366 return Changed;
367 case LibFunc::feof:
368 case LibFunc::free:
369 case LibFunc::fseek:
370 case LibFunc::ftell:
371 case LibFunc::fgetc:
372 case LibFunc::fseeko:
373 case LibFunc::ftello:
374 case LibFunc::fileno:
375 case LibFunc::fflush:
376 case LibFunc::fclose:
377 case LibFunc::fsetpos:
378 case LibFunc::flockfile:
379 case LibFunc::funlockfile:
380 case LibFunc::ftrylockfile:
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]381 Changed |= setDoesNotThrow(F);
382 Changed |= setDoesNotCapture(F, 1);
383 return Changed;
384 case LibFunc::ferror:
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]385 Changed |= setDoesNotThrow(F);
386 Changed |= setDoesNotCapture(F, 1);
387 Changed |= setOnlyReadsMemory(F);
388 return Changed;
389 case LibFunc::fputc:
390 case LibFunc::fstat:
391 case LibFunc::frexp:
392 case LibFunc::frexpf:
393 case LibFunc::frexpl:
394 case LibFunc::fstatvfs:
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]395 Changed |= setDoesNotThrow(F);
396 Changed |= setDoesNotCapture(F, 2);
397 return Changed;
398 case LibFunc::fgets:
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]399 Changed |= setDoesNotThrow(F);
400 Changed |= setDoesNotCapture(F, 3);
401 return Changed;
402 case LibFunc::fread:
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]403 Changed |= setDoesNotThrow(F);
404 Changed |= setDoesNotCapture(F, 1);
405 Changed |= setDoesNotCapture(F, 4);
406 return Changed;
407 case LibFunc::fwrite:
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]408 Changed |= setDoesNotThrow(F);
409 Changed |= setDoesNotCapture(F, 1);
410 Changed |= setDoesNotCapture(F, 4);
411 return Changed;
412 case LibFunc::fputs:
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]413 Changed |= setDoesNotThrow(F);
414 Changed |= setDoesNotCapture(F, 1);
415 Changed |= setDoesNotCapture(F, 2);
416 Changed |= setOnlyReadsMemory(F, 1);
417 return Changed;
418 case LibFunc::fscanf:
419 case LibFunc::fprintf:
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]420 Changed |= setDoesNotThrow(F);
421 Changed |= setDoesNotCapture(F, 1);
422 Changed |= setDoesNotCapture(F, 2);
423 Changed |= setOnlyReadsMemory(F, 2);
424 return Changed;
425 case LibFunc::fgetpos:
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]426 Changed |= setDoesNotThrow(F);
427 Changed |= setDoesNotCapture(F, 1);
428 Changed |= setDoesNotCapture(F, 2);
429 return Changed;
430 case LibFunc::getc:
431 case LibFunc::getlogin_r:
432 case LibFunc::getc_unlocked:
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]433 Changed |= setDoesNotThrow(F);
434 Changed |= setDoesNotCapture(F, 1);
435 return Changed;
436 case LibFunc::getenv:
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]437 Changed |= setDoesNotThrow(F);
438 Changed |= setOnlyReadsMemory(F);
439 Changed |= setDoesNotCapture(F, 1);
440 return Changed;
441 case LibFunc::gets:
442 case LibFunc::getchar:
443 Changed |= setDoesNotThrow(F);
444 return Changed;
445 case LibFunc::getitimer:
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]446 Changed |= setDoesNotThrow(F);
447 Changed |= setDoesNotCapture(F, 2);
448 return Changed;
449 case LibFunc::getpwnam:
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]450 Changed |= setDoesNotThrow(F);
451 Changed |= setDoesNotCapture(F, 1);
452 Changed |= setOnlyReadsMemory(F, 1);
453 return Changed;
454 case LibFunc::ungetc:
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]455 Changed |= setDoesNotThrow(F);
456 Changed |= setDoesNotCapture(F, 2);
457 return Changed;
458 case LibFunc::uname:
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]459 Changed |= setDoesNotThrow(F);
460 Changed |= setDoesNotCapture(F, 1);
461 return Changed;
462 case LibFunc::unlink:
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]463 Changed |= setDoesNotThrow(F);
464 Changed |= setDoesNotCapture(F, 1);
465 Changed |= setOnlyReadsMemory(F, 1);
466 return Changed;
467 case LibFunc::unsetenv:
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]468 Changed |= setDoesNotThrow(F);
469 Changed |= setDoesNotCapture(F, 1);
470 Changed |= setOnlyReadsMemory(F, 1);
471 return Changed;
472 case LibFunc::utime:
473 case LibFunc::utimes:
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]474 Changed |= setDoesNotThrow(F);
475 Changed |= setDoesNotCapture(F, 1);
476 Changed |= setDoesNotCapture(F, 2);
477 Changed |= setOnlyReadsMemory(F, 1);
478 Changed |= setOnlyReadsMemory(F, 2);
479 return Changed;
480 case LibFunc::putc:
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]481 Changed |= setDoesNotThrow(F);
482 Changed |= setDoesNotCapture(F, 2);
483 return Changed;
484 case LibFunc::puts:
485 case LibFunc::printf:
486 case LibFunc::perror:
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]487 Changed |= setDoesNotThrow(F);
488 Changed |= setDoesNotCapture(F, 1);
489 Changed |= setOnlyReadsMemory(F, 1);
490 return Changed;
491 case LibFunc::pread:
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]492 // May throw; "pread" is a valid pthread cancellation point.
493 Changed |= setDoesNotCapture(F, 2);
494 return Changed;
495 case LibFunc::pwrite:
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]496 // May throw; "pwrite" is a valid pthread cancellation point.
497 Changed |= setDoesNotCapture(F, 2);
498 Changed |= setOnlyReadsMemory(F, 2);
499 return Changed;
500 case LibFunc::putchar:
501 Changed |= setDoesNotThrow(F);
502 return Changed;
503 case LibFunc::popen:
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]504 Changed |= setDoesNotThrow(F);
505 Changed |= setDoesNotAlias(F, 0);
506 Changed |= setDoesNotCapture(F, 1);
507 Changed |= setDoesNotCapture(F, 2);
508 Changed |= setOnlyReadsMemory(F, 1);
509 Changed |= setOnlyReadsMemory(F, 2);
510 return Changed;
511 case LibFunc::pclose:
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]512 Changed |= setDoesNotThrow(F);
513 Changed |= setDoesNotCapture(F, 1);
514 return Changed;
515 case LibFunc::vscanf:
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]516 Changed |= setDoesNotThrow(F);
517 Changed |= setDoesNotCapture(F, 1);
518 Changed |= setOnlyReadsMemory(F, 1);
519 return Changed;
520 case LibFunc::vsscanf:
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]521 Changed |= setDoesNotThrow(F);
522 Changed |= setDoesNotCapture(F, 1);
523 Changed |= setDoesNotCapture(F, 2);
524 Changed |= setOnlyReadsMemory(F, 1);
525 Changed |= setOnlyReadsMemory(F, 2);
526 return Changed;
527 case LibFunc::vfscanf:
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]528 Changed |= setDoesNotThrow(F);
529 Changed |= setDoesNotCapture(F, 1);
530 Changed |= setDoesNotCapture(F, 2);
531 Changed |= setOnlyReadsMemory(F, 2);
532 return Changed;
533 case LibFunc::valloc:
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]534 Changed |= setDoesNotThrow(F);
535 Changed |= setDoesNotAlias(F, 0);
536 return Changed;
537 case LibFunc::vprintf:
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]538 Changed |= setDoesNotThrow(F);
539 Changed |= setDoesNotCapture(F, 1);
540 Changed |= setOnlyReadsMemory(F, 1);
541 return Changed;
542 case LibFunc::vfprintf:
543 case LibFunc::vsprintf:
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]544 Changed |= setDoesNotThrow(F);
545 Changed |= setDoesNotCapture(F, 1);
546 Changed |= setDoesNotCapture(F, 2);
547 Changed |= setOnlyReadsMemory(F, 2);
548 return Changed;
549 case LibFunc::vsnprintf:
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]550 Changed |= setDoesNotThrow(F);
551 Changed |= setDoesNotCapture(F, 1);
552 Changed |= setDoesNotCapture(F, 3);
553 Changed |= setOnlyReadsMemory(F, 3);
554 return Changed;
555 case LibFunc::open:
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]556 // May throw; "open" is a valid pthread cancellation point.
557 Changed |= setDoesNotCapture(F, 1);
558 Changed |= setOnlyReadsMemory(F, 1);
559 return Changed;
560 case LibFunc::opendir:
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]561 Changed |= setDoesNotThrow(F);
562 Changed |= setDoesNotAlias(F, 0);
563 Changed |= setDoesNotCapture(F, 1);
564 Changed |= setOnlyReadsMemory(F, 1);
565 return Changed;
566 case LibFunc::tmpfile:
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]567 Changed |= setDoesNotThrow(F);
568 Changed |= setDoesNotAlias(F, 0);
569 return Changed;
570 case LibFunc::times:
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]571 Changed |= setDoesNotThrow(F);
572 Changed |= setDoesNotCapture(F, 1);
573 return Changed;
574 case LibFunc::htonl:
575 case LibFunc::htons:
576 case LibFunc::ntohl:
577 case LibFunc::ntohs:
578 Changed |= setDoesNotThrow(F);
579 Changed |= setDoesNotAccessMemory(F);
580 return Changed;
581 case LibFunc::lstat:
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]582 Changed |= setDoesNotThrow(F);
583 Changed |= setDoesNotCapture(F, 1);
584 Changed |= setDoesNotCapture(F, 2);
585 Changed |= setOnlyReadsMemory(F, 1);
586 return Changed;
587 case LibFunc::lchown:
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]588 Changed |= setDoesNotThrow(F);
589 Changed |= setDoesNotCapture(F, 1);
590 Changed |= setOnlyReadsMemory(F, 1);
591 return Changed;
592 case LibFunc::qsort:
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]593 // May throw; places call through function pointer.
594 Changed |= setDoesNotCapture(F, 4);
595 return Changed;
596 case LibFunc::dunder_strdup:
597 case LibFunc::dunder_strndup:
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]598 Changed |= setDoesNotThrow(F);
599 Changed |= setDoesNotAlias(F, 0);
600 Changed |= setDoesNotCapture(F, 1);
601 Changed |= setOnlyReadsMemory(F, 1);
602 return Changed;
603 case LibFunc::dunder_strtok_r:
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]604 Changed |= setDoesNotThrow(F);
605 Changed |= setDoesNotCapture(F, 2);
606 Changed |= setOnlyReadsMemory(F, 2);
607 return Changed;
608 case LibFunc::under_IO_getc:
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]609 Changed |= setDoesNotThrow(F);
610 Changed |= setDoesNotCapture(F, 1);
611 return Changed;
612 case LibFunc::under_IO_putc:
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]613 Changed |= setDoesNotThrow(F);
614 Changed |= setDoesNotCapture(F, 2);
615 return Changed;
616 case LibFunc::dunder_isoc99_scanf:
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]617 Changed |= setDoesNotThrow(F);
618 Changed |= setDoesNotCapture(F, 1);
619 Changed |= setOnlyReadsMemory(F, 1);
620 return Changed;
621 case LibFunc::stat64:
622 case LibFunc::lstat64:
623 case LibFunc::statvfs64:
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]624 Changed |= setDoesNotThrow(F);
625 Changed |= setDoesNotCapture(F, 1);
626 Changed |= setDoesNotCapture(F, 2);
627 Changed |= setOnlyReadsMemory(F, 1);
628 return Changed;
629 case LibFunc::dunder_isoc99_sscanf:
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]630 Changed |= setDoesNotThrow(F);
631 Changed |= setDoesNotCapture(F, 1);
632 Changed |= setDoesNotCapture(F, 2);
633 Changed |= setOnlyReadsMemory(F, 1);
634 Changed |= setOnlyReadsMemory(F, 2);
635 return Changed;
636 case LibFunc::fopen64:
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]637 Changed |= setDoesNotThrow(F);
638 Changed |= setDoesNotAlias(F, 0);
639 Changed |= setDoesNotCapture(F, 1);
640 Changed |= setDoesNotCapture(F, 2);
641 Changed |= setOnlyReadsMemory(F, 1);
642 Changed |= setOnlyReadsMemory(F, 2);
643 return Changed;
644 case LibFunc::fseeko64:
645 case LibFunc::ftello64:
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]646 Changed |= setDoesNotThrow(F);
647 Changed |= setDoesNotCapture(F, 1);
648 return Changed;
649 case LibFunc::tmpfile64:
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]650 Changed |= setDoesNotThrow(F);
651 Changed |= setDoesNotAlias(F, 0);
652 return Changed;
653 case LibFunc::fstat64:
654 case LibFunc::fstatvfs64:
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]655 Changed |= setDoesNotThrow(F);
656 Changed |= setDoesNotCapture(F, 2);
657 return Changed;
658 case LibFunc::open64:
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]659 // May throw; "open" is a valid pthread cancellation point.
660 Changed |= setDoesNotCapture(F, 1);
661 Changed |= setOnlyReadsMemory(F, 1);
662 return Changed;
663 case LibFunc::gettimeofday:
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]664 // Currently some platforms have the restrict keyword on the arguments to
665 // gettimeofday. To be conservative, do not add noalias to gettimeofday's
666 // arguments.
667 Changed |= setDoesNotThrow(F);
668 Changed |= setDoesNotCapture(F, 1);
669 Changed |= setDoesNotCapture(F, 2);
670 return Changed;
Philip Reames24667192016-01-04 22:49:23 +0000[diff] [blame]671 case LibFunc::Znwj: // new(unsigned int)
672 case LibFunc::Znwm: // new(unsigned long)
673 case LibFunc::Znaj: // new[](unsigned int)
674 case LibFunc::Znam: // new[](unsigned long)
675 case LibFunc::msvc_new_int: // new(unsigned int)
676 case LibFunc::msvc_new_longlong: // new(unsigned long long)
677 case LibFunc::msvc_new_array_int: // new[](unsigned int)
678 case LibFunc::msvc_new_array_longlong: // new[](unsigned long long)
Philip Reames24667192016-01-04 22:49:23 +0000[diff] [blame]679 // Operator new always returns a nonnull noalias pointer
680 Changed |= setNonNull(F, AttributeSet::ReturnIndex);
681 Changed |= setDoesNotAlias(F, AttributeSet::ReturnIndex);
682 return Changed;
Philip Reamesae050a52016-01-06 04:53:16 +0000[diff] [blame]683 //TODO: add LibFunc entries for:
684 //case LibFunc::memset_pattern4:
685 //case LibFunc::memset_pattern8:
686 case LibFunc::memset_pattern16:
Philip Reamesae050a52016-01-06 04:53:16 +0000[diff] [blame]687 Changed |= setOnlyAccessesArgMemory(F);
688 Changed |= setOnlyReadsMemory(F, 2);
689 return Changed;
David Majnemerae272d72016-03-31 21:29:57 +0000[diff] [blame]690 // int __nvvm_reflect(const char *)
691 case LibFunc::nvvm_reflect:
David Majnemerae272d72016-03-31 21:29:57 +0000[diff] [blame]692 Changed |= setDoesNotAccessMemory(F);
693 Changed |= setDoesNotThrow(F);
694 return Changed;
695
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]696 default:
697 // FIXME: It'd be really nice to cover all the library functions we're
698 // aware of here.
699 return false;
700 }
701}
702
703static bool inferAllPrototypeAttributes(Module &M,
704 const TargetLibraryInfo &TLI) {
705 bool Changed = false;
706
707 for (Function &F : M.functions())
708 // We only infer things using the prototype if the definition isn't around
709 // to analyze directly.
710 if (F.isDeclaration())
711 Changed |= inferPrototypeAttributes(F, TLI);
712
713 return Changed;
714}
715
716PreservedAnalyses InferFunctionAttrsPass::run(Module &M,
Chandler Carruthb47f8012016-03-11 11:05:24 +0000[diff] [blame]717 AnalysisManager<Module> &AM) {
718 auto &TLI = AM.getResult<TargetLibraryAnalysis>(M);
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]719
720 if (!inferAllPrototypeAttributes(M, TLI))
721 // If we didn't infer anything, preserve all analyses.
722 return PreservedAnalyses::all();
723
724 // Otherwise, we may have changed fundamental function attributes, so clear
725 // out all the passes.
726 return PreservedAnalyses::none();
727}
728
729namespace {
730struct InferFunctionAttrsLegacyPass : public ModulePass {
731 static char ID; // Pass identification, replacement for typeid
732 InferFunctionAttrsLegacyPass() : ModulePass(ID) {
733 initializeInferFunctionAttrsLegacyPassPass(
734 *PassRegistry::getPassRegistry());
735 }
736
737 void getAnalysisUsage(AnalysisUsage &AU) const override {
738 AU.addRequired<TargetLibraryInfoWrapperPass>();
739 }
740
741 bool runOnModule(Module &M) override {
Andrew Kayloraa641a52016-04-22 22:06:11 +0000[diff] [blame]742 if (skipModule(M))
743 return false;
744
Chandler Carruth3a040e62015-12-27 08:41:34 +0000[diff] [blame]745 auto &TLI = getAnalysis<TargetLibraryInfoWrapperPass>().getTLI();
746 return inferAllPrototypeAttributes(M, TLI);
747 }
748};
749}
750
751char InferFunctionAttrsLegacyPass::ID = 0;
752INITIALIZE_PASS_BEGIN(InferFunctionAttrsLegacyPass, "inferattrs",
753 "Infer set function attributes", false, false)
754INITIALIZE_PASS_DEPENDENCY(TargetLibraryInfoWrapperPass)
755INITIALIZE_PASS_END(InferFunctionAttrsLegacyPass, "inferattrs",
756 "Infer set function attributes", false, false)
757
758Pass *llvm::createInferFunctionAttrsLegacyPass() {
759 return new InferFunctionAttrsLegacyPass();
760}