1//===- BuildLibCalls.cpp - Utility builder for libcalls -------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file implements some functions that will create standard C libcalls.
10//
11//===----------------------------------------------------------------------===//
12
13#include "llvm/Transforms/Utils/BuildLibCalls.h"
14#include "llvm/ADT/SmallString.h"
15#include "llvm/ADT/Statistic.h"
16#include "llvm/Analysis/TargetLibraryInfo.h"
17#include "llvm/IR/Constants.h"
18#include "llvm/IR/DataLayout.h"
19#include "llvm/IR/Function.h"
20#include "llvm/IR/IRBuilder.h"
21#include "llvm/IR/Intrinsics.h"
22#include "llvm/IR/LLVMContext.h"
23#include "llvm/IR/Module.h"
24#include "llvm/IR/Type.h"
25#include "llvm/Analysis/MemoryBuiltins.h"
26
27using namespace llvm;
28
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");
41STATISTIC(NumReturnedArg, "Number of arguments inferred as returned");
42
43static bool setDoesNotAccessMemory(Function &F) {
44  if (F.doesNotAccessMemory())
45    return false;
46  F.setDoesNotAccessMemory();
47  ++NumReadNone;
48  return true;
49}
50
51static bool setOnlyReadsMemory(Function &F) {
52  if (F.onlyReadsMemory())
53    return false;
54  F.setOnlyReadsMemory();
55  ++NumReadOnly;
56  return true;
57}
58
59static bool setOnlyAccessesArgMemory(Function &F) {
60  if (F.onlyAccessesArgMemory())
61    return false;
62  F.setOnlyAccessesArgMemory();
63  ++NumArgMemOnly;
64  return true;
65}
66
67static bool setDoesNotThrow(Function &F) {
68  if (F.doesNotThrow())
69    return false;
70  F.setDoesNotThrow();
71  ++NumNoUnwind;
72  return true;
73}
74
75static bool setRetDoesNotAlias(Function &F) {
76  if (F.hasAttribute(AttributeList::ReturnIndex, Attribute::NoAlias))
77    return false;
78  F.addAttribute(AttributeList::ReturnIndex, Attribute::NoAlias);
79  ++NumNoAlias;
80  return true;
81}
82
83static bool setDoesNotCapture(Function &F, unsigned ArgNo) {
84  if (F.hasParamAttribute(ArgNo, Attribute::NoCapture))
85    return false;
86  F.addParamAttr(ArgNo, Attribute::NoCapture);
87  ++NumNoCapture;
88  return true;
89}
90
91static bool setDoesNotAlias(Function &F, unsigned ArgNo) {
92  if (F.hasParamAttribute(ArgNo, Attribute::NoAlias))
93    return false;
94  F.addParamAttr(ArgNo, Attribute::NoAlias);
95  ++NumNoAlias;
96  return true;
97}
98
99static bool setOnlyReadsMemory(Function &F, unsigned ArgNo) {
100  if (F.hasParamAttribute(ArgNo, Attribute::ReadOnly))
101    return false;
102  F.addParamAttr(ArgNo, Attribute::ReadOnly);
103  ++NumReadOnlyArg;
104  return true;
105}
106
107static bool setRetNonNull(Function &F) {
108  assert(F.getReturnType()->isPointerTy() &&
109         "nonnull applies only to pointers");
110  if (F.hasAttribute(AttributeList::ReturnIndex, Attribute::NonNull))
111    return false;
112  F.addAttribute(AttributeList::ReturnIndex, Attribute::NonNull);
113  ++NumNonNull;
114  return true;
115}
116
117static bool setReturnedArg(Function &F, unsigned ArgNo) {
118  if (F.hasParamAttribute(ArgNo, Attribute::Returned))
119    return false;
120  F.addParamAttr(ArgNo, Attribute::Returned);
121  ++NumReturnedArg;
122  return true;
123}
124
125static bool setNonLazyBind(Function &F) {
126  if (F.hasFnAttribute(Attribute::NonLazyBind))
127    return false;
128  F.addFnAttr(Attribute::NonLazyBind);
129  return true;
130}
131
132static bool setDoesNotFreeMemory(Function &F) {
133  if (F.hasFnAttribute(Attribute::NoFree))
134    return false;
135  F.addFnAttr(Attribute::NoFree);
136  return true;
137}
138
139bool llvm::inferLibFuncAttributes(Module *M, StringRef Name,
140                                  const TargetLibraryInfo &TLI) {
141  Function *F = M->getFunction(Name);
142  if (!F)
143    return false;
144  return inferLibFuncAttributes(*F, TLI);
145}
146
147bool llvm::inferLibFuncAttributes(Function &F, const TargetLibraryInfo &TLI) {
148  LibFunc TheLibFunc;
149  if (!(TLI.getLibFunc(F, TheLibFunc) && TLI.has(TheLibFunc)))
150    return false;
151
152  bool Changed = false;
153
154  if(!isLibFreeFunction(&F, TheLibFunc) && !isReallocLikeFn(&F,  &TLI))
155    Changed |= setDoesNotFreeMemory(F);
156
157  if (F.getParent() != nullptr && F.getParent()->getRtLibUseGOT())
158    Changed |= setNonLazyBind(F);
159
160  switch (TheLibFunc) {
161  case LibFunc_strlen:
162  case LibFunc_wcslen:
163    Changed |= setOnlyReadsMemory(F);
164    Changed |= setDoesNotThrow(F);
165    Changed |= setOnlyAccessesArgMemory(F);
166    Changed |= setDoesNotCapture(F, 0);
167    return Changed;
168  case LibFunc_strchr:
169  case LibFunc_strrchr:
170    Changed |= setOnlyReadsMemory(F);
171    Changed |= setDoesNotThrow(F);
172    return Changed;
173  case LibFunc_strtol:
174  case LibFunc_strtod:
175  case LibFunc_strtof:
176  case LibFunc_strtoul:
177  case LibFunc_strtoll:
178  case LibFunc_strtold:
179  case LibFunc_strtoull:
180    Changed |= setDoesNotThrow(F);
181    Changed |= setDoesNotCapture(F, 1);
182    Changed |= setOnlyReadsMemory(F, 0);
183    return Changed;
184  case LibFunc_strcpy:
185  case LibFunc_strncpy:
186    Changed |= setDoesNotAlias(F, 0);
187    Changed |= setDoesNotAlias(F, 1);
188    LLVM_FALLTHROUGH;
189  case LibFunc_strcat:
190  case LibFunc_strncat:
191    Changed |= setReturnedArg(F, 0);
192    LLVM_FALLTHROUGH;
193  case LibFunc_stpcpy:
194  case LibFunc_stpncpy:
195    Changed |= setDoesNotThrow(F);
196    Changed |= setDoesNotCapture(F, 1);
197    Changed |= setOnlyReadsMemory(F, 1);
198    return Changed;
199  case LibFunc_strxfrm:
200    Changed |= setDoesNotThrow(F);
201    Changed |= setDoesNotCapture(F, 0);
202    Changed |= setDoesNotCapture(F, 1);
203    Changed |= setOnlyReadsMemory(F, 1);
204    return Changed;
205  case LibFunc_strcmp:      // 0,1
206  case LibFunc_strspn:      // 0,1
207  case LibFunc_strncmp:     // 0,1
208  case LibFunc_strcspn:     // 0,1
209  case LibFunc_strcoll:     // 0,1
210  case LibFunc_strcasecmp:  // 0,1
211  case LibFunc_strncasecmp: //
212    Changed |= setOnlyReadsMemory(F);
213    Changed |= setDoesNotThrow(F);
214    Changed |= setDoesNotCapture(F, 0);
215    Changed |= setDoesNotCapture(F, 1);
216    return Changed;
217  case LibFunc_strstr:
218  case LibFunc_strpbrk:
219    Changed |= setOnlyReadsMemory(F);
220    Changed |= setDoesNotThrow(F);
221    Changed |= setDoesNotCapture(F, 1);
222    return Changed;
223  case LibFunc_strtok:
224  case LibFunc_strtok_r:
225    Changed |= setDoesNotThrow(F);
226    Changed |= setDoesNotCapture(F, 1);
227    Changed |= setOnlyReadsMemory(F, 1);
228    return Changed;
229  case LibFunc_scanf:
230    Changed |= setDoesNotThrow(F);
231    Changed |= setDoesNotCapture(F, 0);
232    Changed |= setOnlyReadsMemory(F, 0);
233    return Changed;
234  case LibFunc_setbuf:
235  case LibFunc_setvbuf:
236    Changed |= setDoesNotThrow(F);
237    Changed |= setDoesNotCapture(F, 0);
238    return Changed;
239  case LibFunc_strdup:
240  case LibFunc_strndup:
241    Changed |= setDoesNotThrow(F);
242    Changed |= setRetDoesNotAlias(F);
243    Changed |= setDoesNotCapture(F, 0);
244    Changed |= setOnlyReadsMemory(F, 0);
245    return Changed;
246  case LibFunc_stat:
247  case LibFunc_statvfs:
248    Changed |= setDoesNotThrow(F);
249    Changed |= setDoesNotCapture(F, 0);
250    Changed |= setDoesNotCapture(F, 1);
251    Changed |= setOnlyReadsMemory(F, 0);
252    return Changed;
253  case LibFunc_sscanf:
254    Changed |= setDoesNotThrow(F);
255    Changed |= setDoesNotCapture(F, 0);
256    Changed |= setDoesNotCapture(F, 1);
257    Changed |= setOnlyReadsMemory(F, 0);
258    Changed |= setOnlyReadsMemory(F, 1);
259    return Changed;
260  case LibFunc_sprintf:
261    Changed |= setDoesNotThrow(F);
262    Changed |= setDoesNotCapture(F, 0);
263    Changed |= setDoesNotAlias(F, 0);
264    Changed |= setDoesNotCapture(F, 1);
265    Changed |= setOnlyReadsMemory(F, 1);
266    return Changed;
267  case LibFunc_snprintf:
268    Changed |= setDoesNotThrow(F);
269    Changed |= setDoesNotCapture(F, 0);
270    Changed |= setDoesNotAlias(F, 0);
271    Changed |= setDoesNotCapture(F, 2);
272    Changed |= setOnlyReadsMemory(F, 2);
273    return Changed;
274  case LibFunc_setitimer:
275    Changed |= setDoesNotThrow(F);
276    Changed |= setDoesNotCapture(F, 1);
277    Changed |= setDoesNotCapture(F, 2);
278    Changed |= setOnlyReadsMemory(F, 1);
279    return Changed;
280  case LibFunc_system:
281    // May throw; "system" is a valid pthread cancellation point.
282    Changed |= setDoesNotCapture(F, 0);
283    Changed |= setOnlyReadsMemory(F, 0);
284    return Changed;
285  case LibFunc_malloc:
286    Changed |= setDoesNotThrow(F);
287    Changed |= setRetDoesNotAlias(F);
288    return Changed;
289  case LibFunc_memcmp:
290    Changed |= setOnlyReadsMemory(F);
291    Changed |= setDoesNotThrow(F);
292    Changed |= setDoesNotCapture(F, 0);
293    Changed |= setDoesNotCapture(F, 1);
294    return Changed;
295  case LibFunc_memchr:
296  case LibFunc_memrchr:
297    Changed |= setOnlyReadsMemory(F);
298    Changed |= setDoesNotThrow(F);
299    return Changed;
300  case LibFunc_modf:
301  case LibFunc_modff:
302  case LibFunc_modfl:
303    Changed |= setDoesNotThrow(F);
304    Changed |= setDoesNotCapture(F, 1);
305    return Changed;
306  case LibFunc_memcpy:
307    Changed |= setDoesNotAlias(F, 0);
308    Changed |= setDoesNotAlias(F, 1);
309    Changed |= setReturnedArg(F, 0);
310    Changed |= setDoesNotThrow(F);
311    Changed |= setDoesNotCapture(F, 1);
312    Changed |= setOnlyReadsMemory(F, 1);
313    return Changed;
314  case LibFunc_memmove:
315    Changed |= setReturnedArg(F, 0);
316    Changed |= setDoesNotThrow(F);
317    Changed |= setDoesNotCapture(F, 1);
318    Changed |= setOnlyReadsMemory(F, 1);
319    return Changed;
320  case LibFunc_mempcpy:
321  case LibFunc_memccpy:
322    Changed |= setDoesNotAlias(F, 0);
323    Changed |= setDoesNotAlias(F, 1);
324    Changed |= setDoesNotThrow(F);
325    Changed |= setDoesNotCapture(F, 1);
326    Changed |= setOnlyReadsMemory(F, 1);
327    return Changed;
328  case LibFunc_memcpy_chk:
329    Changed |= setDoesNotThrow(F);
330    return Changed;
331  case LibFunc_memalign:
332    Changed |= setRetDoesNotAlias(F);
333    return Changed;
334  case LibFunc_mkdir:
335    Changed |= setDoesNotThrow(F);
336    Changed |= setDoesNotCapture(F, 0);
337    Changed |= setOnlyReadsMemory(F, 0);
338    return Changed;
339  case LibFunc_mktime:
340    Changed |= setDoesNotThrow(F);
341    Changed |= setDoesNotCapture(F, 0);
342    return Changed;
343  case LibFunc_realloc:
344    Changed |= setDoesNotThrow(F);
345    Changed |= setRetDoesNotAlias(F);
346    Changed |= setDoesNotCapture(F, 0);
347    return Changed;
348  case LibFunc_read:
349    // May throw; "read" is a valid pthread cancellation point.
350    Changed |= setDoesNotCapture(F, 1);
351    return Changed;
352  case LibFunc_rewind:
353    Changed |= setDoesNotThrow(F);
354    Changed |= setDoesNotCapture(F, 0);
355    return Changed;
356  case LibFunc_rmdir:
357  case LibFunc_remove:
358  case LibFunc_realpath:
359    Changed |= setDoesNotThrow(F);
360    Changed |= setDoesNotCapture(F, 0);
361    Changed |= setOnlyReadsMemory(F, 0);
362    return Changed;
363  case LibFunc_rename:
364    Changed |= setDoesNotThrow(F);
365    Changed |= setDoesNotCapture(F, 0);
366    Changed |= setDoesNotCapture(F, 1);
367    Changed |= setOnlyReadsMemory(F, 0);
368    Changed |= setOnlyReadsMemory(F, 1);
369    return Changed;
370  case LibFunc_readlink:
371    Changed |= setDoesNotThrow(F);
372    Changed |= setDoesNotCapture(F, 0);
373    Changed |= setDoesNotCapture(F, 1);
374    Changed |= setOnlyReadsMemory(F, 0);
375    return Changed;
376  case LibFunc_write:
377    // May throw; "write" is a valid pthread cancellation point.
378    Changed |= setDoesNotCapture(F, 1);
379    Changed |= setOnlyReadsMemory(F, 1);
380    return Changed;
381  case LibFunc_bcopy:
382    Changed |= setDoesNotThrow(F);
383    Changed |= setDoesNotCapture(F, 0);
384    Changed |= setDoesNotCapture(F, 1);
385    Changed |= setOnlyReadsMemory(F, 0);
386    return Changed;
387  case LibFunc_bcmp:
388    Changed |= setDoesNotThrow(F);
389    Changed |= setOnlyReadsMemory(F);
390    Changed |= setDoesNotCapture(F, 0);
391    Changed |= setDoesNotCapture(F, 1);
392    return Changed;
393  case LibFunc_bzero:
394    Changed |= setDoesNotThrow(F);
395    Changed |= setDoesNotCapture(F, 0);
396    return Changed;
397  case LibFunc_calloc:
398    Changed |= setDoesNotThrow(F);
399    Changed |= setRetDoesNotAlias(F);
400    return Changed;
401  case LibFunc_chmod:
402  case LibFunc_chown:
403    Changed |= setDoesNotThrow(F);
404    Changed |= setDoesNotCapture(F, 0);
405    Changed |= setOnlyReadsMemory(F, 0);
406    return Changed;
407  case LibFunc_ctermid:
408  case LibFunc_clearerr:
409  case LibFunc_closedir:
410    Changed |= setDoesNotThrow(F);
411    Changed |= setDoesNotCapture(F, 0);
412    return Changed;
413  case LibFunc_atoi:
414  case LibFunc_atol:
415  case LibFunc_atof:
416  case LibFunc_atoll:
417    Changed |= setDoesNotThrow(F);
418    Changed |= setOnlyReadsMemory(F);
419    Changed |= setDoesNotCapture(F, 0);
420    return Changed;
421  case LibFunc_access:
422    Changed |= setDoesNotThrow(F);
423    Changed |= setDoesNotCapture(F, 0);
424    Changed |= setOnlyReadsMemory(F, 0);
425    return Changed;
426  case LibFunc_fopen:
427    Changed |= setDoesNotThrow(F);
428    Changed |= setRetDoesNotAlias(F);
429    Changed |= setDoesNotCapture(F, 0);
430    Changed |= setDoesNotCapture(F, 1);
431    Changed |= setOnlyReadsMemory(F, 0);
432    Changed |= setOnlyReadsMemory(F, 1);
433    return Changed;
434  case LibFunc_fdopen:
435    Changed |= setDoesNotThrow(F);
436    Changed |= setRetDoesNotAlias(F);
437    Changed |= setDoesNotCapture(F, 1);
438    Changed |= setOnlyReadsMemory(F, 1);
439    return Changed;
440  case LibFunc_feof:
441  case LibFunc_free:
442  case LibFunc_fseek:
443  case LibFunc_ftell:
444  case LibFunc_fgetc:
445  case LibFunc_fgetc_unlocked:
446  case LibFunc_fseeko:
447  case LibFunc_ftello:
448  case LibFunc_fileno:
449  case LibFunc_fflush:
450  case LibFunc_fclose:
451  case LibFunc_fsetpos:
452  case LibFunc_flockfile:
453  case LibFunc_funlockfile:
454  case LibFunc_ftrylockfile:
455    Changed |= setDoesNotThrow(F);
456    Changed |= setDoesNotCapture(F, 0);
457    return Changed;
458  case LibFunc_ferror:
459    Changed |= setDoesNotThrow(F);
460    Changed |= setDoesNotCapture(F, 0);
461    Changed |= setOnlyReadsMemory(F);
462    return Changed;
463  case LibFunc_fputc:
464  case LibFunc_fputc_unlocked:
465  case LibFunc_fstat:
466  case LibFunc_frexp:
467  case LibFunc_frexpf:
468  case LibFunc_frexpl:
469  case LibFunc_fstatvfs:
470    Changed |= setDoesNotThrow(F);
471    Changed |= setDoesNotCapture(F, 1);
472    return Changed;
473  case LibFunc_fgets:
474  case LibFunc_fgets_unlocked:
475    Changed |= setDoesNotThrow(F);
476    Changed |= setDoesNotCapture(F, 2);
477    return Changed;
478  case LibFunc_fread:
479  case LibFunc_fread_unlocked:
480    Changed |= setDoesNotThrow(F);
481    Changed |= setDoesNotCapture(F, 0);
482    Changed |= setDoesNotCapture(F, 3);
483    return Changed;
484  case LibFunc_fwrite:
485  case LibFunc_fwrite_unlocked:
486    Changed |= setDoesNotThrow(F);
487    Changed |= setDoesNotCapture(F, 0);
488    Changed |= setDoesNotCapture(F, 3);
489    // FIXME: readonly #1?
490    return Changed;
491  case LibFunc_fputs:
492  case LibFunc_fputs_unlocked:
493    Changed |= setDoesNotThrow(F);
494    Changed |= setDoesNotCapture(F, 0);
495    Changed |= setDoesNotCapture(F, 1);
496    Changed |= setOnlyReadsMemory(F, 0);
497    return Changed;
498  case LibFunc_fscanf:
499  case LibFunc_fprintf:
500    Changed |= setDoesNotThrow(F);
501    Changed |= setDoesNotCapture(F, 0);
502    Changed |= setDoesNotCapture(F, 1);
503    Changed |= setOnlyReadsMemory(F, 1);
504    return Changed;
505  case LibFunc_fgetpos:
506    Changed |= setDoesNotThrow(F);
507    Changed |= setDoesNotCapture(F, 0);
508    Changed |= setDoesNotCapture(F, 1);
509    return Changed;
510  case LibFunc_getc:
511  case LibFunc_getlogin_r:
512  case LibFunc_getc_unlocked:
513    Changed |= setDoesNotThrow(F);
514    Changed |= setDoesNotCapture(F, 0);
515    return Changed;
516  case LibFunc_getenv:
517    Changed |= setDoesNotThrow(F);
518    Changed |= setOnlyReadsMemory(F);
519    Changed |= setDoesNotCapture(F, 0);
520    return Changed;
521  case LibFunc_gets:
522  case LibFunc_getchar:
523  case LibFunc_getchar_unlocked:
524    Changed |= setDoesNotThrow(F);
525    return Changed;
526  case LibFunc_getitimer:
527    Changed |= setDoesNotThrow(F);
528    Changed |= setDoesNotCapture(F, 1);
529    return Changed;
530  case LibFunc_getpwnam:
531    Changed |= setDoesNotThrow(F);
532    Changed |= setDoesNotCapture(F, 0);
533    Changed |= setOnlyReadsMemory(F, 0);
534    return Changed;
535  case LibFunc_ungetc:
536    Changed |= setDoesNotThrow(F);
537    Changed |= setDoesNotCapture(F, 1);
538    return Changed;
539  case LibFunc_uname:
540    Changed |= setDoesNotThrow(F);
541    Changed |= setDoesNotCapture(F, 0);
542    return Changed;
543  case LibFunc_unlink:
544    Changed |= setDoesNotThrow(F);
545    Changed |= setDoesNotCapture(F, 0);
546    Changed |= setOnlyReadsMemory(F, 0);
547    return Changed;
548  case LibFunc_unsetenv:
549    Changed |= setDoesNotThrow(F);
550    Changed |= setDoesNotCapture(F, 0);
551    Changed |= setOnlyReadsMemory(F, 0);
552    return Changed;
553  case LibFunc_utime:
554  case LibFunc_utimes:
555    Changed |= setDoesNotThrow(F);
556    Changed |= setDoesNotCapture(F, 0);
557    Changed |= setDoesNotCapture(F, 1);
558    Changed |= setOnlyReadsMemory(F, 0);
559    Changed |= setOnlyReadsMemory(F, 1);
560    return Changed;
561  case LibFunc_putc:
562  case LibFunc_putc_unlocked:
563    Changed |= setDoesNotThrow(F);
564    Changed |= setDoesNotCapture(F, 1);
565    return Changed;
566  case LibFunc_puts:
567  case LibFunc_printf:
568  case LibFunc_perror:
569    Changed |= setDoesNotThrow(F);
570    Changed |= setDoesNotCapture(F, 0);
571    Changed |= setOnlyReadsMemory(F, 0);
572    return Changed;
573  case LibFunc_pread:
574    // May throw; "pread" is a valid pthread cancellation point.
575    Changed |= setDoesNotCapture(F, 1);
576    return Changed;
577  case LibFunc_pwrite:
578    // May throw; "pwrite" is a valid pthread cancellation point.
579    Changed |= setDoesNotCapture(F, 1);
580    Changed |= setOnlyReadsMemory(F, 1);
581    return Changed;
582  case LibFunc_putchar:
583  case LibFunc_putchar_unlocked:
584    Changed |= setDoesNotThrow(F);
585    return Changed;
586  case LibFunc_popen:
587    Changed |= setDoesNotThrow(F);
588    Changed |= setRetDoesNotAlias(F);
589    Changed |= setDoesNotCapture(F, 0);
590    Changed |= setDoesNotCapture(F, 1);
591    Changed |= setOnlyReadsMemory(F, 0);
592    Changed |= setOnlyReadsMemory(F, 1);
593    return Changed;
594  case LibFunc_pclose:
595    Changed |= setDoesNotThrow(F);
596    Changed |= setDoesNotCapture(F, 0);
597    return Changed;
598  case LibFunc_vscanf:
599    Changed |= setDoesNotThrow(F);
600    Changed |= setDoesNotCapture(F, 0);
601    Changed |= setOnlyReadsMemory(F, 0);
602    return Changed;
603  case LibFunc_vsscanf:
604    Changed |= setDoesNotThrow(F);
605    Changed |= setDoesNotCapture(F, 0);
606    Changed |= setDoesNotCapture(F, 1);
607    Changed |= setOnlyReadsMemory(F, 0);
608    Changed |= setOnlyReadsMemory(F, 1);
609    return Changed;
610  case LibFunc_vfscanf:
611    Changed |= setDoesNotThrow(F);
612    Changed |= setDoesNotCapture(F, 0);
613    Changed |= setDoesNotCapture(F, 1);
614    Changed |= setOnlyReadsMemory(F, 1);
615    return Changed;
616  case LibFunc_valloc:
617    Changed |= setDoesNotThrow(F);
618    Changed |= setRetDoesNotAlias(F);
619    return Changed;
620  case LibFunc_vprintf:
621    Changed |= setDoesNotThrow(F);
622    Changed |= setDoesNotCapture(F, 0);
623    Changed |= setOnlyReadsMemory(F, 0);
624    return Changed;
625  case LibFunc_vfprintf:
626  case LibFunc_vsprintf:
627    Changed |= setDoesNotThrow(F);
628    Changed |= setDoesNotCapture(F, 0);
629    Changed |= setDoesNotCapture(F, 1);
630    Changed |= setOnlyReadsMemory(F, 1);
631    return Changed;
632  case LibFunc_vsnprintf:
633    Changed |= setDoesNotThrow(F);
634    Changed |= setDoesNotCapture(F, 0);
635    Changed |= setDoesNotCapture(F, 2);
636    Changed |= setOnlyReadsMemory(F, 2);
637    return Changed;
638  case LibFunc_open:
639    // May throw; "open" is a valid pthread cancellation point.
640    Changed |= setDoesNotCapture(F, 0);
641    Changed |= setOnlyReadsMemory(F, 0);
642    return Changed;
643  case LibFunc_opendir:
644    Changed |= setDoesNotThrow(F);
645    Changed |= setRetDoesNotAlias(F);
646    Changed |= setDoesNotCapture(F, 0);
647    Changed |= setOnlyReadsMemory(F, 0);
648    return Changed;
649  case LibFunc_tmpfile:
650    Changed |= setDoesNotThrow(F);
651    Changed |= setRetDoesNotAlias(F);
652    return Changed;
653  case LibFunc_times:
654    Changed |= setDoesNotThrow(F);
655    Changed |= setDoesNotCapture(F, 0);
656    return Changed;
657  case LibFunc_htonl:
658  case LibFunc_htons:
659  case LibFunc_ntohl:
660  case LibFunc_ntohs:
661    Changed |= setDoesNotThrow(F);
662    Changed |= setDoesNotAccessMemory(F);
663    return Changed;
664  case LibFunc_lstat:
665    Changed |= setDoesNotThrow(F);
666    Changed |= setDoesNotCapture(F, 0);
667    Changed |= setDoesNotCapture(F, 1);
668    Changed |= setOnlyReadsMemory(F, 0);
669    return Changed;
670  case LibFunc_lchown:
671    Changed |= setDoesNotThrow(F);
672    Changed |= setDoesNotCapture(F, 0);
673    Changed |= setOnlyReadsMemory(F, 0);
674    return Changed;
675  case LibFunc_qsort:
676    // May throw; places call through function pointer.
677    Changed |= setDoesNotCapture(F, 3);
678    return Changed;
679  case LibFunc_dunder_strdup:
680  case LibFunc_dunder_strndup:
681    Changed |= setDoesNotThrow(F);
682    Changed |= setRetDoesNotAlias(F);
683    Changed |= setDoesNotCapture(F, 0);
684    Changed |= setOnlyReadsMemory(F, 0);
685    return Changed;
686  case LibFunc_dunder_strtok_r:
687    Changed |= setDoesNotThrow(F);
688    Changed |= setDoesNotCapture(F, 1);
689    Changed |= setOnlyReadsMemory(F, 1);
690    return Changed;
691  case LibFunc_under_IO_getc:
692    Changed |= setDoesNotThrow(F);
693    Changed |= setDoesNotCapture(F, 0);
694    return Changed;
695  case LibFunc_under_IO_putc:
696    Changed |= setDoesNotThrow(F);
697    Changed |= setDoesNotCapture(F, 1);
698    return Changed;
699  case LibFunc_dunder_isoc99_scanf:
700    Changed |= setDoesNotThrow(F);
701    Changed |= setDoesNotCapture(F, 0);
702    Changed |= setOnlyReadsMemory(F, 0);
703    return Changed;
704  case LibFunc_stat64:
705  case LibFunc_lstat64:
706  case LibFunc_statvfs64:
707    Changed |= setDoesNotThrow(F);
708    Changed |= setDoesNotCapture(F, 0);
709    Changed |= setDoesNotCapture(F, 1);
710    Changed |= setOnlyReadsMemory(F, 0);
711    return Changed;
712  case LibFunc_dunder_isoc99_sscanf:
713    Changed |= setDoesNotThrow(F);
714    Changed |= setDoesNotCapture(F, 0);
715    Changed |= setDoesNotCapture(F, 1);
716    Changed |= setOnlyReadsMemory(F, 0);
717    Changed |= setOnlyReadsMemory(F, 1);
718    return Changed;
719  case LibFunc_fopen64:
720    Changed |= setDoesNotThrow(F);
721    Changed |= setRetDoesNotAlias(F);
722    Changed |= setDoesNotCapture(F, 0);
723    Changed |= setDoesNotCapture(F, 1);
724    Changed |= setOnlyReadsMemory(F, 0);
725    Changed |= setOnlyReadsMemory(F, 1);
726    return Changed;
727  case LibFunc_fseeko64:
728  case LibFunc_ftello64:
729    Changed |= setDoesNotThrow(F);
730    Changed |= setDoesNotCapture(F, 0);
731    return Changed;
732  case LibFunc_tmpfile64:
733    Changed |= setDoesNotThrow(F);
734    Changed |= setRetDoesNotAlias(F);
735    return Changed;
736  case LibFunc_fstat64:
737  case LibFunc_fstatvfs64:
738    Changed |= setDoesNotThrow(F);
739    Changed |= setDoesNotCapture(F, 1);
740    return Changed;
741  case LibFunc_open64:
742    // May throw; "open" is a valid pthread cancellation point.
743    Changed |= setDoesNotCapture(F, 0);
744    Changed |= setOnlyReadsMemory(F, 0);
745    return Changed;
746  case LibFunc_gettimeofday:
747    // Currently some platforms have the restrict keyword on the arguments to
748    // gettimeofday. To be conservative, do not add noalias to gettimeofday's
749    // arguments.
750    Changed |= setDoesNotThrow(F);
751    Changed |= setDoesNotCapture(F, 0);
752    Changed |= setDoesNotCapture(F, 1);
753    return Changed;
754  case LibFunc_Znwj: // new(unsigned int)
755  case LibFunc_Znwm: // new(unsigned long)
756  case LibFunc_Znaj: // new[](unsigned int)
757  case LibFunc_Znam: // new[](unsigned long)
758  case LibFunc_msvc_new_int: // new(unsigned int)
759  case LibFunc_msvc_new_longlong: // new(unsigned long long)
760  case LibFunc_msvc_new_array_int: // new[](unsigned int)
761  case LibFunc_msvc_new_array_longlong: // new[](unsigned long long)
762    // Operator new always returns a nonnull noalias pointer
763    Changed |= setRetNonNull(F);
764    Changed |= setRetDoesNotAlias(F);
765    return Changed;
766  // TODO: add LibFunc entries for:
767  // case LibFunc_memset_pattern4:
768  // case LibFunc_memset_pattern8:
769  case LibFunc_memset_pattern16:
770    Changed |= setOnlyAccessesArgMemory(F);
771    Changed |= setDoesNotCapture(F, 0);
772    Changed |= setDoesNotCapture(F, 1);
773    Changed |= setOnlyReadsMemory(F, 1);
774    return Changed;
775  // int __nvvm_reflect(const char *)
776  case LibFunc_nvvm_reflect:
777    Changed |= setDoesNotAccessMemory(F);
778    Changed |= setDoesNotThrow(F);
779    return Changed;
780
781  default:
782    // FIXME: It'd be really nice to cover all the library functions we're
783    // aware of here.
784    return false;
785  }
786}
787
788bool llvm::hasFloatFn(const TargetLibraryInfo *TLI, Type *Ty,
789                      LibFunc DoubleFn, LibFunc FloatFn, LibFunc LongDoubleFn) {
790  switch (Ty->getTypeID()) {
791  case Type::HalfTyID:
792    return false;
793  case Type::FloatTyID:
794    return TLI->has(FloatFn);
795  case Type::DoubleTyID:
796    return TLI->has(DoubleFn);
797  default:
798    return TLI->has(LongDoubleFn);
799  }
800}
801
802StringRef llvm::getFloatFnName(const TargetLibraryInfo *TLI, Type *Ty,
803                               LibFunc DoubleFn, LibFunc FloatFn,
804                               LibFunc LongDoubleFn) {
805  assert(hasFloatFn(TLI, Ty, DoubleFn, FloatFn, LongDoubleFn) &&
806         "Cannot get name for unavailable function!");
807
808  switch (Ty->getTypeID()) {
809  case Type::HalfTyID:
810    llvm_unreachable("No name for HalfTy!");
811  case Type::FloatTyID:
812    return TLI->getName(FloatFn);
813  case Type::DoubleTyID:
814    return TLI->getName(DoubleFn);
815  default:
816    return TLI->getName(LongDoubleFn);
817  }
818}
819
820//- Emit LibCalls ------------------------------------------------------------//
821
822Value *llvm::castToCStr(Value *V, IRBuilder<> &B) {
823  unsigned AS = V->getType()->getPointerAddressSpace();
824  return B.CreateBitCast(V, B.getInt8PtrTy(AS), "cstr");
825}
826
827static Value *emitLibCall(LibFunc TheLibFunc, Type *ReturnType,
828                          ArrayRef<Type *> ParamTypes,
829                          ArrayRef<Value *> Operands, IRBuilder<> &B,
830                          const TargetLibraryInfo *TLI,
831                          bool IsVaArgs = false) {
832  if (!TLI->has(TheLibFunc))
833    return nullptr;
834
835  Module *M = B.GetInsertBlock()->getModule();
836  StringRef FuncName = TLI->getName(TheLibFunc);
837  FunctionType *FuncType = FunctionType::get(ReturnType, ParamTypes, IsVaArgs);
838  FunctionCallee Callee = M->getOrInsertFunction(FuncName, FuncType);
839  inferLibFuncAttributes(M, FuncName, *TLI);
840  CallInst *CI = B.CreateCall(Callee, Operands, FuncName);
841  if (const Function *F =
842          dyn_cast<Function>(Callee.getCallee()->stripPointerCasts()))
843    CI->setCallingConv(F->getCallingConv());
844  return CI;
845}
846
847Value *llvm::emitStrLen(Value *Ptr, IRBuilder<> &B, const DataLayout &DL,
848                        const TargetLibraryInfo *TLI) {
849  LLVMContext &Context = B.GetInsertBlock()->getContext();
850  return emitLibCall(LibFunc_strlen, DL.getIntPtrType(Context),
851                     B.getInt8PtrTy(), castToCStr(Ptr, B), B, TLI);
852}
853
854Value *llvm::emitStrDup(Value *Ptr, IRBuilder<> &B,
855                        const TargetLibraryInfo *TLI) {
856  return emitLibCall(LibFunc_strdup, B.getInt8PtrTy(), B.getInt8PtrTy(),
857                     castToCStr(Ptr, B), B, TLI);
858}
859
860Value *llvm::emitStrChr(Value *Ptr, char C, IRBuilder<> &B,
861                        const TargetLibraryInfo *TLI) {
862  Type *I8Ptr = B.getInt8PtrTy();
863  Type *I32Ty = B.getInt32Ty();
864  return emitLibCall(LibFunc_strchr, I8Ptr, {I8Ptr, I32Ty},
865                     {castToCStr(Ptr, B), ConstantInt::get(I32Ty, C)}, B, TLI);
866}
867
868Value *llvm::emitStrNCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilder<> &B,
869                         const DataLayout &DL, const TargetLibraryInfo *TLI) {
870  LLVMContext &Context = B.GetInsertBlock()->getContext();
871  return emitLibCall(
872      LibFunc_strncmp, B.getInt32Ty(),
873      {B.getInt8PtrTy(), B.getInt8PtrTy(), DL.getIntPtrType(Context)},
874      {castToCStr(Ptr1, B), castToCStr(Ptr2, B), Len}, B, TLI);
875}
876
877Value *llvm::emitStrCpy(Value *Dst, Value *Src, IRBuilder<> &B,
878                        const TargetLibraryInfo *TLI) {
879  Type *I8Ptr = B.getInt8PtrTy();
880  return emitLibCall(LibFunc_strcpy, I8Ptr, {I8Ptr, I8Ptr},
881                     {castToCStr(Dst, B), castToCStr(Src, B)}, B, TLI);
882}
883
884Value *llvm::emitStpCpy(Value *Dst, Value *Src, IRBuilder<> &B,
885                        const TargetLibraryInfo *TLI) {
886  Type *I8Ptr = B.getInt8PtrTy();
887  return emitLibCall(LibFunc_stpcpy, I8Ptr, {I8Ptr, I8Ptr},
888                     {castToCStr(Dst, B), castToCStr(Src, B)}, B, TLI);
889}
890
891Value *llvm::emitStrNCpy(Value *Dst, Value *Src, Value *Len, IRBuilder<> &B,
892                         const TargetLibraryInfo *TLI) {
893  Type *I8Ptr = B.getInt8PtrTy();
894  return emitLibCall(LibFunc_strncpy, I8Ptr, {I8Ptr, I8Ptr, Len->getType()},
895                     {castToCStr(Dst, B), castToCStr(Src, B), Len}, B, TLI);
896}
897
898Value *llvm::emitStpNCpy(Value *Dst, Value *Src, Value *Len, IRBuilder<> &B,
899                         const TargetLibraryInfo *TLI) {
900  Type *I8Ptr = B.getInt8PtrTy();
901  return emitLibCall(LibFunc_stpncpy, I8Ptr, {I8Ptr, I8Ptr, Len->getType()},
902                     {castToCStr(Dst, B), castToCStr(Src, B), Len}, B, TLI);
903}
904
905Value *llvm::emitMemCpyChk(Value *Dst, Value *Src, Value *Len, Value *ObjSize,
906                           IRBuilder<> &B, const DataLayout &DL,
907                           const TargetLibraryInfo *TLI) {
908  if (!TLI->has(LibFunc_memcpy_chk))
909    return nullptr;
910
911  Module *M = B.GetInsertBlock()->getModule();
912  AttributeList AS;
913  AS = AttributeList::get(M->getContext(), AttributeList::FunctionIndex,
914                          Attribute::NoUnwind);
915  LLVMContext &Context = B.GetInsertBlock()->getContext();
916  FunctionCallee MemCpy = M->getOrInsertFunction(
917      "__memcpy_chk", AttributeList::get(M->getContext(), AS), B.getInt8PtrTy(),
918      B.getInt8PtrTy(), B.getInt8PtrTy(), DL.getIntPtrType(Context),
919      DL.getIntPtrType(Context));
920  Dst = castToCStr(Dst, B);
921  Src = castToCStr(Src, B);
922  CallInst *CI = B.CreateCall(MemCpy, {Dst, Src, Len, ObjSize});
923  if (const Function *F =
924          dyn_cast<Function>(MemCpy.getCallee()->stripPointerCasts()))
925    CI->setCallingConv(F->getCallingConv());
926  return CI;
927}
928
929Value *llvm::emitMemChr(Value *Ptr, Value *Val, Value *Len, IRBuilder<> &B,
930                        const DataLayout &DL, const TargetLibraryInfo *TLI) {
931  LLVMContext &Context = B.GetInsertBlock()->getContext();
932  return emitLibCall(
933      LibFunc_memchr, B.getInt8PtrTy(),
934      {B.getInt8PtrTy(), B.getInt32Ty(), DL.getIntPtrType(Context)},
935      {castToCStr(Ptr, B), Val, Len}, B, TLI);
936}
937
938Value *llvm::emitMemCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilder<> &B,
939                        const DataLayout &DL, const TargetLibraryInfo *TLI) {
940  LLVMContext &Context = B.GetInsertBlock()->getContext();
941  return emitLibCall(
942      LibFunc_memcmp, B.getInt32Ty(),
943      {B.getInt8PtrTy(), B.getInt8PtrTy(), DL.getIntPtrType(Context)},
944      {castToCStr(Ptr1, B), castToCStr(Ptr2, B), Len}, B, TLI);
945}
946
947Value *llvm::emitBCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilder<> &B,
948                      const DataLayout &DL, const TargetLibraryInfo *TLI) {
949  LLVMContext &Context = B.GetInsertBlock()->getContext();
950  return emitLibCall(
951      LibFunc_bcmp, B.getInt32Ty(),
952      {B.getInt8PtrTy(), B.getInt8PtrTy(), DL.getIntPtrType(Context)},
953      {castToCStr(Ptr1, B), castToCStr(Ptr2, B), Len}, B, TLI);
954}
955
956Value *llvm::emitMemCCpy(Value *Ptr1, Value *Ptr2, Value *Val, Value *Len,
957                         IRBuilder<> &B, const TargetLibraryInfo *TLI) {
958  return emitLibCall(
959      LibFunc_memccpy, B.getInt8PtrTy(),
960      {B.getInt8PtrTy(), B.getInt8PtrTy(), B.getInt32Ty(), Len->getType()},
961      {Ptr1, Ptr2, Val, Len}, B, TLI);
962}
963
964Value *llvm::emitSNPrintf(Value *Dest, Value *Size, Value *Fmt,
965                          ArrayRef<Value *> VariadicArgs, IRBuilder<> &B,
966                          const TargetLibraryInfo *TLI) {
967  SmallVector<Value *, 8> Args{castToCStr(Dest, B), Size, castToCStr(Fmt, B)};
968  Args.insert(Args.end(), VariadicArgs.begin(), VariadicArgs.end());
969  return emitLibCall(LibFunc_snprintf, B.getInt32Ty(),
970                     {B.getInt8PtrTy(), Size->getType(), B.getInt8PtrTy()},
971                     Args, B, TLI, /*IsVaArgs=*/true);
972}
973
974Value *llvm::emitSPrintf(Value *Dest, Value *Fmt,
975                         ArrayRef<Value *> VariadicArgs, IRBuilder<> &B,
976                         const TargetLibraryInfo *TLI) {
977  SmallVector<Value *, 8> Args{castToCStr(Dest, B), castToCStr(Fmt, B)};
978  Args.insert(Args.end(), VariadicArgs.begin(), VariadicArgs.end());
979  return emitLibCall(LibFunc_sprintf, B.getInt32Ty(),
980                     {B.getInt8PtrTy(), B.getInt8PtrTy()}, Args, B, TLI,
981                     /*IsVaArgs=*/true);
982}
983
984Value *llvm::emitStrCat(Value *Dest, Value *Src, IRBuilder<> &B,
985                        const TargetLibraryInfo *TLI) {
986  return emitLibCall(LibFunc_strcat, B.getInt8PtrTy(),
987                     {B.getInt8PtrTy(), B.getInt8PtrTy()},
988                     {castToCStr(Dest, B), castToCStr(Src, B)}, B, TLI);
989}
990
991Value *llvm::emitStrLCpy(Value *Dest, Value *Src, Value *Size, IRBuilder<> &B,
992                         const TargetLibraryInfo *TLI) {
993  return emitLibCall(LibFunc_strlcpy, Size->getType(),
994                     {B.getInt8PtrTy(), B.getInt8PtrTy(), Size->getType()},
995                     {castToCStr(Dest, B), castToCStr(Src, B), Size}, B, TLI);
996}
997
998Value *llvm::emitStrLCat(Value *Dest, Value *Src, Value *Size, IRBuilder<> &B,
999                         const TargetLibraryInfo *TLI) {
1000  return emitLibCall(LibFunc_strlcat, Size->getType(),
1001                     {B.getInt8PtrTy(), B.getInt8PtrTy(), Size->getType()},
1002                     {castToCStr(Dest, B), castToCStr(Src, B), Size}, B, TLI);
1003}
1004
1005Value *llvm::emitStrNCat(Value *Dest, Value *Src, Value *Size, IRBuilder<> &B,
1006                         const TargetLibraryInfo *TLI) {
1007  return emitLibCall(LibFunc_strncat, B.getInt8PtrTy(),
1008                     {B.getInt8PtrTy(), B.getInt8PtrTy(), Size->getType()},
1009                     {castToCStr(Dest, B), castToCStr(Src, B), Size}, B, TLI);
1010}
1011
1012Value *llvm::emitVSNPrintf(Value *Dest, Value *Size, Value *Fmt, Value *VAList,
1013                           IRBuilder<> &B, const TargetLibraryInfo *TLI) {
1014  return emitLibCall(
1015      LibFunc_vsnprintf, B.getInt32Ty(),
1016      {B.getInt8PtrTy(), Size->getType(), B.getInt8PtrTy(), VAList->getType()},
1017      {castToCStr(Dest, B), Size, castToCStr(Fmt, B), VAList}, B, TLI);
1018}
1019
1020Value *llvm::emitVSPrintf(Value *Dest, Value *Fmt, Value *VAList,
1021                          IRBuilder<> &B, const TargetLibraryInfo *TLI) {
1022  return emitLibCall(LibFunc_vsprintf, B.getInt32Ty(),
1023                     {B.getInt8PtrTy(), B.getInt8PtrTy(), VAList->getType()},
1024                     {castToCStr(Dest, B), castToCStr(Fmt, B), VAList}, B, TLI);
1025}
1026
1027/// Append a suffix to the function name according to the type of 'Op'.
1028static void appendTypeSuffix(Value *Op, StringRef &Name,
1029                             SmallString<20> &NameBuffer) {
1030  if (!Op->getType()->isDoubleTy()) {
1031      NameBuffer += Name;
1032
1033    if (Op->getType()->isFloatTy())
1034      NameBuffer += 'f';
1035    else
1036      NameBuffer += 'l';
1037
1038    Name = NameBuffer;
1039  }
1040}
1041
1042static Value *emitUnaryFloatFnCallHelper(Value *Op, StringRef Name,
1043                                         IRBuilder<> &B,
1044                                         const AttributeList &Attrs) {
1045  assert((Name != "") && "Must specify Name to emitUnaryFloatFnCall");
1046
1047  Module *M = B.GetInsertBlock()->getModule();
1048  FunctionCallee Callee =
1049      M->getOrInsertFunction(Name, Op->getType(), Op->getType());
1050  CallInst *CI = B.CreateCall(Callee, Op, Name);
1051
1052  // The incoming attribute set may have come from a speculatable intrinsic, but
1053  // is being replaced with a library call which is not allowed to be
1054  // speculatable.
1055  CI->setAttributes(Attrs.removeAttribute(B.getContext(),
1056                                          AttributeList::FunctionIndex,
1057                                          Attribute::Speculatable));
1058  if (const Function *F =
1059          dyn_cast<Function>(Callee.getCallee()->stripPointerCasts()))
1060    CI->setCallingConv(F->getCallingConv());
1061
1062  return CI;
1063}
1064
1065Value *llvm::emitUnaryFloatFnCall(Value *Op, StringRef Name, IRBuilder<> &B,
1066                                  const AttributeList &Attrs) {
1067  SmallString<20> NameBuffer;
1068  appendTypeSuffix(Op, Name, NameBuffer);
1069
1070  return emitUnaryFloatFnCallHelper(Op, Name, B, Attrs);
1071}
1072
1073Value *llvm::emitUnaryFloatFnCall(Value *Op, const TargetLibraryInfo *TLI,
1074                                  LibFunc DoubleFn, LibFunc FloatFn,
1075                                  LibFunc LongDoubleFn, IRBuilder<> &B,
1076                                  const AttributeList &Attrs) {
1077  // Get the name of the function according to TLI.
1078  StringRef Name = getFloatFnName(TLI, Op->getType(),
1079                                  DoubleFn, FloatFn, LongDoubleFn);
1080
1081  return emitUnaryFloatFnCallHelper(Op, Name, B, Attrs);
1082}
1083
1084static Value *emitBinaryFloatFnCallHelper(Value *Op1, Value *Op2,
1085                                          StringRef Name, IRBuilder<> &B,
1086                                          const AttributeList &Attrs) {
1087  assert((Name != "") && "Must specify Name to emitBinaryFloatFnCall");
1088
1089  Module *M = B.GetInsertBlock()->getModule();
1090  FunctionCallee Callee = M->getOrInsertFunction(Name, Op1->getType(),
1091                                                 Op1->getType(), Op2->getType());
1092  CallInst *CI = B.CreateCall(Callee, { Op1, Op2 }, Name);
1093
1094  // The incoming attribute set may have come from a speculatable intrinsic, but
1095  // is being replaced with a library call which is not allowed to be
1096  // speculatable.
1097  CI->setAttributes(Attrs.removeAttribute(B.getContext(),
1098                                          AttributeList::FunctionIndex,
1099                                          Attribute::Speculatable));
1100  if (const Function *F =
1101          dyn_cast<Function>(Callee.getCallee()->stripPointerCasts()))
1102    CI->setCallingConv(F->getCallingConv());
1103
1104  return CI;
1105}
1106
1107Value *llvm::emitBinaryFloatFnCall(Value *Op1, Value *Op2, StringRef Name,
1108                                   IRBuilder<> &B, const AttributeList &Attrs) {
1109  assert((Name != "") && "Must specify Name to emitBinaryFloatFnCall");
1110
1111  SmallString<20> NameBuffer;
1112  appendTypeSuffix(Op1, Name, NameBuffer);
1113
1114  return emitBinaryFloatFnCallHelper(Op1, Op2, Name, B, Attrs);
1115}
1116
1117Value *llvm::emitBinaryFloatFnCall(Value *Op1, Value *Op2,
1118                                   const TargetLibraryInfo *TLI,
1119                                   LibFunc DoubleFn, LibFunc FloatFn,
1120                                   LibFunc LongDoubleFn, IRBuilder<> &B,
1121                                   const AttributeList &Attrs) {
1122  // Get the name of the function according to TLI.
1123  StringRef Name = getFloatFnName(TLI, Op1->getType(),
1124                                  DoubleFn, FloatFn, LongDoubleFn);
1125
1126  return emitBinaryFloatFnCallHelper(Op1, Op2, Name, B, Attrs);
1127}
1128
1129Value *llvm::emitPutChar(Value *Char, IRBuilder<> &B,
1130                         const TargetLibraryInfo *TLI) {
1131  if (!TLI->has(LibFunc_putchar))
1132    return nullptr;
1133
1134  Module *M = B.GetInsertBlock()->getModule();
1135  StringRef PutCharName = TLI->getName(LibFunc_putchar);
1136  FunctionCallee PutChar =
1137      M->getOrInsertFunction(PutCharName, B.getInt32Ty(), B.getInt32Ty());
1138  inferLibFuncAttributes(M, PutCharName, *TLI);
1139  CallInst *CI = B.CreateCall(PutChar,
1140                              B.CreateIntCast(Char,
1141                              B.getInt32Ty(),
1142                              /*isSigned*/true,
1143                              "chari"),
1144                              PutCharName);
1145
1146  if (const Function *F =
1147          dyn_cast<Function>(PutChar.getCallee()->stripPointerCasts()))
1148    CI->setCallingConv(F->getCallingConv());
1149  return CI;
1150}
1151
1152Value *llvm::emitPutS(Value *Str, IRBuilder<> &B,
1153                      const TargetLibraryInfo *TLI) {
1154  if (!TLI->has(LibFunc_puts))
1155    return nullptr;
1156
1157  Module *M = B.GetInsertBlock()->getModule();
1158  StringRef PutsName = TLI->getName(LibFunc_puts);
1159  FunctionCallee PutS =
1160      M->getOrInsertFunction(PutsName, B.getInt32Ty(), B.getInt8PtrTy());
1161  inferLibFuncAttributes(M, PutsName, *TLI);
1162  CallInst *CI = B.CreateCall(PutS, castToCStr(Str, B), PutsName);
1163  if (const Function *F =
1164          dyn_cast<Function>(PutS.getCallee()->stripPointerCasts()))
1165    CI->setCallingConv(F->getCallingConv());
1166  return CI;
1167}
1168
1169Value *llvm::emitFPutC(Value *Char, Value *File, IRBuilder<> &B,
1170                       const TargetLibraryInfo *TLI) {
1171  if (!TLI->has(LibFunc_fputc))
1172    return nullptr;
1173
1174  Module *M = B.GetInsertBlock()->getModule();
1175  StringRef FPutcName = TLI->getName(LibFunc_fputc);
1176  FunctionCallee F = M->getOrInsertFunction(FPutcName, B.getInt32Ty(),
1177                                            B.getInt32Ty(), File->getType());
1178  if (File->getType()->isPointerTy())
1179    inferLibFuncAttributes(M, FPutcName, *TLI);
1180  Char = B.CreateIntCast(Char, B.getInt32Ty(), /*isSigned*/true,
1181                         "chari");
1182  CallInst *CI = B.CreateCall(F, {Char, File}, FPutcName);
1183
1184  if (const Function *Fn =
1185          dyn_cast<Function>(F.getCallee()->stripPointerCasts()))
1186    CI->setCallingConv(Fn->getCallingConv());
1187  return CI;
1188}
1189
1190Value *llvm::emitFPutCUnlocked(Value *Char, Value *File, IRBuilder<> &B,
1191                               const TargetLibraryInfo *TLI) {
1192  if (!TLI->has(LibFunc_fputc_unlocked))
1193    return nullptr;
1194
1195  Module *M = B.GetInsertBlock()->getModule();
1196  StringRef FPutcUnlockedName = TLI->getName(LibFunc_fputc_unlocked);
1197  FunctionCallee F = M->getOrInsertFunction(FPutcUnlockedName, B.getInt32Ty(),
1198                                            B.getInt32Ty(), File->getType());
1199  if (File->getType()->isPointerTy())
1200    inferLibFuncAttributes(M, FPutcUnlockedName, *TLI);
1201  Char = B.CreateIntCast(Char, B.getInt32Ty(), /*isSigned*/ true, "chari");
1202  CallInst *CI = B.CreateCall(F, {Char, File}, FPutcUnlockedName);
1203
1204  if (const Function *Fn =
1205          dyn_cast<Function>(F.getCallee()->stripPointerCasts()))
1206    CI->setCallingConv(Fn->getCallingConv());
1207  return CI;
1208}
1209
1210Value *llvm::emitFPutS(Value *Str, Value *File, IRBuilder<> &B,
1211                       const TargetLibraryInfo *TLI) {
1212  if (!TLI->has(LibFunc_fputs))
1213    return nullptr;
1214
1215  Module *M = B.GetInsertBlock()->getModule();
1216  StringRef FPutsName = TLI->getName(LibFunc_fputs);
1217  FunctionCallee F = M->getOrInsertFunction(FPutsName, B.getInt32Ty(),
1218                                            B.getInt8PtrTy(), File->getType());
1219  if (File->getType()->isPointerTy())
1220    inferLibFuncAttributes(M, FPutsName, *TLI);
1221  CallInst *CI = B.CreateCall(F, {castToCStr(Str, B), File}, FPutsName);
1222
1223  if (const Function *Fn =
1224          dyn_cast<Function>(F.getCallee()->stripPointerCasts()))
1225    CI->setCallingConv(Fn->getCallingConv());
1226  return CI;
1227}
1228
1229Value *llvm::emitFPutSUnlocked(Value *Str, Value *File, IRBuilder<> &B,
1230                               const TargetLibraryInfo *TLI) {
1231  if (!TLI->has(LibFunc_fputs_unlocked))
1232    return nullptr;
1233
1234  Module *M = B.GetInsertBlock()->getModule();
1235  StringRef FPutsUnlockedName = TLI->getName(LibFunc_fputs_unlocked);
1236  FunctionCallee F = M->getOrInsertFunction(FPutsUnlockedName, B.getInt32Ty(),
1237                                            B.getInt8PtrTy(), File->getType());
1238  if (File->getType()->isPointerTy())
1239    inferLibFuncAttributes(M, FPutsUnlockedName, *TLI);
1240  CallInst *CI = B.CreateCall(F, {castToCStr(Str, B), File}, FPutsUnlockedName);
1241
1242  if (const Function *Fn =
1243          dyn_cast<Function>(F.getCallee()->stripPointerCasts()))
1244    CI->setCallingConv(Fn->getCallingConv());
1245  return CI;
1246}
1247
1248Value *llvm::emitFWrite(Value *Ptr, Value *Size, Value *File, IRBuilder<> &B,
1249                        const DataLayout &DL, const TargetLibraryInfo *TLI) {
1250  if (!TLI->has(LibFunc_fwrite))
1251    return nullptr;
1252
1253  Module *M = B.GetInsertBlock()->getModule();
1254  LLVMContext &Context = B.GetInsertBlock()->getContext();
1255  StringRef FWriteName = TLI->getName(LibFunc_fwrite);
1256  FunctionCallee F = M->getOrInsertFunction(
1257      FWriteName, DL.getIntPtrType(Context), B.getInt8PtrTy(),
1258      DL.getIntPtrType(Context), DL.getIntPtrType(Context), File->getType());
1259
1260  if (File->getType()->isPointerTy())
1261    inferLibFuncAttributes(M, FWriteName, *TLI);
1262  CallInst *CI =
1263      B.CreateCall(F, {castToCStr(Ptr, B), Size,
1264                       ConstantInt::get(DL.getIntPtrType(Context), 1), File});
1265
1266  if (const Function *Fn =
1267          dyn_cast<Function>(F.getCallee()->stripPointerCasts()))
1268    CI->setCallingConv(Fn->getCallingConv());
1269  return CI;
1270}
1271
1272Value *llvm::emitMalloc(Value *Num, IRBuilder<> &B, const DataLayout &DL,
1273                        const TargetLibraryInfo *TLI) {
1274  if (!TLI->has(LibFunc_malloc))
1275    return nullptr;
1276
1277  Module *M = B.GetInsertBlock()->getModule();
1278  StringRef MallocName = TLI->getName(LibFunc_malloc);
1279  LLVMContext &Context = B.GetInsertBlock()->getContext();
1280  FunctionCallee Malloc = M->getOrInsertFunction(MallocName, B.getInt8PtrTy(),
1281                                                 DL.getIntPtrType(Context));
1282  inferLibFuncAttributes(M, MallocName, *TLI);
1283  CallInst *CI = B.CreateCall(Malloc, Num, MallocName);
1284
1285  if (const Function *F =
1286          dyn_cast<Function>(Malloc.getCallee()->stripPointerCasts()))
1287    CI->setCallingConv(F->getCallingConv());
1288
1289  return CI;
1290}
1291
1292Value *llvm::emitCalloc(Value *Num, Value *Size, const AttributeList &Attrs,
1293                        IRBuilder<> &B, const TargetLibraryInfo &TLI) {
1294  if (!TLI.has(LibFunc_calloc))
1295    return nullptr;
1296
1297  Module *M = B.GetInsertBlock()->getModule();
1298  StringRef CallocName = TLI.getName(LibFunc_calloc);
1299  const DataLayout &DL = M->getDataLayout();
1300  IntegerType *PtrType = DL.getIntPtrType((B.GetInsertBlock()->getContext()));
1301  FunctionCallee Calloc = M->getOrInsertFunction(
1302      CallocName, Attrs, B.getInt8PtrTy(), PtrType, PtrType);
1303  inferLibFuncAttributes(M, CallocName, TLI);
1304  CallInst *CI = B.CreateCall(Calloc, {Num, Size}, CallocName);
1305
1306  if (const auto *F =
1307          dyn_cast<Function>(Calloc.getCallee()->stripPointerCasts()))
1308    CI->setCallingConv(F->getCallingConv());
1309
1310  return CI;
1311}
1312
1313Value *llvm::emitFWriteUnlocked(Value *Ptr, Value *Size, Value *N, Value *File,
1314                                IRBuilder<> &B, const DataLayout &DL,
1315                                const TargetLibraryInfo *TLI) {
1316  if (!TLI->has(LibFunc_fwrite_unlocked))
1317    return nullptr;
1318
1319  Module *M = B.GetInsertBlock()->getModule();
1320  LLVMContext &Context = B.GetInsertBlock()->getContext();
1321  StringRef FWriteUnlockedName = TLI->getName(LibFunc_fwrite_unlocked);
1322  FunctionCallee F = M->getOrInsertFunction(
1323      FWriteUnlockedName, DL.getIntPtrType(Context), B.getInt8PtrTy(),
1324      DL.getIntPtrType(Context), DL.getIntPtrType(Context), File->getType());
1325
1326  if (File->getType()->isPointerTy())
1327    inferLibFuncAttributes(M, FWriteUnlockedName, *TLI);
1328  CallInst *CI = B.CreateCall(F, {castToCStr(Ptr, B), Size, N, File});
1329
1330  if (const Function *Fn =
1331          dyn_cast<Function>(F.getCallee()->stripPointerCasts()))
1332    CI->setCallingConv(Fn->getCallingConv());
1333  return CI;
1334}
1335
1336Value *llvm::emitFGetCUnlocked(Value *File, IRBuilder<> &B,
1337                               const TargetLibraryInfo *TLI) {
1338  if (!TLI->has(LibFunc_fgetc_unlocked))
1339    return nullptr;
1340
1341  Module *M = B.GetInsertBlock()->getModule();
1342  StringRef FGetCUnlockedName = TLI->getName(LibFunc_fgetc_unlocked);
1343  FunctionCallee F = M->getOrInsertFunction(FGetCUnlockedName, B.getInt32Ty(),
1344                                            File->getType());
1345  if (File->getType()->isPointerTy())
1346    inferLibFuncAttributes(M, FGetCUnlockedName, *TLI);
1347  CallInst *CI = B.CreateCall(F, File, FGetCUnlockedName);
1348
1349  if (const Function *Fn =
1350          dyn_cast<Function>(F.getCallee()->stripPointerCasts()))
1351    CI->setCallingConv(Fn->getCallingConv());
1352  return CI;
1353}
1354
1355Value *llvm::emitFGetSUnlocked(Value *Str, Value *Size, Value *File,
1356                               IRBuilder<> &B, const TargetLibraryInfo *TLI) {
1357  if (!TLI->has(LibFunc_fgets_unlocked))
1358    return nullptr;
1359
1360  Module *M = B.GetInsertBlock()->getModule();
1361  StringRef FGetSUnlockedName = TLI->getName(LibFunc_fgets_unlocked);
1362  FunctionCallee F =
1363      M->getOrInsertFunction(FGetSUnlockedName, B.getInt8PtrTy(),
1364                             B.getInt8PtrTy(), B.getInt32Ty(), File->getType());
1365  inferLibFuncAttributes(M, FGetSUnlockedName, *TLI);
1366  CallInst *CI =
1367      B.CreateCall(F, {castToCStr(Str, B), Size, File}, FGetSUnlockedName);
1368
1369  if (const Function *Fn =
1370          dyn_cast<Function>(F.getCallee()->stripPointerCasts()))
1371    CI->setCallingConv(Fn->getCallingConv());
1372  return CI;
1373}
1374
1375Value *llvm::emitFReadUnlocked(Value *Ptr, Value *Size, Value *N, Value *File,
1376                               IRBuilder<> &B, const DataLayout &DL,
1377                               const TargetLibraryInfo *TLI) {
1378  if (!TLI->has(LibFunc_fread_unlocked))
1379    return nullptr;
1380
1381  Module *M = B.GetInsertBlock()->getModule();
1382  LLVMContext &Context = B.GetInsertBlock()->getContext();
1383  StringRef FReadUnlockedName = TLI->getName(LibFunc_fread_unlocked);
1384  FunctionCallee F = M->getOrInsertFunction(
1385      FReadUnlockedName, DL.getIntPtrType(Context), B.getInt8PtrTy(),
1386      DL.getIntPtrType(Context), DL.getIntPtrType(Context), File->getType());
1387
1388  if (File->getType()->isPointerTy())
1389    inferLibFuncAttributes(M, FReadUnlockedName, *TLI);
1390  CallInst *CI = B.CreateCall(F, {castToCStr(Ptr, B), Size, N, File});
1391
1392  if (const Function *Fn =
1393          dyn_cast<Function>(F.getCallee()->stripPointerCasts()))
1394    CI->setCallingConv(Fn->getCallingConv());
1395  return CI;
1396}
1397