Gitiles
Code Review Sign In
gerrit-public.fairphone.software / toolchain / llvm-project / de3b9a2ecc7e9ebe3fc1780aede0223821c52d2a / . / llvm / lib / Transforms / Utils / BuildLibCalls.cpp
blob: aac604531da427457136701e83f7a46d7ebe7c15 [file] [log] [blame]
Eric Christopher87abfc52010-03-05 22:25:30 +0000[diff] [blame]1//===- BuildLibCalls.cpp - Utility builder for libcalls -------------------===//
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// This file implements some functions that will create standard C libcalls.
11//
12//===----------------------------------------------------------------------===//
13
14#include "llvm/Transforms/Utils/BuildLibCalls.h"
Chandler Carruthed0881b2012-12-03 16:50:05 +0000[diff] [blame]15#include "llvm/ADT/SmallString.h"
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]16#include "llvm/ADT/Statistic.h"
Weiming Zhao45d4cb92015-11-24 18:57:06 +0000[diff] [blame]17#include "llvm/Analysis/TargetLibraryInfo.h"
Chandler Carruth9fb823b2013-01-02 11:36:10 +0000[diff] [blame]18#include "llvm/IR/Constants.h"
19#include "llvm/IR/DataLayout.h"
20#include "llvm/IR/Function.h"
21#include "llvm/IR/IRBuilder.h"
22#include "llvm/IR/Intrinsics.h"
23#include "llvm/IR/LLVMContext.h"
24#include "llvm/IR/Module.h"
25#include "llvm/IR/Type.h"
Eric Christopher87abfc52010-03-05 22:25:30 +0000[diff] [blame]26
27using namespace llvm;
28
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]29#define DEBUG_TYPE "build-libcalls"
30
31//- Infer Attributes ---------------------------------------------------------//
32
33STATISTIC(NumReadNone, "Number of functions inferred as readnone");
34STATISTIC(NumReadOnly, "Number of functions inferred as readonly");
35STATISTIC(NumArgMemOnly, "Number of functions inferred as argmemonly");
36STATISTIC(NumNoUnwind, "Number of functions inferred as nounwind");
37STATISTIC(NumNoCapture, "Number of arguments inferred as nocapture");
38STATISTIC(NumReadOnlyArg, "Number of arguments inferred as readonly");
39STATISTIC(NumNoAlias, "Number of function returns inferred as noalias");
40STATISTIC(NumNonNull, "Number of function returns inferred as nonnull returns");
41
42static bool setDoesNotAccessMemory(Function &F) {
43 if (F.doesNotAccessMemory())
44 return false;
45 F.setDoesNotAccessMemory();
46 ++NumReadNone;
47 return true;
48}
49
50static bool setOnlyReadsMemory(Function &F) {
51 if (F.onlyReadsMemory())
52 return false;
53 F.setOnlyReadsMemory();
54 ++NumReadOnly;
55 return true;
56}
57
58static bool setOnlyAccessesArgMemory(Function &F) {
59 if (F.onlyAccessesArgMemory())
60 return false;
61 F.setOnlyAccessesArgMemory ();
62 ++NumArgMemOnly;
63 return true;
64}
65
66static bool setDoesNotThrow(Function &F) {
67 if (F.doesNotThrow())
68 return false;
69 F.setDoesNotThrow();
70 ++NumNoUnwind;
71 return true;
72}
73
74static bool setDoesNotCapture(Function &F, unsigned n) {
75 if (F.doesNotCapture(n))
76 return false;
77 F.setDoesNotCapture(n);
78 ++NumNoCapture;
79 return true;
80}
81
82static bool setOnlyReadsMemory(Function &F, unsigned n) {
83 if (F.onlyReadsMemory(n))
84 return false;
85 F.setOnlyReadsMemory(n);
86 ++NumReadOnlyArg;
87 return true;
88}
89
90static bool setDoesNotAlias(Function &F, unsigned n) {
91 if (F.doesNotAlias(n))
92 return false;
93 F.setDoesNotAlias(n);
94 ++NumNoAlias;
95 return true;
96}
97
98static bool setNonNull(Function &F, unsigned n) {
Reid Klecknerb5180542017-03-21 16:57:19 +0000[diff] [blame]99 assert(
100 (n != AttributeList::ReturnIndex || F.getReturnType()->isPointerTy()) &&
101 "nonnull applies only to pointers");
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]102 if (F.getAttributes().hasAttribute(n, Attribute::NonNull))
103 return false;
104 F.addAttribute(n, Attribute::NonNull);
105 ++NumNonNull;
106 return true;
107}
108
109bool llvm::inferLibFuncAttributes(Function &F, const TargetLibraryInfo &TLI) {
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]110 LibFunc TheLibFunc;
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]111 if (!(TLI.getLibFunc(F, TheLibFunc) && TLI.has(TheLibFunc)))
112 return false;
113
114 bool Changed = false;
115 switch (TheLibFunc) {
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]116 case LibFunc_strlen:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]117 Changed |= setOnlyReadsMemory(F);
118 Changed |= setDoesNotThrow(F);
119 Changed |= setDoesNotCapture(F, 1);
120 return Changed;
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]121 case LibFunc_strchr:
122 case LibFunc_strrchr:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]123 Changed |= setOnlyReadsMemory(F);
124 Changed |= setDoesNotThrow(F);
125 return Changed;
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]126 case LibFunc_strtol:
127 case LibFunc_strtod:
128 case LibFunc_strtof:
129 case LibFunc_strtoul:
130 case LibFunc_strtoll:
131 case LibFunc_strtold:
132 case LibFunc_strtoull:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]133 Changed |= setDoesNotThrow(F);
134 Changed |= setDoesNotCapture(F, 2);
135 Changed |= setOnlyReadsMemory(F, 1);
136 return Changed;
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]137 case LibFunc_strcpy:
138 case LibFunc_stpcpy:
139 case LibFunc_strcat:
140 case LibFunc_strncat:
141 case LibFunc_strncpy:
142 case LibFunc_stpncpy:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]143 Changed |= setDoesNotThrow(F);
144 Changed |= setDoesNotCapture(F, 2);
145 Changed |= setOnlyReadsMemory(F, 2);
146 return Changed;
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]147 case LibFunc_strxfrm:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]148 Changed |= setDoesNotThrow(F);
149 Changed |= setDoesNotCapture(F, 1);
150 Changed |= setDoesNotCapture(F, 2);
151 Changed |= setOnlyReadsMemory(F, 2);
152 return Changed;
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]153 case LibFunc_strcmp: // 0,1
154 case LibFunc_strspn: // 0,1
155 case LibFunc_strncmp: // 0,1
156 case LibFunc_strcspn: // 0,1
157 case LibFunc_strcoll: // 0,1
158 case LibFunc_strcasecmp: // 0,1
159 case LibFunc_strncasecmp: //
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]160 Changed |= setOnlyReadsMemory(F);
161 Changed |= setDoesNotThrow(F);
162 Changed |= setDoesNotCapture(F, 1);
163 Changed |= setDoesNotCapture(F, 2);
164 return Changed;
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]165 case LibFunc_strstr:
166 case LibFunc_strpbrk:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]167 Changed |= setOnlyReadsMemory(F);
168 Changed |= setDoesNotThrow(F);
169 Changed |= setDoesNotCapture(F, 2);
170 return Changed;
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]171 case LibFunc_strtok:
172 case LibFunc_strtok_r:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]173 Changed |= setDoesNotThrow(F);
174 Changed |= setDoesNotCapture(F, 2);
175 Changed |= setOnlyReadsMemory(F, 2);
176 return Changed;
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]177 case LibFunc_scanf:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]178 Changed |= setDoesNotThrow(F);
179 Changed |= setDoesNotCapture(F, 1);
180 Changed |= setOnlyReadsMemory(F, 1);
181 return Changed;
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]182 case LibFunc_setbuf:
183 case LibFunc_setvbuf:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]184 Changed |= setDoesNotThrow(F);
185 Changed |= setDoesNotCapture(F, 1);
186 return Changed;
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]187 case LibFunc_strdup:
188 case LibFunc_strndup:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]189 Changed |= setDoesNotThrow(F);
190 Changed |= setDoesNotAlias(F, 0);
191 Changed |= setDoesNotCapture(F, 1);
192 Changed |= setOnlyReadsMemory(F, 1);
193 return Changed;
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]194 case LibFunc_stat:
195 case LibFunc_statvfs:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]196 Changed |= setDoesNotThrow(F);
197 Changed |= setDoesNotCapture(F, 1);
198 Changed |= setDoesNotCapture(F, 2);
199 Changed |= setOnlyReadsMemory(F, 1);
200 return Changed;
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]201 case LibFunc_sscanf:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]202 Changed |= setDoesNotThrow(F);
203 Changed |= setDoesNotCapture(F, 1);
204 Changed |= setDoesNotCapture(F, 2);
205 Changed |= setOnlyReadsMemory(F, 1);
206 Changed |= setOnlyReadsMemory(F, 2);
207 return Changed;
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]208 case LibFunc_sprintf:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]209 Changed |= setDoesNotThrow(F);
210 Changed |= setDoesNotCapture(F, 1);
211 Changed |= setDoesNotCapture(F, 2);
212 Changed |= setOnlyReadsMemory(F, 2);
213 return Changed;
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]214 case LibFunc_snprintf:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]215 Changed |= setDoesNotThrow(F);
216 Changed |= setDoesNotCapture(F, 1);
217 Changed |= setDoesNotCapture(F, 3);
218 Changed |= setOnlyReadsMemory(F, 3);
219 return Changed;
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]220 case LibFunc_setitimer:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]221 Changed |= setDoesNotThrow(F);
222 Changed |= setDoesNotCapture(F, 2);
223 Changed |= setDoesNotCapture(F, 3);
224 Changed |= setOnlyReadsMemory(F, 2);
225 return Changed;
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]226 case LibFunc_system:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]227 // May throw; "system" is a valid pthread cancellation point.
228 Changed |= setDoesNotCapture(F, 1);
229 Changed |= setOnlyReadsMemory(F, 1);
230 return Changed;
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]231 case LibFunc_malloc:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]232 Changed |= setDoesNotThrow(F);
233 Changed |= setDoesNotAlias(F, 0);
234 return Changed;
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]235 case LibFunc_memcmp:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]236 Changed |= setOnlyReadsMemory(F);
237 Changed |= setDoesNotThrow(F);
238 Changed |= setDoesNotCapture(F, 1);
239 Changed |= setDoesNotCapture(F, 2);
240 return Changed;
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]241 case LibFunc_memchr:
242 case LibFunc_memrchr:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]243 Changed |= setOnlyReadsMemory(F);
244 Changed |= setDoesNotThrow(F);
245 return Changed;
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]246 case LibFunc_modf:
247 case LibFunc_modff:
248 case LibFunc_modfl:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]249 Changed |= setDoesNotThrow(F);
250 Changed |= setDoesNotCapture(F, 2);
251 return Changed;
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]252 case LibFunc_memcpy:
253 case LibFunc_mempcpy:
254 case LibFunc_memccpy:
255 case LibFunc_memmove:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]256 Changed |= setDoesNotThrow(F);
257 Changed |= setDoesNotCapture(F, 2);
258 Changed |= setOnlyReadsMemory(F, 2);
259 return Changed;
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]260 case LibFunc_memcpy_chk:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]261 Changed |= setDoesNotThrow(F);
262 return Changed;
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]263 case LibFunc_memalign:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]264 Changed |= setDoesNotAlias(F, 0);
265 return Changed;
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]266 case LibFunc_mkdir:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]267 Changed |= setDoesNotThrow(F);
268 Changed |= setDoesNotCapture(F, 1);
269 Changed |= setOnlyReadsMemory(F, 1);
270 return Changed;
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]271 case LibFunc_mktime:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]272 Changed |= setDoesNotThrow(F);
273 Changed |= setDoesNotCapture(F, 1);
274 return Changed;
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]275 case LibFunc_realloc:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]276 Changed |= setDoesNotThrow(F);
277 Changed |= setDoesNotAlias(F, 0);
278 Changed |= setDoesNotCapture(F, 1);
279 return Changed;
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]280 case LibFunc_read:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]281 // May throw; "read" is a valid pthread cancellation point.
282 Changed |= setDoesNotCapture(F, 2);
283 return Changed;
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]284 case LibFunc_rewind:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]285 Changed |= setDoesNotThrow(F);
286 Changed |= setDoesNotCapture(F, 1);
287 return Changed;
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]288 case LibFunc_rmdir:
289 case LibFunc_remove:
290 case LibFunc_realpath:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]291 Changed |= setDoesNotThrow(F);
292 Changed |= setDoesNotCapture(F, 1);
293 Changed |= setOnlyReadsMemory(F, 1);
294 return Changed;
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]295 case LibFunc_rename:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]296 Changed |= setDoesNotThrow(F);
297 Changed |= setDoesNotCapture(F, 1);
298 Changed |= setDoesNotCapture(F, 2);
299 Changed |= setOnlyReadsMemory(F, 1);
300 Changed |= setOnlyReadsMemory(F, 2);
301 return Changed;
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]302 case LibFunc_readlink:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]303 Changed |= setDoesNotThrow(F);
304 Changed |= setDoesNotCapture(F, 1);
305 Changed |= setDoesNotCapture(F, 2);
306 Changed |= setOnlyReadsMemory(F, 1);
307 return Changed;
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]308 case LibFunc_write:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]309 // May throw; "write" is a valid pthread cancellation point.
310 Changed |= setDoesNotCapture(F, 2);
311 Changed |= setOnlyReadsMemory(F, 2);
312 return Changed;
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]313 case LibFunc_bcopy:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]314 Changed |= setDoesNotThrow(F);
315 Changed |= setDoesNotCapture(F, 1);
316 Changed |= setDoesNotCapture(F, 2);
317 Changed |= setOnlyReadsMemory(F, 1);
318 return Changed;
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]319 case LibFunc_bcmp:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]320 Changed |= setDoesNotThrow(F);
321 Changed |= setOnlyReadsMemory(F);
322 Changed |= setDoesNotCapture(F, 1);
323 Changed |= setDoesNotCapture(F, 2);
324 return Changed;
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]325 case LibFunc_bzero:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]326 Changed |= setDoesNotThrow(F);
327 Changed |= setDoesNotCapture(F, 1);
328 return Changed;
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]329 case LibFunc_calloc:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]330 Changed |= setDoesNotThrow(F);
331 Changed |= setDoesNotAlias(F, 0);
332 return Changed;
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]333 case LibFunc_chmod:
334 case LibFunc_chown:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]335 Changed |= setDoesNotThrow(F);
336 Changed |= setDoesNotCapture(F, 1);
337 Changed |= setOnlyReadsMemory(F, 1);
338 return Changed;
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]339 case LibFunc_ctermid:
340 case LibFunc_clearerr:
341 case LibFunc_closedir:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]342 Changed |= setDoesNotThrow(F);
343 Changed |= setDoesNotCapture(F, 1);
344 return Changed;
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]345 case LibFunc_atoi:
346 case LibFunc_atol:
347 case LibFunc_atof:
348 case LibFunc_atoll:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]349 Changed |= setDoesNotThrow(F);
350 Changed |= setOnlyReadsMemory(F);
351 Changed |= setDoesNotCapture(F, 1);
352 return Changed;
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]353 case LibFunc_access:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]354 Changed |= setDoesNotThrow(F);
355 Changed |= setDoesNotCapture(F, 1);
356 Changed |= setOnlyReadsMemory(F, 1);
357 return Changed;
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]358 case LibFunc_fopen:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]359 Changed |= setDoesNotThrow(F);
360 Changed |= setDoesNotAlias(F, 0);
361 Changed |= setDoesNotCapture(F, 1);
362 Changed |= setDoesNotCapture(F, 2);
363 Changed |= setOnlyReadsMemory(F, 1);
364 Changed |= setOnlyReadsMemory(F, 2);
365 return Changed;
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]366 case LibFunc_fdopen:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]367 Changed |= setDoesNotThrow(F);
368 Changed |= setDoesNotAlias(F, 0);
369 Changed |= setDoesNotCapture(F, 2);
370 Changed |= setOnlyReadsMemory(F, 2);
371 return Changed;
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]372 case LibFunc_feof:
373 case LibFunc_free:
374 case LibFunc_fseek:
375 case LibFunc_ftell:
376 case LibFunc_fgetc:
377 case LibFunc_fseeko:
378 case LibFunc_ftello:
379 case LibFunc_fileno:
380 case LibFunc_fflush:
381 case LibFunc_fclose:
382 case LibFunc_fsetpos:
383 case LibFunc_flockfile:
384 case LibFunc_funlockfile:
385 case LibFunc_ftrylockfile:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]386 Changed |= setDoesNotThrow(F);
387 Changed |= setDoesNotCapture(F, 1);
388 return Changed;
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]389 case LibFunc_ferror:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]390 Changed |= setDoesNotThrow(F);
391 Changed |= setDoesNotCapture(F, 1);
392 Changed |= setOnlyReadsMemory(F);
393 return Changed;
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]394 case LibFunc_fputc:
395 case LibFunc_fstat:
396 case LibFunc_frexp:
397 case LibFunc_frexpf:
398 case LibFunc_frexpl:
399 case LibFunc_fstatvfs:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]400 Changed |= setDoesNotThrow(F);
401 Changed |= setDoesNotCapture(F, 2);
402 return Changed;
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]403 case LibFunc_fgets:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]404 Changed |= setDoesNotThrow(F);
405 Changed |= setDoesNotCapture(F, 3);
406 return Changed;
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]407 case LibFunc_fread:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]408 Changed |= setDoesNotThrow(F);
409 Changed |= setDoesNotCapture(F, 1);
410 Changed |= setDoesNotCapture(F, 4);
411 return Changed;
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]412 case LibFunc_fwrite:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]413 Changed |= setDoesNotThrow(F);
414 Changed |= setDoesNotCapture(F, 1);
415 Changed |= setDoesNotCapture(F, 4);
416 // FIXME: readonly #1?
417 return Changed;
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]418 case LibFunc_fputs:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]419 Changed |= setDoesNotThrow(F);
420 Changed |= setDoesNotCapture(F, 1);
421 Changed |= setDoesNotCapture(F, 2);
422 Changed |= setOnlyReadsMemory(F, 1);
423 return Changed;
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]424 case LibFunc_fscanf:
425 case LibFunc_fprintf:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]426 Changed |= setDoesNotThrow(F);
427 Changed |= setDoesNotCapture(F, 1);
428 Changed |= setDoesNotCapture(F, 2);
429 Changed |= setOnlyReadsMemory(F, 2);
430 return Changed;
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]431 case LibFunc_fgetpos:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]432 Changed |= setDoesNotThrow(F);
433 Changed |= setDoesNotCapture(F, 1);
434 Changed |= setDoesNotCapture(F, 2);
435 return Changed;
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]436 case LibFunc_getc:
437 case LibFunc_getlogin_r:
438 case LibFunc_getc_unlocked:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]439 Changed |= setDoesNotThrow(F);
440 Changed |= setDoesNotCapture(F, 1);
441 return Changed;
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]442 case LibFunc_getenv:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]443 Changed |= setDoesNotThrow(F);
444 Changed |= setOnlyReadsMemory(F);
445 Changed |= setDoesNotCapture(F, 1);
446 return Changed;
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]447 case LibFunc_gets:
448 case LibFunc_getchar:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]449 Changed |= setDoesNotThrow(F);
450 return Changed;
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]451 case LibFunc_getitimer:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]452 Changed |= setDoesNotThrow(F);
453 Changed |= setDoesNotCapture(F, 2);
454 return Changed;
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]455 case LibFunc_getpwnam:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]456 Changed |= setDoesNotThrow(F);
457 Changed |= setDoesNotCapture(F, 1);
458 Changed |= setOnlyReadsMemory(F, 1);
459 return Changed;
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]460 case LibFunc_ungetc:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]461 Changed |= setDoesNotThrow(F);
462 Changed |= setDoesNotCapture(F, 2);
463 return Changed;
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]464 case LibFunc_uname:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]465 Changed |= setDoesNotThrow(F);
466 Changed |= setDoesNotCapture(F, 1);
467 return Changed;
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]468 case LibFunc_unlink:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]469 Changed |= setDoesNotThrow(F);
470 Changed |= setDoesNotCapture(F, 1);
471 Changed |= setOnlyReadsMemory(F, 1);
472 return Changed;
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]473 case LibFunc_unsetenv:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]474 Changed |= setDoesNotThrow(F);
475 Changed |= setDoesNotCapture(F, 1);
476 Changed |= setOnlyReadsMemory(F, 1);
477 return Changed;
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]478 case LibFunc_utime:
479 case LibFunc_utimes:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]480 Changed |= setDoesNotThrow(F);
481 Changed |= setDoesNotCapture(F, 1);
482 Changed |= setDoesNotCapture(F, 2);
483 Changed |= setOnlyReadsMemory(F, 1);
484 Changed |= setOnlyReadsMemory(F, 2);
485 return Changed;
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]486 case LibFunc_putc:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]487 Changed |= setDoesNotThrow(F);
488 Changed |= setDoesNotCapture(F, 2);
489 return Changed;
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]490 case LibFunc_puts:
491 case LibFunc_printf:
492 case LibFunc_perror:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]493 Changed |= setDoesNotThrow(F);
494 Changed |= setDoesNotCapture(F, 1);
495 Changed |= setOnlyReadsMemory(F, 1);
496 return Changed;
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]497 case LibFunc_pread:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]498 // May throw; "pread" is a valid pthread cancellation point.
499 Changed |= setDoesNotCapture(F, 2);
500 return Changed;
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]501 case LibFunc_pwrite:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]502 // May throw; "pwrite" is a valid pthread cancellation point.
503 Changed |= setDoesNotCapture(F, 2);
504 Changed |= setOnlyReadsMemory(F, 2);
505 return Changed;
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]506 case LibFunc_putchar:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]507 Changed |= setDoesNotThrow(F);
508 return Changed;
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]509 case LibFunc_popen:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]510 Changed |= setDoesNotThrow(F);
511 Changed |= setDoesNotAlias(F, 0);
512 Changed |= setDoesNotCapture(F, 1);
513 Changed |= setDoesNotCapture(F, 2);
514 Changed |= setOnlyReadsMemory(F, 1);
515 Changed |= setOnlyReadsMemory(F, 2);
516 return Changed;
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]517 case LibFunc_pclose:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]518 Changed |= setDoesNotThrow(F);
519 Changed |= setDoesNotCapture(F, 1);
520 return Changed;
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]521 case LibFunc_vscanf:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]522 Changed |= setDoesNotThrow(F);
523 Changed |= setDoesNotCapture(F, 1);
524 Changed |= setOnlyReadsMemory(F, 1);
525 return Changed;
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]526 case LibFunc_vsscanf:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]527 Changed |= setDoesNotThrow(F);
528 Changed |= setDoesNotCapture(F, 1);
529 Changed |= setDoesNotCapture(F, 2);
530 Changed |= setOnlyReadsMemory(F, 1);
531 Changed |= setOnlyReadsMemory(F, 2);
532 return Changed;
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]533 case LibFunc_vfscanf:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]534 Changed |= setDoesNotThrow(F);
535 Changed |= setDoesNotCapture(F, 1);
536 Changed |= setDoesNotCapture(F, 2);
537 Changed |= setOnlyReadsMemory(F, 2);
538 return Changed;
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]539 case LibFunc_valloc:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]540 Changed |= setDoesNotThrow(F);
541 Changed |= setDoesNotAlias(F, 0);
542 return Changed;
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]543 case LibFunc_vprintf:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]544 Changed |= setDoesNotThrow(F);
545 Changed |= setDoesNotCapture(F, 1);
546 Changed |= setOnlyReadsMemory(F, 1);
547 return Changed;
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]548 case LibFunc_vfprintf:
549 case LibFunc_vsprintf:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]550 Changed |= setDoesNotThrow(F);
551 Changed |= setDoesNotCapture(F, 1);
552 Changed |= setDoesNotCapture(F, 2);
553 Changed |= setOnlyReadsMemory(F, 2);
554 return Changed;
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]555 case LibFunc_vsnprintf:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]556 Changed |= setDoesNotThrow(F);
557 Changed |= setDoesNotCapture(F, 1);
558 Changed |= setDoesNotCapture(F, 3);
559 Changed |= setOnlyReadsMemory(F, 3);
560 return Changed;
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]561 case LibFunc_open:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]562 // May throw; "open" is a valid pthread cancellation point.
563 Changed |= setDoesNotCapture(F, 1);
564 Changed |= setOnlyReadsMemory(F, 1);
565 return Changed;
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]566 case LibFunc_opendir:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]567 Changed |= setDoesNotThrow(F);
568 Changed |= setDoesNotAlias(F, 0);
569 Changed |= setDoesNotCapture(F, 1);
570 Changed |= setOnlyReadsMemory(F, 1);
571 return Changed;
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]572 case LibFunc_tmpfile:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]573 Changed |= setDoesNotThrow(F);
574 Changed |= setDoesNotAlias(F, 0);
575 return Changed;
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]576 case LibFunc_times:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]577 Changed |= setDoesNotThrow(F);
578 Changed |= setDoesNotCapture(F, 1);
579 return Changed;
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]580 case LibFunc_htonl:
581 case LibFunc_htons:
582 case LibFunc_ntohl:
583 case LibFunc_ntohs:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]584 Changed |= setDoesNotThrow(F);
585 Changed |= setDoesNotAccessMemory(F);
586 return Changed;
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]587 case LibFunc_lstat:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]588 Changed |= setDoesNotThrow(F);
589 Changed |= setDoesNotCapture(F, 1);
590 Changed |= setDoesNotCapture(F, 2);
591 Changed |= setOnlyReadsMemory(F, 1);
592 return Changed;
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]593 case LibFunc_lchown:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]594 Changed |= setDoesNotThrow(F);
595 Changed |= setDoesNotCapture(F, 1);
596 Changed |= setOnlyReadsMemory(F, 1);
597 return Changed;
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]598 case LibFunc_qsort:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]599 // May throw; places call through function pointer.
600 Changed |= setDoesNotCapture(F, 4);
601 return Changed;
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]602 case LibFunc_dunder_strdup:
603 case LibFunc_dunder_strndup:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]604 Changed |= setDoesNotThrow(F);
605 Changed |= setDoesNotAlias(F, 0);
606 Changed |= setDoesNotCapture(F, 1);
607 Changed |= setOnlyReadsMemory(F, 1);
608 return Changed;
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]609 case LibFunc_dunder_strtok_r:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]610 Changed |= setDoesNotThrow(F);
611 Changed |= setDoesNotCapture(F, 2);
612 Changed |= setOnlyReadsMemory(F, 2);
613 return Changed;
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]614 case LibFunc_under_IO_getc:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]615 Changed |= setDoesNotThrow(F);
616 Changed |= setDoesNotCapture(F, 1);
617 return Changed;
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]618 case LibFunc_under_IO_putc:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]619 Changed |= setDoesNotThrow(F);
620 Changed |= setDoesNotCapture(F, 2);
621 return Changed;
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]622 case LibFunc_dunder_isoc99_scanf:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]623 Changed |= setDoesNotThrow(F);
624 Changed |= setDoesNotCapture(F, 1);
625 Changed |= setOnlyReadsMemory(F, 1);
626 return Changed;
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]627 case LibFunc_stat64:
628 case LibFunc_lstat64:
629 case LibFunc_statvfs64:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]630 Changed |= setDoesNotThrow(F);
631 Changed |= setDoesNotCapture(F, 1);
632 Changed |= setDoesNotCapture(F, 2);
633 Changed |= setOnlyReadsMemory(F, 1);
634 return Changed;
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]635 case LibFunc_dunder_isoc99_sscanf:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]636 Changed |= setDoesNotThrow(F);
637 Changed |= setDoesNotCapture(F, 1);
638 Changed |= setDoesNotCapture(F, 2);
639 Changed |= setOnlyReadsMemory(F, 1);
640 Changed |= setOnlyReadsMemory(F, 2);
641 return Changed;
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]642 case LibFunc_fopen64:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]643 Changed |= setDoesNotThrow(F);
644 Changed |= setDoesNotAlias(F, 0);
645 Changed |= setDoesNotCapture(F, 1);
646 Changed |= setDoesNotCapture(F, 2);
647 Changed |= setOnlyReadsMemory(F, 1);
648 Changed |= setOnlyReadsMemory(F, 2);
649 return Changed;
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]650 case LibFunc_fseeko64:
651 case LibFunc_ftello64:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]652 Changed |= setDoesNotThrow(F);
653 Changed |= setDoesNotCapture(F, 1);
654 return Changed;
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]655 case LibFunc_tmpfile64:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]656 Changed |= setDoesNotThrow(F);
657 Changed |= setDoesNotAlias(F, 0);
658 return Changed;
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]659 case LibFunc_fstat64:
660 case LibFunc_fstatvfs64:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]661 Changed |= setDoesNotThrow(F);
662 Changed |= setDoesNotCapture(F, 2);
663 return Changed;
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]664 case LibFunc_open64:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]665 // May throw; "open" is a valid pthread cancellation point.
666 Changed |= setDoesNotCapture(F, 1);
667 Changed |= setOnlyReadsMemory(F, 1);
668 return Changed;
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]669 case LibFunc_gettimeofday:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]670 // Currently some platforms have the restrict keyword on the arguments to
671 // gettimeofday. To be conservative, do not add noalias to gettimeofday's
672 // arguments.
673 Changed |= setDoesNotThrow(F);
674 Changed |= setDoesNotCapture(F, 1);
675 Changed |= setDoesNotCapture(F, 2);
676 return Changed;
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]677 case LibFunc_Znwj: // new(unsigned int)
678 case LibFunc_Znwm: // new(unsigned long)
679 case LibFunc_Znaj: // new[](unsigned int)
680 case LibFunc_Znam: // new[](unsigned long)
681 case LibFunc_msvc_new_int: // new(unsigned int)
682 case LibFunc_msvc_new_longlong: // new(unsigned long long)
683 case LibFunc_msvc_new_array_int: // new[](unsigned int)
684 case LibFunc_msvc_new_array_longlong: // new[](unsigned long long)
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]685 // Operator new always returns a nonnull noalias pointer
Reid Klecknerb5180542017-03-21 16:57:19 +0000[diff] [blame]686 Changed |= setNonNull(F, AttributeList::ReturnIndex);
687 Changed |= setDoesNotAlias(F, AttributeList::ReturnIndex);
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]688 return Changed;
689 //TODO: add LibFunc entries for:
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]690 //case LibFunc_memset_pattern4:
691 //case LibFunc_memset_pattern8:
692 case LibFunc_memset_pattern16:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]693 Changed |= setOnlyAccessesArgMemory(F);
Ahmed Bougacha44c19872016-04-27 19:04:43 +0000[diff] [blame]694 Changed |= setDoesNotCapture(F, 1);
695 Changed |= setDoesNotCapture(F, 2);
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]696 Changed |= setOnlyReadsMemory(F, 2);
697 return Changed;
698 // int __nvvm_reflect(const char *)
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]699 case LibFunc_nvvm_reflect:
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]700 Changed |= setDoesNotAccessMemory(F);
701 Changed |= setDoesNotThrow(F);
702 return Changed;
703
704 default:
705 // FIXME: It'd be really nice to cover all the library functions we're
706 // aware of here.
707 return false;
708 }
709}
710
711//- Emit LibCalls ------------------------------------------------------------//
712
Sanjay Pateld3112a52016-01-19 19:46:10 +0000[diff] [blame]713Value *llvm::castToCStr(Value *V, IRBuilder<> &B) {
Matt Arsenaultbe558882014-04-23 20:58:57 +0000[diff] [blame]714 unsigned AS = V->getType()->getPointerAddressSpace();
715 return B.CreateBitCast(V, B.getInt8PtrTy(AS), "cstr");
Eric Christopher87abfc52010-03-05 22:25:30 +0000[diff] [blame]716}
717
Sanjay Pateld3112a52016-01-19 19:46:10 +0000[diff] [blame]718Value *llvm::emitStrLen(Value *Ptr, IRBuilder<> &B, const DataLayout &DL,
Nuno Lopes89702e92012-07-25 16:46:31 +0000[diff] [blame]719 const TargetLibraryInfo *TLI) {
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]720 if (!TLI->has(LibFunc_strlen))
Craig Topperf40110f2014-04-25 05:29:35 +0000[diff] [blame]721 return nullptr;
Nuno Lopes89702e92012-07-25 16:46:31 +0000[diff] [blame]722
Sanjay Pateld4af2972016-01-19 19:58:49 +0000[diff] [blame]723 Module *M = B.GetInsertBlock()->getModule();
Chandler Carruth7ec50852012-11-01 08:07:29 +0000[diff] [blame]724 LLVMContext &Context = B.GetInsertBlock()->getContext();
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]725 Constant *StrLen = M->getOrInsertFunction("strlen", DL.getIntPtrType(Context),
Diana Picusb050c7f2017-04-11 10:07:12 +0000[diff] [blame]726 B.getInt8PtrTy(), nullptr);
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]727 inferLibFuncAttributes(*M->getFunction("strlen"), *TLI);
Sanjay Pateld3112a52016-01-19 19:46:10 +0000[diff] [blame]728 CallInst *CI = B.CreateCall(StrLen, castToCStr(Ptr, B), "strlen");
Evan Chengad6efbf2014-03-12 18:09:37 +0000[diff] [blame]729 if (const Function *F = dyn_cast<Function>(StrLen->stripPointerCasts()))
730 CI->setCallingConv(F->getCallingConv());
731
Eric Christopher87abfc52010-03-05 22:25:30 +0000[diff] [blame]732 return CI;
733}
734
Sanjay Pateld3112a52016-01-19 19:46:10 +0000[diff] [blame]735Value *llvm::emitStrChr(Value *Ptr, char C, IRBuilder<> &B,
Mehdi Aminia28d91d2015-03-10 02:37:25 +0000[diff] [blame]736 const TargetLibraryInfo *TLI) {
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]737 if (!TLI->has(LibFunc_strchr))
Craig Topperf40110f2014-04-25 05:29:35 +0000[diff] [blame]738 return nullptr;
Nuno Lopes89702e92012-07-25 16:46:31 +0000[diff] [blame]739
Sanjay Pateld4af2972016-01-19 19:58:49 +0000[diff] [blame]740 Module *M = B.GetInsertBlock()->getModule();
Chris Lattner229907c2011-07-18 04:54:35 +0000[diff] [blame]741 Type *I8Ptr = B.getInt8PtrTy();
742 Type *I32Ty = B.getInt32Ty();
Mehdi Aminidb11fdf2017-04-06 20:23:57 +0000[diff] [blame]743 Constant *StrChr =
Diana Picusb050c7f2017-04-11 10:07:12 +0000[diff] [blame]744 M->getOrInsertFunction("strchr", I8Ptr, I8Ptr, I32Ty, nullptr);
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]745 inferLibFuncAttributes(*M->getFunction("strchr"), *TLI);
David Blaikieff6409d2015-05-18 22:13:54 +0000[diff] [blame]746 CallInst *CI = B.CreateCall(
Sanjay Pateld3112a52016-01-19 19:46:10 +0000[diff] [blame]747 StrChr, {castToCStr(Ptr, B), ConstantInt::get(I32Ty, C)}, "strchr");
Evan Chengad6efbf2014-03-12 18:09:37 +0000[diff] [blame]748 if (const Function *F = dyn_cast<Function>(StrChr->stripPointerCasts()))
749 CI->setCallingConv(F->getCallingConv());
Eric Christopher87abfc52010-03-05 22:25:30 +0000[diff] [blame]750 return CI;
751}
752
Sanjay Pateld3112a52016-01-19 19:46:10 +0000[diff] [blame]753Value *llvm::emitStrNCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilder<> &B,
Mehdi Aminia28d91d2015-03-10 02:37:25 +0000[diff] [blame]754 const DataLayout &DL, const TargetLibraryInfo *TLI) {
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]755 if (!TLI->has(LibFunc_strncmp))
Craig Topperf40110f2014-04-25 05:29:35 +0000[diff] [blame]756 return nullptr;
Nuno Lopes89702e92012-07-25 16:46:31 +0000[diff] [blame]757
Sanjay Pateld4af2972016-01-19 19:58:49 +0000[diff] [blame]758 Module *M = B.GetInsertBlock()->getModule();
Chandler Carruth7ec50852012-11-01 08:07:29 +0000[diff] [blame]759 LLVMContext &Context = B.GetInsertBlock()->getContext();
Mehdi Aminidb11fdf2017-04-06 20:23:57 +0000[diff] [blame]760 Value *StrNCmp = M->getOrInsertFunction("strncmp", B.getInt32Ty(),
761 B.getInt8PtrTy(), B.getInt8PtrTy(),
Diana Picusb050c7f2017-04-11 10:07:12 +0000[diff] [blame]762 DL.getIntPtrType(Context), nullptr);
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]763 inferLibFuncAttributes(*M->getFunction("strncmp"), *TLI);
David Blaikieff6409d2015-05-18 22:13:54 +0000[diff] [blame]764 CallInst *CI = B.CreateCall(
Sanjay Pateld3112a52016-01-19 19:46:10 +0000[diff] [blame]765 StrNCmp, {castToCStr(Ptr1, B), castToCStr(Ptr2, B), Len}, "strncmp");
Evan Chengad6efbf2014-03-12 18:09:37 +0000[diff] [blame]766
767 if (const Function *F = dyn_cast<Function>(StrNCmp->stripPointerCasts()))
768 CI->setCallingConv(F->getCallingConv());
769
Benjamin Kramer11188602010-06-15 21:34:25 +0000[diff] [blame]770 return CI;
771}
772
Sanjay Pateld3112a52016-01-19 19:46:10 +0000[diff] [blame]773Value *llvm::emitStrCpy(Value *Dst, Value *Src, IRBuilder<> &B,
Mehdi Aminia28d91d2015-03-10 02:37:25 +0000[diff] [blame]774 const TargetLibraryInfo *TLI, StringRef Name) {
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]775 if (!TLI->has(LibFunc_strcpy))
Craig Topperf40110f2014-04-25 05:29:35 +0000[diff] [blame]776 return nullptr;
Nuno Lopes89702e92012-07-25 16:46:31 +0000[diff] [blame]777
Sanjay Pateld4af2972016-01-19 19:58:49 +0000[diff] [blame]778 Module *M = B.GetInsertBlock()->getModule();
Chris Lattner229907c2011-07-18 04:54:35 +0000[diff] [blame]779 Type *I8Ptr = B.getInt8PtrTy();
Diana Picusb050c7f2017-04-11 10:07:12 +0000[diff] [blame]780 Value *StrCpy = M->getOrInsertFunction(Name, I8Ptr, I8Ptr, I8Ptr, nullptr);
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]781 inferLibFuncAttributes(*M->getFunction(Name), *TLI);
David Blaikieff6409d2015-05-18 22:13:54 +0000[diff] [blame]782 CallInst *CI =
Sanjay Pateld3112a52016-01-19 19:46:10 +0000[diff] [blame]783 B.CreateCall(StrCpy, {castToCStr(Dst, B), castToCStr(Src, B)}, Name);
Evan Chengad6efbf2014-03-12 18:09:37 +0000[diff] [blame]784 if (const Function *F = dyn_cast<Function>(StrCpy->stripPointerCasts()))
785 CI->setCallingConv(F->getCallingConv());
Eric Christopher87abfc52010-03-05 22:25:30 +0000[diff] [blame]786 return CI;
787}
788
Sanjay Pateld3112a52016-01-19 19:46:10 +0000[diff] [blame]789Value *llvm::emitStrNCpy(Value *Dst, Value *Src, Value *Len, IRBuilder<> &B,
Nuno Lopes89702e92012-07-25 16:46:31 +0000[diff] [blame]790 const TargetLibraryInfo *TLI, StringRef Name) {
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]791 if (!TLI->has(LibFunc_strncpy))
Craig Topperf40110f2014-04-25 05:29:35 +0000[diff] [blame]792 return nullptr;
Nuno Lopes89702e92012-07-25 16:46:31 +0000[diff] [blame]793
Sanjay Pateld4af2972016-01-19 19:58:49 +0000[diff] [blame]794 Module *M = B.GetInsertBlock()->getModule();
Chris Lattner229907c2011-07-18 04:54:35 +0000[diff] [blame]795 Type *I8Ptr = B.getInt8PtrTy();
Mehdi Aminidb11fdf2017-04-06 20:23:57 +0000[diff] [blame]796 Value *StrNCpy = M->getOrInsertFunction(Name, I8Ptr, I8Ptr, I8Ptr,
Diana Picusb050c7f2017-04-11 10:07:12 +0000[diff] [blame]797 Len->getType(), nullptr);
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]798 inferLibFuncAttributes(*M->getFunction(Name), *TLI);
David Blaikieff6409d2015-05-18 22:13:54 +0000[diff] [blame]799 CallInst *CI = B.CreateCall(
Sanjay Pateld3112a52016-01-19 19:46:10 +0000[diff] [blame]800 StrNCpy, {castToCStr(Dst, B), castToCStr(Src, B), Len}, "strncpy");
Evan Chengad6efbf2014-03-12 18:09:37 +0000[diff] [blame]801 if (const Function *F = dyn_cast<Function>(StrNCpy->stripPointerCasts()))
802 CI->setCallingConv(F->getCallingConv());
Eric Christopher43dc11c2010-03-11 01:25:07 +0000[diff] [blame]803 return CI;
804}
805
Sanjay Pateld3112a52016-01-19 19:46:10 +0000[diff] [blame]806Value *llvm::emitMemCpyChk(Value *Dst, Value *Src, Value *Len, Value *ObjSize,
Mehdi Aminia28d91d2015-03-10 02:37:25 +0000[diff] [blame]807 IRBuilder<> &B, const DataLayout &DL,
Nuno Lopes89702e92012-07-25 16:46:31 +0000[diff] [blame]808 const TargetLibraryInfo *TLI) {
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]809 if (!TLI->has(LibFunc_memcpy_chk))
Craig Topperf40110f2014-04-25 05:29:35 +0000[diff] [blame]810 return nullptr;
Nuno Lopes89702e92012-07-25 16:46:31 +0000[diff] [blame]811
Sanjay Pateld4af2972016-01-19 19:58:49 +0000[diff] [blame]812 Module *M = B.GetInsertBlock()->getModule();
Reid Klecknerb5180542017-03-21 16:57:19 +0000[diff] [blame]813 AttributeList AS;
814 AS = AttributeList::get(M->getContext(), AttributeList::FunctionIndex,
815 Attribute::NoUnwind);
Chandler Carruth7ec50852012-11-01 08:07:29 +0000[diff] [blame]816 LLVMContext &Context = B.GetInsertBlock()->getContext();
Mehdi Aminia28d91d2015-03-10 02:37:25 +0000[diff] [blame]817 Value *MemCpy = M->getOrInsertFunction(
Reid Klecknerb5180542017-03-21 16:57:19 +0000[diff] [blame]818 "__memcpy_chk", AttributeList::get(M->getContext(), AS), B.getInt8PtrTy(),
Mehdi Aminia28d91d2015-03-10 02:37:25 +0000[diff] [blame]819 B.getInt8PtrTy(), B.getInt8PtrTy(), DL.getIntPtrType(Context),
Diana Picusb050c7f2017-04-11 10:07:12 +0000[diff] [blame]820 DL.getIntPtrType(Context), nullptr);
Sanjay Pateld3112a52016-01-19 19:46:10 +0000[diff] [blame]821 Dst = castToCStr(Dst, B);
822 Src = castToCStr(Src, B);
David Blaikieff6409d2015-05-18 22:13:54 +0000[diff] [blame]823 CallInst *CI = B.CreateCall(MemCpy, {Dst, Src, Len, ObjSize});
Evan Chengad6efbf2014-03-12 18:09:37 +0000[diff] [blame]824 if (const Function *F = dyn_cast<Function>(MemCpy->stripPointerCasts()))
825 CI->setCallingConv(F->getCallingConv());
Evan Chengd9e82232010-03-23 15:48:04 +0000[diff] [blame]826 return CI;
827}
828
Sanjay Pateld3112a52016-01-19 19:46:10 +0000[diff] [blame]829Value *llvm::emitMemChr(Value *Ptr, Value *Val, Value *Len, IRBuilder<> &B,
Mehdi Aminia28d91d2015-03-10 02:37:25 +0000[diff] [blame]830 const DataLayout &DL, const TargetLibraryInfo *TLI) {
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]831 if (!TLI->has(LibFunc_memchr))
Craig Topperf40110f2014-04-25 05:29:35 +0000[diff] [blame]832 return nullptr;
Nuno Lopes89702e92012-07-25 16:46:31 +0000[diff] [blame]833
Sanjay Pateld4af2972016-01-19 19:58:49 +0000[diff] [blame]834 Module *M = B.GetInsertBlock()->getModule();
Chandler Carruth7ec50852012-11-01 08:07:29 +0000[diff] [blame]835 LLVMContext &Context = B.GetInsertBlock()->getContext();
Mehdi Aminidb11fdf2017-04-06 20:23:57 +0000[diff] [blame]836 Value *MemChr = M->getOrInsertFunction("memchr", B.getInt8PtrTy(),
837 B.getInt8PtrTy(), B.getInt32Ty(),
Diana Picusb050c7f2017-04-11 10:07:12 +0000[diff] [blame]838 DL.getIntPtrType(Context), nullptr);
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]839 inferLibFuncAttributes(*M->getFunction("memchr"), *TLI);
Sanjay Pateld3112a52016-01-19 19:46:10 +0000[diff] [blame]840 CallInst *CI = B.CreateCall(MemChr, {castToCStr(Ptr, B), Val, Len}, "memchr");
Evan Chengad6efbf2014-03-12 18:09:37 +0000[diff] [blame]841
842 if (const Function *F = dyn_cast<Function>(MemChr->stripPointerCasts()))
843 CI->setCallingConv(F->getCallingConv());
844
Eric Christopher87abfc52010-03-05 22:25:30 +0000[diff] [blame]845 return CI;
846}
847
Sanjay Pateld3112a52016-01-19 19:46:10 +0000[diff] [blame]848Value *llvm::emitMemCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilder<> &B,
Mehdi Aminia28d91d2015-03-10 02:37:25 +0000[diff] [blame]849 const DataLayout &DL, const TargetLibraryInfo *TLI) {
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]850 if (!TLI->has(LibFunc_memcmp))
Craig Topperf40110f2014-04-25 05:29:35 +0000[diff] [blame]851 return nullptr;
Nuno Lopes89702e92012-07-25 16:46:31 +0000[diff] [blame]852
Sanjay Pateld4af2972016-01-19 19:58:49 +0000[diff] [blame]853 Module *M = B.GetInsertBlock()->getModule();
Chandler Carruth7ec50852012-11-01 08:07:29 +0000[diff] [blame]854 LLVMContext &Context = B.GetInsertBlock()->getContext();
Mehdi Aminidb11fdf2017-04-06 20:23:57 +0000[diff] [blame]855 Value *MemCmp = M->getOrInsertFunction("memcmp", B.getInt32Ty(),
856 B.getInt8PtrTy(), B.getInt8PtrTy(),
Diana Picusb050c7f2017-04-11 10:07:12 +0000[diff] [blame]857 DL.getIntPtrType(Context), nullptr);
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]858 inferLibFuncAttributes(*M->getFunction("memcmp"), *TLI);
David Blaikieff6409d2015-05-18 22:13:54 +0000[diff] [blame]859 CallInst *CI = B.CreateCall(
Sanjay Pateld3112a52016-01-19 19:46:10 +0000[diff] [blame]860 MemCmp, {castToCStr(Ptr1, B), castToCStr(Ptr2, B), Len}, "memcmp");
Evan Chengad6efbf2014-03-12 18:09:37 +0000[diff] [blame]861
862 if (const Function *F = dyn_cast<Function>(MemCmp->stripPointerCasts()))
863 CI->setCallingConv(F->getCallingConv());
864
Eric Christopher87abfc52010-03-05 22:25:30 +0000[diff] [blame]865 return CI;
866}
867
Yi Jiang6ab044e2013-12-16 22:42:40 +0000[diff] [blame]868/// Append a suffix to the function name according to the type of 'Op'.
Sanjay Pateld3112a52016-01-19 19:46:10 +0000[diff] [blame]869static void appendTypeSuffix(Value *Op, StringRef &Name,
Sanjay Patelb50325e2016-01-19 19:17:47 +0000[diff] [blame]870 SmallString<20> &NameBuffer) {
Yi Jiang6ab044e2013-12-16 22:42:40 +0000[diff] [blame]871 if (!Op->getType()->isDoubleTy()) {
872 NameBuffer += Name;
873
874 if (Op->getType()->isFloatTy())
875 NameBuffer += 'f';
876 else
877 NameBuffer += 'l';
878
879 Name = NameBuffer;
880 }
Yi Jiang6ab044e2013-12-16 22:42:40 +0000[diff] [blame]881}
882
Sanjay Pateld3112a52016-01-19 19:46:10 +0000[diff] [blame]883Value *llvm::emitUnaryFloatFnCall(Value *Op, StringRef Name, IRBuilder<> &B,
Reid Klecknerb5180542017-03-21 16:57:19 +0000[diff] [blame]884 const AttributeList &Attrs) {
Benjamin Kramerb106bcc2011-11-15 19:12:09 +0000[diff] [blame]885 SmallString<20> NameBuffer;
Sanjay Pateld3112a52016-01-19 19:46:10 +0000[diff] [blame]886 appendTypeSuffix(Op, Name, NameBuffer);
Eric Christopher87abfc52010-03-05 22:25:30 +0000[diff] [blame]887
Sanjay Pateld4af2972016-01-19 19:58:49 +0000[diff] [blame]888 Module *M = B.GetInsertBlock()->getModule();
Mehdi Aminidb11fdf2017-04-06 20:23:57 +0000[diff] [blame]889 Value *Callee = M->getOrInsertFunction(Name, Op->getType(),
Diana Picusb050c7f2017-04-11 10:07:12 +0000[diff] [blame]890 Op->getType(), nullptr);
Eric Christopher87abfc52010-03-05 22:25:30 +0000[diff] [blame]891 CallInst *CI = B.CreateCall(Callee, Op, Name);
892 CI->setAttributes(Attrs);
Evan Chengad6efbf2014-03-12 18:09:37 +0000[diff] [blame]893 if (const Function *F = dyn_cast<Function>(Callee->stripPointerCasts()))
894 CI->setCallingConv(F->getCallingConv());
895
Eric Christopher87abfc52010-03-05 22:25:30 +0000[diff] [blame]896 return CI;
897}
898
Sanjay Pateld3112a52016-01-19 19:46:10 +0000[diff] [blame]899Value *llvm::emitBinaryFloatFnCall(Value *Op1, Value *Op2, StringRef Name,
Reid Klecknerb5180542017-03-21 16:57:19 +0000[diff] [blame]900 IRBuilder<> &B, const AttributeList &Attrs) {
Yi Jiang6ab044e2013-12-16 22:42:40 +0000[diff] [blame]901 SmallString<20> NameBuffer;
Sanjay Pateld3112a52016-01-19 19:46:10 +0000[diff] [blame]902 appendTypeSuffix(Op1, Name, NameBuffer);
Yi Jiang6ab044e2013-12-16 22:42:40 +0000[diff] [blame]903
Sanjay Pateld4af2972016-01-19 19:58:49 +0000[diff] [blame]904 Module *M = B.GetInsertBlock()->getModule();
Sanjay Patelb50325e2016-01-19 19:17:47 +0000[diff] [blame]905 Value *Callee = M->getOrInsertFunction(Name, Op1->getType(), Op1->getType(),
Diana Picusb050c7f2017-04-11 10:07:12 +0000[diff] [blame]906 Op2->getType(), nullptr);
David Blaikieff6409d2015-05-18 22:13:54 +0000[diff] [blame]907 CallInst *CI = B.CreateCall(Callee, {Op1, Op2}, Name);
Yi Jiang6ab044e2013-12-16 22:42:40 +0000[diff] [blame]908 CI->setAttributes(Attrs);
Evan Chengad6efbf2014-03-12 18:09:37 +0000[diff] [blame]909 if (const Function *F = dyn_cast<Function>(Callee->stripPointerCasts()))
910 CI->setCallingConv(F->getCallingConv());
911
Yi Jiang6ab044e2013-12-16 22:42:40 +0000[diff] [blame]912 return CI;
913}
914
Sanjay Pateld3112a52016-01-19 19:46:10 +0000[diff] [blame]915Value *llvm::emitPutChar(Value *Char, IRBuilder<> &B,
Nuno Lopes89702e92012-07-25 16:46:31 +0000[diff] [blame]916 const TargetLibraryInfo *TLI) {
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]917 if (!TLI->has(LibFunc_putchar))
Craig Topperf40110f2014-04-25 05:29:35 +0000[diff] [blame]918 return nullptr;
Nuno Lopes89702e92012-07-25 16:46:31 +0000[diff] [blame]919
Sanjay Pateld4af2972016-01-19 19:58:49 +0000[diff] [blame]920 Module *M = B.GetInsertBlock()->getModule();
Diana Picusb050c7f2017-04-11 10:07:12 +0000[diff] [blame]921 Value *PutChar = M->getOrInsertFunction("putchar", B.getInt32Ty(),
922 B.getInt32Ty(), nullptr);
Craig Topper0f5063c2017-03-17 23:48:02 +0000[diff] [blame]923 inferLibFuncAttributes(*M->getFunction("putchar"), *TLI);
Eric Christopher87abfc52010-03-05 22:25:30 +0000[diff] [blame]924 CallInst *CI = B.CreateCall(PutChar,
925 B.CreateIntCast(Char,
926 B.getInt32Ty(),
927 /*isSigned*/true,
928 "chari"),
929 "putchar");
Evan Chengad6efbf2014-03-12 18:09:37 +0000[diff] [blame]930
931 if (const Function *F = dyn_cast<Function>(PutChar->stripPointerCasts()))
932 CI->setCallingConv(F->getCallingConv());
Eric Christopher87abfc52010-03-05 22:25:30 +0000[diff] [blame]933 return CI;
934}
935
Sanjay Pateld3112a52016-01-19 19:46:10 +0000[diff] [blame]936Value *llvm::emitPutS(Value *Str, IRBuilder<> &B,
Nuno Lopes89702e92012-07-25 16:46:31 +0000[diff] [blame]937 const TargetLibraryInfo *TLI) {
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]938 if (!TLI->has(LibFunc_puts))
Craig Topperf40110f2014-04-25 05:29:35 +0000[diff] [blame]939 return nullptr;
Nuno Lopes89702e92012-07-25 16:46:31 +0000[diff] [blame]940
Sanjay Pateld4af2972016-01-19 19:58:49 +0000[diff] [blame]941 Module *M = B.GetInsertBlock()->getModule();
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]942 Value *PutS =
Diana Picusb050c7f2017-04-11 10:07:12 +0000[diff] [blame]943 M->getOrInsertFunction("puts", B.getInt32Ty(), B.getInt8PtrTy(), nullptr);
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]944 inferLibFuncAttributes(*M->getFunction("puts"), *TLI);
Sanjay Pateld3112a52016-01-19 19:46:10 +0000[diff] [blame]945 CallInst *CI = B.CreateCall(PutS, castToCStr(Str, B), "puts");
Evan Chengad6efbf2014-03-12 18:09:37 +0000[diff] [blame]946 if (const Function *F = dyn_cast<Function>(PutS->stripPointerCasts()))
947 CI->setCallingConv(F->getCallingConv());
Nuno Lopes89702e92012-07-25 16:46:31 +0000[diff] [blame]948 return CI;
Eric Christopher87abfc52010-03-05 22:25:30 +0000[diff] [blame]949}
950
Sanjay Pateld3112a52016-01-19 19:46:10 +0000[diff] [blame]951Value *llvm::emitFPutC(Value *Char, Value *File, IRBuilder<> &B,
Mehdi Aminia28d91d2015-03-10 02:37:25 +0000[diff] [blame]952 const TargetLibraryInfo *TLI) {
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]953 if (!TLI->has(LibFunc_fputc))
Craig Topperf40110f2014-04-25 05:29:35 +0000[diff] [blame]954 return nullptr;
Nuno Lopes89702e92012-07-25 16:46:31 +0000[diff] [blame]955
Sanjay Pateld4af2972016-01-19 19:58:49 +0000[diff] [blame]956 Module *M = B.GetInsertBlock()->getModule();
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]957 Constant *F = M->getOrInsertFunction("fputc", B.getInt32Ty(), B.getInt32Ty(),
Diana Picusb050c7f2017-04-11 10:07:12 +0000[diff] [blame]958 File->getType(), nullptr);
Eric Christopher87abfc52010-03-05 22:25:30 +0000[diff] [blame]959 if (File->getType()->isPointerTy())
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]960 inferLibFuncAttributes(*M->getFunction("fputc"), *TLI);
Eric Christopher87abfc52010-03-05 22:25:30 +0000[diff] [blame]961 Char = B.CreateIntCast(Char, B.getInt32Ty(), /*isSigned*/true,
962 "chari");
David Blaikieff6409d2015-05-18 22:13:54 +0000[diff] [blame]963 CallInst *CI = B.CreateCall(F, {Char, File}, "fputc");
Evan Chengad6efbf2014-03-12 18:09:37 +0000[diff] [blame]964
965 if (const Function *Fn = dyn_cast<Function>(F->stripPointerCasts()))
966 CI->setCallingConv(Fn->getCallingConv());
Nuno Lopes89702e92012-07-25 16:46:31 +0000[diff] [blame]967 return CI;
Eric Christopher87abfc52010-03-05 22:25:30 +0000[diff] [blame]968}
969
Sanjay Pateld3112a52016-01-19 19:46:10 +0000[diff] [blame]970Value *llvm::emitFPutS(Value *Str, Value *File, IRBuilder<> &B,
Mehdi Aminia28d91d2015-03-10 02:37:25 +0000[diff] [blame]971 const TargetLibraryInfo *TLI) {
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]972 if (!TLI->has(LibFunc_fputs))
Craig Topperf40110f2014-04-25 05:29:35 +0000[diff] [blame]973 return nullptr;
Nuno Lopes89702e92012-07-25 16:46:31 +0000[diff] [blame]974
Sanjay Pateld4af2972016-01-19 19:58:49 +0000[diff] [blame]975 Module *M = B.GetInsertBlock()->getModule();
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]976 StringRef FPutsName = TLI->getName(LibFunc_fputs);
Mehdi Aminidb11fdf2017-04-06 20:23:57 +0000[diff] [blame]977 Constant *F = M->getOrInsertFunction(
Diana Picusb050c7f2017-04-11 10:07:12 +0000[diff] [blame]978 FPutsName, B.getInt32Ty(), B.getInt8PtrTy(), File->getType(), nullptr);
Eric Christopher87abfc52010-03-05 22:25:30 +0000[diff] [blame]979 if (File->getType()->isPointerTy())
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]980 inferLibFuncAttributes(*M->getFunction(FPutsName), *TLI);
Sanjay Pateld3112a52016-01-19 19:46:10 +0000[diff] [blame]981 CallInst *CI = B.CreateCall(F, {castToCStr(Str, B), File}, "fputs");
Evan Chengad6efbf2014-03-12 18:09:37 +0000[diff] [blame]982
983 if (const Function *Fn = dyn_cast<Function>(F->stripPointerCasts()))
984 CI->setCallingConv(Fn->getCallingConv());
Nuno Lopes89702e92012-07-25 16:46:31 +0000[diff] [blame]985 return CI;
Eric Christopher87abfc52010-03-05 22:25:30 +0000[diff] [blame]986}
987
Sanjay Pateld3112a52016-01-19 19:46:10 +0000[diff] [blame]988Value *llvm::emitFWrite(Value *Ptr, Value *Size, Value *File, IRBuilder<> &B,
Mehdi Aminia28d91d2015-03-10 02:37:25 +0000[diff] [blame]989 const DataLayout &DL, const TargetLibraryInfo *TLI) {
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]990 if (!TLI->has(LibFunc_fwrite))
Craig Topperf40110f2014-04-25 05:29:35 +0000[diff] [blame]991 return nullptr;
Nuno Lopes89702e92012-07-25 16:46:31 +0000[diff] [blame]992
Sanjay Pateld4af2972016-01-19 19:58:49 +0000[diff] [blame]993 Module *M = B.GetInsertBlock()->getModule();
Chandler Carruth7ec50852012-11-01 08:07:29 +0000[diff] [blame]994 LLVMContext &Context = B.GetInsertBlock()->getContext();
David L. Jonesd21529f2017-01-23 23:16:46 +0000[diff] [blame]995 StringRef FWriteName = TLI->getName(LibFunc_fwrite);
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]996 Constant *F = M->getOrInsertFunction(
997 FWriteName, DL.getIntPtrType(Context), B.getInt8PtrTy(),
Diana Picusb050c7f2017-04-11 10:07:12 +0000[diff] [blame]998 DL.getIntPtrType(Context), DL.getIntPtrType(Context), File->getType(),
999 nullptr);
Eric Christopher87abfc52010-03-05 22:25:30 +0000[diff] [blame]1000 if (File->getType()->isPointerTy())
Ahmed Bougachab0624a22016-04-27 19:04:40 +0000[diff] [blame]1001 inferLibFuncAttributes(*M->getFunction(FWriteName), *TLI);
Mehdi Aminia28d91d2015-03-10 02:37:25 +0000[diff] [blame]1002 CallInst *CI =
Sanjay Pateld3112a52016-01-19 19:46:10 +0000[diff] [blame]1003 B.CreateCall(F, {castToCStr(Ptr, B), Size,
David Blaikieff6409d2015-05-18 22:13:54 +0000[diff] [blame]1004 ConstantInt::get(DL.getIntPtrType(Context), 1), File});
Evan Chengad6efbf2014-03-12 18:09:37 +0000[diff] [blame]1005
1006 if (const Function *Fn = dyn_cast<Function>(F->stripPointerCasts()))
1007 CI->setCallingConv(Fn->getCallingConv());
Nuno Lopes89702e92012-07-25 16:46:31 +0000[diff] [blame]1008 return CI;
Eric Christopher87abfc52010-03-05 22:25:30 +0000[diff] [blame]1009}