[SimplifyLibcalls] Replace locked IO with unlocked IO

[xbolva00]

Summary

If file stream arg is not captured and source is fopen, we could replace IO calls by unlocked IO ("_unlocked" function variants) to gain better speed,

[xbolva00]

lib/Transforms/Utils/SimplifyLibCalls.cpp

123

Maybe we could check for "main" function too and threat it as if it was a "static one"?

[xbolva00]

Would be ok if we simplify getc to fgetc_unlocked and not getc_unlocked? Same for putc...

[lebedev.ri]

to gain better speed

Out of curiosity, what are the motivational cases, benchmarks?

if we know, that there is no fork or pthread_create calls in the current module.

I'm not sure this is sufficient.
I'll be super surprised if this could be done outside of a LTO build with no dynamic linking.

[xbolva00]

In D45736#1070249, @lebedev.ri wrote:

to gain better speed

Out of curiosity, what are the motivational cases, benchmarks?

if we know, that there is no fork or pthread_create calls in the current module.

I'm not sure this is sufficient.
I'll be super surprised if this could be done outside of a LTO build with no dynamic linking.

Motivation? I tried to "getchar and putchar" 2 MB file and using unlocked variants I got time difference around 0,1 s.

I believe there are more reasons to apply such optimizations, if possible. If we can have faster IO code, why not?

Why not sufficient?
Can you explain it more? Static function can be called only from module and if there is no fork or pthread_create, why we cant say that all static functions are not called from multiple threads/processes?

[lebedev.ri]

In D45736#1070328, @xbolva00 wrote:

In D45736#1070249, @lebedev.ri wrote:

to gain better speed

Out of curiosity, what are the motivational cases, benchmarks?

if we know, that there is no fork or pthread_create calls in the current module.

I'm not sure this is sufficient.
I'll be super surprised if this could be done outside of a LTO build with no dynamic linking.

Motivation? I tried to "getchar and putchar" 2 MB file and using unlocked variants I got time difference around 0,1 s.

I believe there are more reasons to apply such optimizations, if possible. If we can have faster IO code, why not?

Why not sufficient?
Can you explain it more?

Static function can be called only from module and if there is no fork or pthread_create, why we cant say that all static functions are not called from multiple threads/processes?

And what about said static function being [indirectly] called from some non-static function?

[xbolva00]

In D45736#1070330, @lebedev.ri wrote:

In D45736#1070328, @xbolva00 wrote:

In D45736#1070249, @lebedev.ri wrote:

to gain better speed

Out of curiosity, what are the motivational cases, benchmarks?

if we know, that there is no fork or pthread_create calls in the current module.

I'm not sure this is sufficient.
I'll be super surprised if this could be done outside of a LTO build with no dynamic linking.

Motivation? I tried to "getchar and putchar" 2 MB file and using unlocked variants I got time difference around 0,1 s.

I believe there are more reasons to apply such optimizations, if possible. If we can have faster IO code, why not?

Why not sufficient?
Can you explain it more?

Static function can be called only from module and if there is no fork or pthread_create, why we cant say that all static functions are not called from multiple threads/processes?

And what about said static function being [indirectly] called from some non-static function?

In D45736#1070330, @lebedev.ri wrote:

In D45736#1070328, @xbolva00 wrote:

In D45736#1070249, @lebedev.ri wrote:

to gain better speed

Out of curiosity, what are the motivational cases, benchmarks?

if we know, that there is no fork or pthread_create calls in the current module.

I'm not sure this is sufficient.
I'll be super surprised if this could be done outside of a LTO build with no dynamic linking.

Motivation? I tried to "getchar and putchar" 2 MB file and using unlocked variants I got time difference around 0,1 s.

I believe there are more reasons to apply such optimizations, if possible. If we can have faster IO code, why not?

Why not sufficient?
Can you explain it more?

Static function can be called only from module and if there is no fork or pthread_create, why we cant say that all static functions are not called from multiple threads/processes?

And what about said static function being [indirectly] called from some non-static function?

Ah sure. So maybe somehow check if module has only static functions (+main)? Or iterate over non static functions in module and check if our static function is called from them?

[efriedma]

So maybe somehow check if module has only static functions (+main)?

You might be able to get this to work, but there are a lot of weird edge cases, and it wouldn't be very useful in practice; most programs have more than one source code file.

The practical approach would be to use something like llvm::PointerMayBeCaptured to prove no other thread knows the value of the FILE*.

[xbolva00]

In D45736#1070347, @efriedma wrote:

So maybe somehow check if module has only static functions (+main)?

You might be able to get this to work, but there are a lot of weird edge cases, and it wouldn't be very useful in practice; most programs have more than one source code file.

The practical approach would be to use something like llvm::PointerMayBeCaptured to prove no other thread knows the value of the FILE*.

Code:
static void capt_test(void) {

FILE *f = fopen("file", "w");
char s[10];
fwrite(s, 10, 10, f);

}

int main(void) {

capt_test();

}

static bool isInSingleThread(CallInst *CI, IRBuilder<> &B) {

for (unsigned i = 0; i < CI->getNumOperands(); ++i) {
  Value *Op = CI->getOperand(i);
  if (Op->getType()->isPointerTy() && !isa<GlobalValue>(Op)) {
    errs() << "pty is " << i << " and "
           << PointerMayBeCaptured(Op, false, false) << "\n";
    if (PointerMayBeCaptured(Op, false, false))
      return false;
  }
}

return true;

}

I got that that pointers may be captured. Did I use it wrongly? It detects that fwrite captures that values, but can you explain a bit more "how to prove no other thread knows the value of the FILE via this API call"? Thanks

[efriedma]

That should work, as far as I know; maybe we aren't adding the right nocapture markings to the fwrite() call?

[xbolva00]

I checked a CaptureTracking a bit and I was surprised that doesNotCapture (CS.doesNotCapture(A - B)) returned false for parameter, which is set as "No capture" in BuildLibCalls.

Any expert for BuildLibCalls/CaptureTracking?

Edit: well, I should use getArgOperand, but problem is still same...

for (unsigned i = 0; i < CI->getNumArgOperands(); ++i) {
  Value *Op = CI->getArgOperand(i);
  if (Op->getType()->isPointerTy() && !isa<GlobalValue>(Op)) {
    errs() << "pty is " << i << " and " << PointerMayBeCaptured(Op, false, false) << "\n";
    
    if (PointerMayBeCaptured(Op, false, false))
      return false;
  }
}

[xbolva00]

NoCapture attributes check now works, I forgot about inferLibFuncAttributes..

But I still get a issue like:

define i32 @aa() #0 {
entry:

%call = call i32 @aac()
ret i32 %call

}

; Function Attrs: noinline nounwind uwtable
define internal i32 @aac() #0 {
entry:

%getchar_unlocked = call i32 @getchar_unlocked()
ret i32 %getchar_unlocked

}

Any idea how to fix it, @efriedma ?

[efriedma]

I don't think there's any practical way to prove that no other thread will write to stdout.

[xbolva00]

In D45736#1071386, @efriedma wrote:

I don't think there's any practical way to prove that no other thread will write to stdout.

I can check if non static functions call a certain static function.

[efriedma]

It doesn't matter what code is in the module which is currently being processed; another module could do __attribute((constructor)) void f() { pthread_t t; pthread_create(&t, 0, puts, "foo"); } or something.

[xbolva00]

In D45736#1071418, @efriedma wrote:

It doesn't matter what code is in the module which is currently being processed; another module could do __attribute((constructor)) void f() { pthread_t t; pthread_create(&t, 0, puts, "foo"); } or something.

Then, this patch is dead, right? Or?

If there are no external functions that could call static ones which contain IO calls.. we are still safe to do this transformation, nope?

[efriedma]

It's still possible to optimize your capt_test() example.

[xbolva00]

In D45736#1071437, @efriedma wrote:

It's still possible to optimize your capt_test() example.

Yes, I updated this patch.

[xbolva00]

@efriedma, May I add tests for "capture detection" only for one IO call, e.g. fgetc? Since all others depends on the "isReplaceableWithUnlockedVariant" anyway..

[xbolva00]

Which additional tests you would like to see?

[efriedma]

lib/Analysis/TargetLibraryInfo.cpp

321

We probably want to whitelist which operating systems these are available on, rather than blacklist; most of these aren't part of any standard.

And actually, thinking about it a bit more, the "non-standard" part has other problems; a user could define their own function named fputc_unlocked, which does something different from the GNU functions. (Nothing else in the current BuildLibCalls.h hits this particular problem because those are all reserved names.) But I'm not sure if that's likely to be a problem in practice.

lib/Transforms/Utils/SimplifyLibCalls.cpp

126

This check doesn't buy you anything.

135

This is incomplete; you also need to check that the instruction which produces the FILE* is a call to fopen, or the capture analysis won't do anything useful. Consider:

FILE* foo() { return stdout; }
void bar() { fputc('x', foo()); }

Also, iterating over the operands like this is weird; probably want to explicitly pass in which operand is the FILE*.

[xbolva00]

Fixed things .

[xbolva00]

Updated tests.

[xbolva00]

Better tests

[xbolva00]

This comment was removed by xbolva00.

[xbolva00]

ping

[xbolva00]

ping^2

[xbolva00]

Updated tests
Renamed helper function to isLocallyOpenedFile.

[lebedev.ri]

Was this actually reviewed?
The differential is not marked as accepted.

[xbolva00]

In D45736#1080224, @lebedev.ri wrote:

Was this actually reviewed?
The differential is not marked as accepted.

Notes were fixes and no futher comments were given... even if I pinged it.

I will check how to revert via arc so..

Edit: can you revert it? arc revert doesnt work with svn only.

[morehouse]

This seems to have broken the sanitizer bots: http://lab.llvm.org:8011/builders/sanitizer-x86_64-linux-fast/builds/17377.

I will revert for now.

[morehouse]

Reverted in r331011.

[lebedev.ri]

In D45736#1080228, @xbolva00 wrote:

In D45736#1080224, @lebedev.ri wrote:

Was this actually reviewed?
The differential is not marked as accepted.

Notes were fixes and no futher comments were given... even if I pinged it.

That is not how this works though.

https://llvm.org/docs/Phabricator.html#committing-a-change

Once a patch has been reviewed and approved on Phabricator it can then be committed to trunk.

I will check how to revert via arc so..

Edit: can you revert it? arc revert doesnt work with svn only.

[xbolva00]

Fixed build problems

[xbolva00]

@efriedma , @lebedev.ri:

Fixed and tested:
ThinLTO/X86/tli-nobuiltin.ll
Transforms/InstCombine/fprintf-1.ll
Transforms/InstCombine/fputs-1.ll

So it should not break the build.

I updated TargetLibraryInfoTest.cpp to fix other problem too..

but I got some problems when running ninja check-all
unittests/Transforms/Utils/CMakeFiles/UtilsTests.dir/IntegerDivision.cpp.o: In function `(anonymous namespace)::IntegerDivision_SRem64_Test::TestBody()':
IntegerDivision.cpp:(.text._ZN12_GLOBAL__N_127IntegerDivision_SRem64_Test8TestBodyEv+0x39c): undefined reference to `llvm::expandRemainder(llvm::BinaryOperator*)'

So please somebody verify this new revision too. Thanks.

[xbolva00]

annotation.ll test needs to be too, I will check it.

Any other things to do?

[xbolva00]

This comment was removed by xbolva00.

[xbolva00]

Hi @lebedev.ri ,
Can you recommend me some person who is able to review this patch?

I ran test-suite, no breakages. Older notes to the patch was fixed. I think it is good to go.

[efriedma]

Sorry about the delay, I got busy with other things.

lib/Analysis/TargetLibraryInfo.cpp

475

You probably also need to check T.isAndroid(), like the code above this. (I haven't actually checked what bionic provides, but I'm guessing it doesn't have all of these.)

lib/Transforms/Utils/SimplifyLibCalls.cpp

127

I think you also need to check if the call is marked nobuiltin.

test/Transforms/InstCombine/unlocked-stdio.ll

4 ↗

(On Diff #144437)

It would be nice to have at least some tests which call fclose (since otherwise you're leaking the file handle).

Needs some negative tests to make sure the capture checking is working correctly.

[xbolva00]

In D45736#1083561, @efriedma wrote:

Sorry about the delay, I got busy with other things.

Ok, no problem. I will fix your notes :)

[xbolva00]

lib/Analysis/TargetLibraryInfo.cpp

475

They will be available since Android P, so I will enable this for Android P and higher

https://android.googlesource.com/platform/bionic/+/master/docs/status.md

[xbolva00]

Fixed things.

[xbolva00]

This comment was removed by xbolva00.

[xbolva00]

Check if the call is NoBuiltin

[xbolva00]

Removed redundant check

lib/Transforms/Utils/SimplifyLibCalls.cpp

127

I added check but I now see that optimizeCall checks for this also.

Edit: removed nobuiltin check

[xbolva00]

friendly ping :) we are close with this patch to get it done

[xbolva00]

ping :)

[efriedma]

The code looks fine. But I'm a bit worried this could break in some cases. It's possible a user could define a function named fputc_unlocked, so we wouldn't accept a valid C program. And it's possible this could break some runtime instrumentation tools which haven't implemented the *_unlocked functions. Or someone could use some obscure C library on Linux which doesn't have all the glibc extensions and get surprised by a link error.

So I'm not sure what to do here; maybe get a second opinion on llvmdev?

[xbolva00]

In D45736#1092176, @efriedma wrote:

The code looks fine. But I'm a bit worried this could break in some cases. It's possible a user could define a function named fputc_unlocked, so we wouldn't accept a valid C program. And it's possible this could break some runtime instrumentation tools which haven't implemented the *_unlocked functions. Or someone could use some obscure C library on Linux which doesn't have all the glibc extensions and get surprised by a link error.

So I'm not sure what to do here; maybe get a second opinion on llvmdev?

We could check if e.g. fputc_unlocked is user defined in the current module, no?

Instrumentation tools are fixable, they would have to cover more functions but it is not a useless work - their analysis will just improve. I believe they would have to add some new cases to switch as a solution, etc.

Obscure C library: I believe if such C library, nobody would use Clang 7 on such system.

It would live in the trunk and it could be reverted in 7.0.1 if any major problems reported.

[xbolva00]

lib/Analysis/TargetLibraryInfo.cpp

474

if (T.isGNUEnvironment()) ?

[xbolva00]

So as a solution

if (isLinux && isGNU)?

[xbolva00]

Handle GNU extensions under isGNUEnvironment (same way as we do for sincos)

[xbolva00]

lib/Analysis/TargetLibraryInfo.cpp

474

@efriedma I updated patch to use the same way as we do for sincos - https://github.com/llvm-mirror/llvm/blob/af4d5d44bb6590140f7474323bbd11b78126a5be/lib/CodeGen/TargetLoweringBase.cpp#L164

[rja]

LGTM.

We should merge this patch to see the impact of this patch on real code bases. We can still revert it if too many problems.

[xbolva00]

Ping

[rja]

LG

[echristo]

In D45736#1096871, @rja wrote:

LGTM.

We should merge this patch to see the impact of this patch on real code bases. We can still revert it if too many problems.

We're definitely seeing problems here and I'm not sure if it's safe in general. Also, before committing we'd prefer that actual committers review patches - and I'm not seeing that you're an active committer to the project. If so, could you let us know who you are?

In particular, for this patch I think it should have gone to llvm-dev first as Eli suggested.

Thanks.

-eric

[xbolva00]

! In D45736#1103697, @echristo wrote:
We're definitely seeing problems here and I'm not sure if it's safe in general.

...

-eric

There was a llvm-dev thread. but only me, Eli and Han participated. There was a discussion that Linux && GNU check would be enough to be sure we have these unlocked functions.

Can you write here your problems?

The transformation logic is safe I think, we are sure via capture tracker that if fileptr cannot be captured & fileptr comes from fopen, we can use unlocked variants.

But I cannot do tests everywhere with every glibc versions, every XY system :)

And If almost nobody write comments (btw, I would like say thanks to Eli for advices not only in this patch) during review (and he wrote the code is OK), llvm-dev thread, we cannot do this transformation better, safer (?) ...

[echristo]

In D45736#1103716, @xbolva00 wrote:

! In D45736#1103697, @echristo wrote:
We're definitely seeing problems here and I'm not sure if it's safe in general.

...

-eric

There was a llvm-dev thread. but only me, Eli and Han participated. There was a discussion that Linux && GNU check would be enough to be sure we have these unlocked functions.

Can you write here your problems?

The transformation logic is safe I think, we are sure via capture tracker that if fileptr cannot be captured & fileptr comes from fopen, we can use unlocked variants.

But I cannot do tests everywhere with every glibc versions, every XY system :)

And If almost nobody write comments (btw, I would like say thanks to Eli for advices not only in this patch) during review (and he wrote the code is OK), llvm-dev thread, we cannot do this transformation better, safer (?) ...

Ben's fix and comment on the patch were the problems I was seeing. More so that no actual committer to the project approved - no one I've spoken to knows who rja is.

[xbolva00]

So please revert it and if possible, write here problems what this caused. Maybe it is possible to fix it.

[xbolva00]

This comment was removed by xbolva00.

[xbolva00]

Not sure about benchmarks, if there are any for C FILE IO. But in my tests and programs I see small improvements - yes, they read and write a lot from / to files.

Would you like to remove it?
... or make it off by default and provide option to turn this on if anybody wants?

[xbolva00]

This comment was removed by xbolva00.

include/llvm/Analysis/TargetLibraryInfo.def

 TLI_DEFINE_ENUM_INTERNAL(ffsl)
 TLI_DEFINE_STRING_INTERNAL("ffsl")
 /// int ffsll(long long int i);
 TLI_DEFINE_ENUM_INTERNAL(ffsll)
 TLI_DEFINE_STRING_INTERNAL("ffsll")
 /// int fgetc(FILE *stream);
 TLI_DEFINE_ENUM_INTERNAL(fgetc)
 TLI_DEFINE_STRING_INTERNAL("fgetc")
+/// int fgetc_unlocked(FILE *stream);
+TLI_DEFINE_ENUM_INTERNAL(fgetc_unlocked)
+TLI_DEFINE_STRING_INTERNAL("fgetc_unlocked")
 /// int fgetpos(FILE *stream, fpos_t *pos);
 TLI_DEFINE_ENUM_INTERNAL(fgetpos)
 TLI_DEFINE_STRING_INTERNAL("fgetpos")
 /// char *fgets(char *s, int n, FILE *stream);
 TLI_DEFINE_ENUM_INTERNAL(fgets)
 TLI_DEFINE_STRING_INTERNAL("fgets")
+/// char *fgets_unlocked(char *s, int n, FILE *stream);
+TLI_DEFINE_ENUM_INTERNAL(fgets_unlocked)
+TLI_DEFINE_STRING_INTERNAL("fgets_unlocked")
 /// int fileno(FILE *stream);
 TLI_DEFINE_ENUM_INTERNAL(fileno)
 TLI_DEFINE_STRING_INTERNAL("fileno")
 /// int fiprintf(FILE *stream, const char *format, ...);
 TLI_DEFINE_ENUM_INTERNAL(fiprintf)
 TLI_DEFINE_STRING_INTERNAL("fiprintf")
 /// void flockfile(FILE *file);
 TLI_DEFINE_ENUM_INTERNAL(flockfile)

 TLI_DEFINE_ENUM_INTERNAL(fopen64)
 TLI_DEFINE_STRING_INTERNAL("fopen64")
 /// int fprintf(FILE *stream, const char *format, ...);
 TLI_DEFINE_ENUM_INTERNAL(fprintf)
 TLI_DEFINE_STRING_INTERNAL("fprintf")
 /// int fputc(int c, FILE *stream);
 TLI_DEFINE_ENUM_INTERNAL(fputc)
 TLI_DEFINE_STRING_INTERNAL("fputc")
+/// int fputc_unlocked(int c, FILE *stream);
+TLI_DEFINE_ENUM_INTERNAL(fputc_unlocked)
+TLI_DEFINE_STRING_INTERNAL("fputc_unlocked")
 /// int fputs(const char *s, FILE *stream);
 TLI_DEFINE_ENUM_INTERNAL(fputs)
 TLI_DEFINE_STRING_INTERNAL("fputs")
+/// int fputs_unlocked(const char *s, FILE *stream);
+TLI_DEFINE_ENUM_INTERNAL(fputs_unlocked)
+TLI_DEFINE_STRING_INTERNAL("fputs_unlocked")
 /// size_t fread(void *ptr, size_t size, size_t nitems, FILE *stream);
 TLI_DEFINE_ENUM_INTERNAL(fread)
 TLI_DEFINE_STRING_INTERNAL("fread")
+/// size_t fread_unlocked(void *ptr, size_t size, size_t nitems, FILE *stream);
+TLI_DEFINE_ENUM_INTERNAL(fread_unlocked)
+TLI_DEFINE_STRING_INTERNAL("fread_unlocked")
 /// void free(void *ptr);
 TLI_DEFINE_ENUM_INTERNAL(free)
 TLI_DEFINE_STRING_INTERNAL("free")
 /// double frexp(double num, int *exp);
 TLI_DEFINE_ENUM_INTERNAL(frexp)
 TLI_DEFINE_STRING_INTERNAL("frexp")
 /// float frexpf(float num, int *exp);
 TLI_DEFINE_ENUM_INTERNAL(frexpf)

 TLI_DEFINE_ENUM_INTERNAL(ftrylockfile)
 TLI_DEFINE_STRING_INTERNAL("ftrylockfile")
 /// void funlockfile(FILE *file);
 TLI_DEFINE_ENUM_INTERNAL(funlockfile)
 TLI_DEFINE_STRING_INTERNAL("funlockfile")
 /// size_t fwrite(const void *ptr, size_t size, size_t nitems, FILE *stream);
 TLI_DEFINE_ENUM_INTERNAL(fwrite)
 TLI_DEFINE_STRING_INTERNAL("fwrite")
+/// size_t fwrite_unlocked(const void *ptr, size_t size, size_t nitems, FILE *stream);
+TLI_DEFINE_ENUM_INTERNAL(fwrite_unlocked)
+TLI_DEFINE_STRING_INTERNAL("fwrite_unlocked")
 /// int getc(FILE *stream);
 TLI_DEFINE_ENUM_INTERNAL(getc)
 TLI_DEFINE_STRING_INTERNAL("getc")
 /// int getc_unlocked(FILE *stream);
 TLI_DEFINE_ENUM_INTERNAL(getc_unlocked)
 TLI_DEFINE_STRING_INTERNAL("getc_unlocked")
 /// int getchar(void);
 TLI_DEFINE_ENUM_INTERNAL(getchar)
 TLI_DEFINE_STRING_INTERNAL("getchar")
+/// int getchar_unlocked(void);
+TLI_DEFINE_ENUM_INTERNAL(getchar_unlocked)
+TLI_DEFINE_STRING_INTERNAL("getchar_unlocked")
 /// char *getenv(const char *name);
 TLI_DEFINE_ENUM_INTERNAL(getenv)
 TLI_DEFINE_STRING_INTERNAL("getenv")
 /// int getitimer(int which, struct itimerval *value);
 TLI_DEFINE_ENUM_INTERNAL(getitimer)
 TLI_DEFINE_STRING_INTERNAL("getitimer")
 /// int getlogin_r(char *name, size_t namesize);
 TLI_DEFINE_ENUM_INTERNAL(getlogin_r)

 TLI_DEFINE_ENUM_INTERNAL(pread)
 TLI_DEFINE_STRING_INTERNAL("pread")
 /// int printf(const char *format, ...);
 TLI_DEFINE_ENUM_INTERNAL(printf)
 TLI_DEFINE_STRING_INTERNAL("printf")
 /// int putc(int c, FILE *stream);
 TLI_DEFINE_ENUM_INTERNAL(putc)
 TLI_DEFINE_STRING_INTERNAL("putc")
+/// int putc_unlocked(int c, FILE *stream);
+TLI_DEFINE_ENUM_INTERNAL(putc_unlocked)
+TLI_DEFINE_STRING_INTERNAL("putc_unlocked")
 /// int putchar(int c);
 TLI_DEFINE_ENUM_INTERNAL(putchar)
 TLI_DEFINE_STRING_INTERNAL("putchar")
+/// int putchar_unlocked(int c);
+TLI_DEFINE_ENUM_INTERNAL(putchar_unlocked)
+TLI_DEFINE_STRING_INTERNAL("putchar_unlocked")
 /// int puts(const char *s);
 TLI_DEFINE_ENUM_INTERNAL(puts)
 TLI_DEFINE_STRING_INTERNAL("puts")
 /// ssize_t pwrite(int fildes, const void *buf, size_t nbyte, off_t offset);
 TLI_DEFINE_ENUM_INTERNAL(pwrite)
 TLI_DEFINE_STRING_INTERNAL("pwrite")
 /// void qsort(void *base, size_t nel, size_t width,
 ///            int (*compar)(const void *, const void *));

include/llvm/Transforms/Utils/BuildLibCalls.h

namespace llvm {
   /// value with the same type. If 'Op1/Op2' are long double, 'l' is added as
   /// the suffix of name, if 'Op1/Op2' are float, we add a 'f' suffix.
   Value *emitBinaryFloatFnCall(Value *Op1, Value *Op2, StringRef Name,
                                IRBuilder<> &B, const AttributeList &Attrs);
 
   /// Emit a call to the putchar function. This assumes that Char is an integer.
   Value *emitPutChar(Value *Char, IRBuilder<> &B, const TargetLibraryInfo *TLI);
 
+  /// Emit a call to the putchar_unlocked function.
+  /// This assumes that Char is an integer.
+  Value *emitPutCharUnlocked(Value *Char, IRBuilder<> &B,
+                             const TargetLibraryInfo *TLI);
+
   /// Emit a call to the puts function. This assumes that Str is some pointer.
   Value *emitPutS(Value *Str, IRBuilder<> &B, const TargetLibraryInfo *TLI);
 
   /// Emit a call to the fputc function. This assumes that Char is an i32, and
   /// File is a pointer to FILE.
   Value *emitFPutC(Value *Char, Value *File, IRBuilder<> &B,
                    const TargetLibraryInfo *TLI);
 
-  /// Emit a call to the puts function. Str is required to be a pointer and
+  /// Emit a call to the fputc_unlocked function. This assumes that Char is an i32, and
+  /// File is a pointer to FILE.
+  Value *emitFPutCUnlocked(Value *Char, Value *File, IRBuilder<> &B,
+                   const TargetLibraryInfo *TLI);
+
+  /// Emit a call to the fputs function. Str is required to be a pointer and
   /// File is a pointer to FILE.
   Value *emitFPutS(Value *Str, Value *File, IRBuilder<> &B,
                    const TargetLibraryInfo *TLI);
 
+  /// Emit a call to the fputs_unlocked function. Str is required to be a
+  /// pointer and File is a pointer to FILE.
+  Value *emitFPutSUnlocked(Value *Str, Value *File, IRBuilder<> &B,
+                           const TargetLibraryInfo *TLI);
+
   /// Emit a call to the fwrite function. This assumes that Ptr is a pointer,
   /// Size is an 'intptr_t', and File is a pointer to FILE.
   Value *emitFWrite(Value *Ptr, Value *Size, Value *File, IRBuilder<> &B,
                     const DataLayout &DL, const TargetLibraryInfo *TLI);
+
+  /// Emit a call to the fwrite_unlocked function. This assumes that Ptr is a
+  /// pointer, Size is an 'intptr_t', and File is a pointer to FILE.
+  Value *emitFWriteUnlocked(Value *Ptr, Value *Size, Value *File,
+                            IRBuilder<> &B, const DataLayout &DL,
+                            const TargetLibraryInfo *TLI);
+
+  /// Emit a call to the fgetc_unlocked function. File is a pointer to FILE.
+  Value *emitFGetCUnlocked(Value *File, IRBuilder<> &B,
+                           const TargetLibraryInfo *TLI);
+
+  /// Emit a call to the getchar_unlocked function.
+  Value *emitGetCharUnlocked(IRBuilder<> &B, const TargetLibraryInfo *TLI);
+
+  /// Emit a call to the fgets_unlocked function. Str is required to be a
+  /// pointer, Size is an 'int' and File is a pointer to FILE.
+  Value *emitFGetSUnlocked(Value *Str, Value *Size, Value *File,
+                                 IRBuilder<> &B, const TargetLibraryInfo *TLI);
+
+  /// Emit a call to the fread_unlocked function. This assumes that Ptr is a
+  /// pointer, Size is an 'intptr_t', and File is a pointer to FILE.
+  Value *emitFReadUnlocked(Value *Ptr, Value *Size, Value *File, IRBuilder<> &B,
+                           const DataLayout &DL, const TargetLibraryInfo *TLI);
 }
 
 #endif

include/llvm/Transforms/Utils/SimplifyLibCalls.h

private:
 
   // Formatting and IO Library Call Optimizations
   Value *optimizeErrorReporting(CallInst *CI, IRBuilder<> &B,
                                 int StreamArg = -1);
   Value *optimizePrintF(CallInst *CI, IRBuilder<> &B);
   Value *optimizeSPrintF(CallInst *CI, IRBuilder<> &B);
   Value *optimizeFPrintF(CallInst *CI, IRBuilder<> &B);
   Value *optimizeFWrite(CallInst *CI, IRBuilder<> &B);
+  Value *optimizeFRead(CallInst *CI, IRBuilder<> &B);
   Value *optimizeFPuts(CallInst *CI, IRBuilder<> &B);
+  Value *optimizeFGets(CallInst *CI, IRBuilder<> &B);
+  Value *optimizeFPutc(CallInst *CI, IRBuilder<> &B);
+  Value *optimizeFGetc(CallInst *CI, IRBuilder<> &B);
+  Value *optimizePutChar(CallInst *CI, IRBuilder<> &B);
+  Value *optimizeGetChar(CallInst *CI, IRBuilder<> &B);
   Value *optimizePuts(CallInst *CI, IRBuilder<> &B);
 
   // Helper methods
   Value *emitStrLenMemCpy(Value *Src, Value *Dst, uint64_t Len, IRBuilder<> &B);
   void classifyArgUse(Value *Val, Function *F, bool IsFloat,
                       SmallVectorImpl<CallInst *> &SinCalls,
                       SmallVectorImpl<CallInst *> &CosCalls,
                       SmallVectorImpl<CallInst *> &SinCosCalls);

lib/Analysis/TargetLibraryInfo.cpp

if (T.isOSWindows() && !T.isOSCygMing()) {
     TLI.setUnavailable(LibFunc_flockfile);
     TLI.setUnavailable(LibFunc_fseeko);
     TLI.setUnavailable(LibFunc_fstat);
     TLI.setUnavailable(LibFunc_fstatvfs);
     TLI.setUnavailable(LibFunc_ftello);
     TLI.setUnavailable(LibFunc_ftrylockfile);
     TLI.setUnavailable(LibFunc_funlockfile);
     TLI.setUnavailable(LibFunc_getc_unlocked);
+    TLI.setUnavailable(LibFunc_getchar_unlocked);
+    TLI.setUnavailable(LibFunc_putc_unlocked);
+    TLI.setUnavailable(LibFunc_putchar_unlocked);
+    TLI.setUnavailable(LibFunc_fputc_unlocked);
+    TLI.setUnavailable(LibFunc_fgetc_unlocked);
+    TLI.setUnavailable(LibFunc_fread_unlocked);
+    TLI.setUnavailable(LibFunc_fwrite_unlocked);
+    TLI.setUnavailable(LibFunc_fputs_unlocked);
+    TLI.setUnavailable(LibFunc_fgets_unlocked);
     TLI.setUnavailable(LibFunc_getitimer);
     TLI.setUnavailable(LibFunc_getlogin_r);
     TLI.setUnavailable(LibFunc_getpwnam);
     TLI.setUnavailable(LibFunc_gettimeofday);
     TLI.setUnavailable(LibFunc_htonl);
     TLI.setUnavailable(LibFunc_htons);
     TLI.setUnavailable(LibFunc_lchown);
     TLI.setUnavailable(LibFunc_lstat);
if (!T.isOSLinux()) {
     TLI.setUnavailable(LibFunc_ftello64);
     TLI.setUnavailable(LibFunc_lstat64);
     TLI.setUnavailable(LibFunc_open64);
     TLI.setUnavailable(LibFunc_stat64);
     TLI.setUnavailable(LibFunc_statvfs64);
     TLI.setUnavailable(LibFunc_tmpfile64);
   }
 
   // As currently implemented in clang, NVPTX code has no standard library to
   // speak of.  Headers provide a standard-ish library implementation, but many
   // of the signatures are wrong -- for example, many libm functions are not
   // extern "C".
   //
   // libdevice, an IR library provided by nvidia, is linked in by the front-end,
   // but only used functions are provided to llvm.  Moreover, most of the
   // functions in libdevice don't map precisely to standard library functions.
   //
   // FIXME: Having no standard library prevents e.g. many fastmath
bool TargetLibraryInfoImpl::isValidProtoForLibFunc(const FunctionType &FTy,
   case LibFunc_chown:
   case LibFunc_clearerr:
   case LibFunc_closedir:
   case LibFunc_ctermid:
   case LibFunc_fclose:
   case LibFunc_feof:
   case LibFunc_fflush:
   case LibFunc_fgetc:
+  case LibFunc_fgetc_unlocked:
   case LibFunc_fileno:
   case LibFunc_flockfile:
   case LibFunc_free:
   case LibFunc_fseek:
   case LibFunc_fseeko64:
   case LibFunc_fseeko:
   case LibFunc_fsetpos:
   case LibFunc_ftell:
bool TargetLibraryInfoImpl::isValidProtoForLibFunc(const FunctionType &FTy,
   case LibFunc_fopen:
     return (NumParams == 2 && FTy.getReturnType()->isPointerTy() &&
             FTy.getParamType(0)->isPointerTy() &&
             FTy.getParamType(1)->isPointerTy());
   case LibFunc_fdopen:
     return (NumParams == 2 && FTy.getReturnType()->isPointerTy() &&
             FTy.getParamType(1)->isPointerTy());
   case LibFunc_fputc:
+  case LibFunc_fputc_unlocked:
   case LibFunc_fstat:
   case LibFunc_frexp:
   case LibFunc_frexpf:
   case LibFunc_frexpl:
   case LibFunc_fstatvfs:
     return (NumParams == 2 && FTy.getParamType(1)->isPointerTy());
   case LibFunc_fgets:
+  case LibFunc_fgets_unlocked:
     return (NumParams == 3 && FTy.getParamType(0)->isPointerTy() &&
             FTy.getParamType(2)->isPointerTy());
   case LibFunc_fread:
+  case LibFunc_fread_unlocked:
     return (NumParams == 4 && FTy.getParamType(0)->isPointerTy() &&
             FTy.getParamType(3)->isPointerTy());
   case LibFunc_fwrite:
+  case LibFunc_fwrite_unlocked:
     return (NumParams == 4 && FTy.getReturnType()->isIntegerTy() &&
             FTy.getParamType(0)->isPointerTy() &&
             FTy.getParamType(1)->isIntegerTy() &&
             FTy.getParamType(2)->isIntegerTy() &&
             FTy.getParamType(3)->isPointerTy());
   case LibFunc_fputs:
+  case LibFunc_fputs_unlocked:
     return (NumParams >= 2 && FTy.getParamType(0)->isPointerTy() &&
             FTy.getParamType(1)->isPointerTy());
   case LibFunc_fscanf:
   case LibFunc_fiprintf:
   case LibFunc_fprintf:
     return (NumParams >= 2 && FTy.getReturnType()->isIntegerTy() &&
             FTy.getParamType(0)->isPointerTy() &&
             FTy.getParamType(1)->isPointerTy());
   case LibFunc_fgetpos:
     return (NumParams >= 2 && FTy.getParamType(0)->isPointerTy() &&
             FTy.getParamType(1)->isPointerTy());
   case LibFunc_getchar:
+  case LibFunc_getchar_unlocked:
     return (NumParams == 0 && FTy.getReturnType()->isIntegerTy());
   case LibFunc_gets:
     return (NumParams == 1 && FTy.getParamType(0) == PCharTy);
   case LibFunc_getitimer:
     return (NumParams == 2 && FTy.getParamType(1)->isPointerTy());
   case LibFunc_ungetc:
     return (NumParams == 2 && FTy.getParamType(1)->isPointerTy());
   case LibFunc_utime:
   case LibFunc_utimes:
     return (NumParams == 2 && FTy.getParamType(0)->isPointerTy() &&
             FTy.getParamType(1)->isPointerTy());
   case LibFunc_putc:
+  case LibFunc_putc_unlocked:
     return (NumParams == 2 && FTy.getParamType(1)->isPointerTy());
   case LibFunc_pread:
   case LibFunc_pwrite:
     return (NumParams == 4 && FTy.getParamType(1)->isPointerTy());
   case LibFunc_popen:
     return (NumParams == 2 && FTy.getReturnType()->isPointerTy() &&
             FTy.getParamType(0)->isPointerTy() &&
             FTy.getParamType(1)->isPointerTy());
bool TargetLibraryInfoImpl::isValidProtoForLibFunc(const FunctionType &FTy,
   case LibFunc_flsll:
     return (NumParams == 1 && FTy.getReturnType()->isIntegerTy(32) &&
             FTy.getParamType(0)->isIntegerTy());
 
   case LibFunc_isdigit:
   case LibFunc_isascii:
   case LibFunc_toascii:
   case LibFunc_putchar:
+  case LibFunc_putchar_unlocked:
     return (NumParams == 1 && FTy.getReturnType()->isIntegerTy(32) &&
             FTy.getReturnType() == FTy.getParamType(0));
 
   case LibFunc_abs:
   case LibFunc_labs:
   case LibFunc_llabs:
     return (NumParams == 1 && FTy.getReturnType()->isIntegerTy() &&
             FTy.getReturnType() == FTy.getParamType(0));

lib/Transforms/Utils/BuildLibCalls.cpp

case LibFunc_fdopen:
     Changed |= setDoesNotCapture(F, 1);
     Changed |= setOnlyReadsMemory(F, 1);
     return Changed;
   case LibFunc_feof:
   case LibFunc_free:
   case LibFunc_fseek:
   case LibFunc_ftell:
   case LibFunc_fgetc:
+  case LibFunc_fgetc_unlocked:
   case LibFunc_fseeko:
   case LibFunc_ftello:
   case LibFunc_fileno:
   case LibFunc_fflush:
   case LibFunc_fclose:
   case LibFunc_fsetpos:
   case LibFunc_flockfile:
   case LibFunc_funlockfile:
   case LibFunc_ftrylockfile:
     Changed |= setDoesNotThrow(F);
     Changed |= setDoesNotCapture(F, 0);
     return Changed;
   case LibFunc_ferror:
     Changed |= setDoesNotThrow(F);
     Changed |= setDoesNotCapture(F, 0);
     Changed |= setOnlyReadsMemory(F);
     return Changed;
   case LibFunc_fputc:
+  case LibFunc_fputc_unlocked:
   case LibFunc_fstat:
   case LibFunc_frexp:
   case LibFunc_frexpf:
   case LibFunc_frexpl:
   case LibFunc_fstatvfs:
     Changed |= setDoesNotThrow(F);
     Changed |= setDoesNotCapture(F, 1);
     return Changed;
   case LibFunc_fgets:
+  case LibFunc_fgets_unlocked:
     Changed |= setDoesNotThrow(F);
     Changed |= setDoesNotCapture(F, 2);
     return Changed;
   case LibFunc_fread:
+  case LibFunc_fread_unlocked:
     Changed |= setDoesNotThrow(F);
     Changed |= setDoesNotCapture(F, 0);
     Changed |= setDoesNotCapture(F, 3);
     return Changed;
   case LibFunc_fwrite:
+  case LibFunc_fwrite_unlocked:
     Changed |= setDoesNotThrow(F);
     Changed |= setDoesNotCapture(F, 0);
     Changed |= setDoesNotCapture(F, 3);
     // FIXME: readonly #1?
     return Changed;
   case LibFunc_fputs:
+  case LibFunc_fputs_unlocked:
     Changed |= setDoesNotThrow(F);
     Changed |= setDoesNotCapture(F, 0);
     Changed |= setDoesNotCapture(F, 1);
     Changed |= setOnlyReadsMemory(F, 0);
     return Changed;
   case LibFunc_fscanf:
   case LibFunc_fprintf:
     Changed |= setDoesNotThrow(F);
     Changed |= setDoesNotCapture(F, 0);
     Changed |= setDoesNotCapture(F, 1);
     Changed |= setOnlyReadsMemory(F, 1);
     return Changed;
   case LibFunc_fgetpos:
     Changed |= setDoesNotThrow(F);
     Changed |= setDoesNotCapture(F, 0);
     Changed |= setDoesNotCapture(F, 1);
     return Changed;
   case LibFunc_getc:
-  case LibFunc_getlogin_r:
   case LibFunc_getc_unlocked:
+  case LibFunc_getlogin_r:
     Changed |= setDoesNotThrow(F);
     Changed |= setDoesNotCapture(F, 0);
     return Changed;
   case LibFunc_getenv:
     Changed |= setDoesNotThrow(F);
     Changed |= setOnlyReadsMemory(F);
     Changed |= setDoesNotCapture(F, 0);
     return Changed;
   case LibFunc_gets:
   case LibFunc_getchar:
+  case LibFunc_getchar_unlocked:
     Changed |= setDoesNotThrow(F);
     return Changed;
   case LibFunc_getitimer:
     Changed |= setDoesNotThrow(F);
     Changed |= setDoesNotCapture(F, 1);
     return Changed;
   case LibFunc_getpwnam:
     Changed |= setDoesNotThrow(F);
bool llvm::inferLibFuncAttributes(Function &F, const TargetLibraryInfo &TLI) {
   case LibFunc_utimes:
     Changed |= setDoesNotThrow(F);
     Changed |= setDoesNotCapture(F, 0);
     Changed |= setDoesNotCapture(F, 1);
     Changed |= setOnlyReadsMemory(F, 0);
     Changed |= setOnlyReadsMemory(F, 1);
     return Changed;
   case LibFunc_putc:
+  case LibFunc_putc_unlocked:
     Changed |= setDoesNotThrow(F);
     Changed |= setDoesNotCapture(F, 1);
     return Changed;
   case LibFunc_puts:
   case LibFunc_printf:
   case LibFunc_perror:
     Changed |= setDoesNotThrow(F);
     Changed |= setDoesNotCapture(F, 0);
     Changed |= setOnlyReadsMemory(F, 0);
     return Changed;
   case LibFunc_pread:
     // May throw; "pread" is a valid pthread cancellation point.
     Changed |= setDoesNotCapture(F, 1);
     return Changed;
   case LibFunc_pwrite:
     // May throw; "pwrite" is a valid pthread cancellation point.
     Changed |= setDoesNotCapture(F, 1);
     Changed |= setOnlyReadsMemory(F, 1);
     return Changed;
   case LibFunc_putchar:
+  case LibFunc_putchar_unlocked:
     Changed |= setDoesNotThrow(F);
     return Changed;
   case LibFunc_popen:
     Changed |= setDoesNotThrow(F);
     Changed |= setRetDoesNotAlias(F);
     Changed |= setDoesNotCapture(F, 0);
     Changed |= setDoesNotCapture(F, 1);
     Changed |= setOnlyReadsMemory(F, 0);
CallInst *CI = B.CreateCall(PutChar,
                               "chari"),
                               "putchar");
 
   if (const Function *F = dyn_cast<Function>(PutChar->stripPointerCasts()))
     CI->setCallingConv(F->getCallingConv());
   return CI;
 }
 
+Value *llvm::emitPutCharUnlocked(Value *Char, IRBuilder<> &B,
+                                 const TargetLibraryInfo *TLI) {
+  if (!TLI->has(LibFunc_putchar_unlocked))
+    return nullptr;
+
+  Module *M = B.GetInsertBlock()->getModule();
+  Value *PutCharUnlocked = M->getOrInsertFunction(
+      "putchar_unlocked", B.getInt32Ty(), B.getInt32Ty());
+  inferLibFuncAttributes(*M->getFunction("putchar_unlocked"), *TLI);
+  CallInst *CI = B.CreateCall(PutCharUnlocked,
+                              B.CreateIntCast(Char, B.getInt32Ty(),
+                                              /*isSigned*/ true, "chari"),
+                              "putchar_unlocked");
+
+  if (const Function *F =
+          dyn_cast<Function>(PutCharUnlocked->stripPointerCasts()))
+    CI->setCallingConv(F->getCallingConv());
+  return CI;
+}
+
 Value *llvm::emitPutS(Value *Str, IRBuilder<> &B,
                       const TargetLibraryInfo *TLI) {
   if (!TLI->has(LibFunc_puts))
     return nullptr;
 
   Module *M = B.GetInsertBlock()->getModule();
   Value *PutS =
       M->getOrInsertFunction("puts", B.getInt32Ty(), B.getInt8PtrTy());
Char = B.CreateIntCast(Char, B.getInt32Ty(), /*isSigned*/true,
                          "chari");
   CallInst *CI = B.CreateCall(F, {Char, File}, "fputc");
 
   if (const Function *Fn = dyn_cast<Function>(F->stripPointerCasts()))
     CI->setCallingConv(Fn->getCallingConv());
   return CI;
 }
 
+Value *llvm::emitFPutCUnlocked(Value *Char, Value *File, IRBuilder<> &B,
+                               const TargetLibraryInfo *TLI) {
+  if (!TLI->has(LibFunc_fputc_unlocked))
+    return nullptr;
+
+  Module *M = B.GetInsertBlock()->getModule();
+  Constant *F = M->getOrInsertFunction("fputc_unlocked", B.getInt32Ty(),
+                                       B.getInt32Ty(), File->getType());
+  if (File->getType()->isPointerTy())
+    inferLibFuncAttributes(*M->getFunction("fputc_unlocked"), *TLI);
+  Char = B.CreateIntCast(Char, B.getInt32Ty(), /*isSigned*/ true, "chari");
+  CallInst *CI = B.CreateCall(F, {Char, File}, "fputc_unlocked");
+
+  if (const Function *Fn = dyn_cast<Function>(F->stripPointerCasts()))
+    CI->setCallingConv(Fn->getCallingConv());
+  return CI;
+}
+
 Value *llvm::emitFPutS(Value *Str, Value *File, IRBuilder<> &B,
                        const TargetLibraryInfo *TLI) {
   if (!TLI->has(LibFunc_fputs))
     return nullptr;
 
   Module *M = B.GetInsertBlock()->getModule();
   StringRef FPutsName = TLI->getName(LibFunc_fputs);
   Constant *F = M->getOrInsertFunction(
       FPutsName, B.getInt32Ty(), B.getInt8PtrTy(), File->getType());
   if (File->getType()->isPointerTy())
     inferLibFuncAttributes(*M->getFunction(FPutsName), *TLI);
   CallInst *CI = B.CreateCall(F, {castToCStr(Str, B), File}, "fputs");
 
   if (const Function *Fn = dyn_cast<Function>(F->stripPointerCasts()))
     CI->setCallingConv(Fn->getCallingConv());
   return CI;
 }
 
+Value *llvm::emitFPutSUnlocked(Value *Str, Value *File, IRBuilder<> &B,
+                               const TargetLibraryInfo *TLI) {
+  if (!TLI->has(LibFunc_fputs_unlocked))
+    return nullptr;
+
+  Module *M = B.GetInsertBlock()->getModule();
+  StringRef FPutsUnlockedName = TLI->getName(LibFunc_fputs_unlocked);
+  Constant *F = M->getOrInsertFunction(FPutsUnlockedName, B.getInt32Ty(),
+                                       B.getInt8PtrTy(), File->getType());
+  if (File->getType()->isPointerTy())
+    inferLibFuncAttributes(*M->getFunction(FPutsUnlockedName), *TLI);
+  CallInst *CI = B.CreateCall(F, {castToCStr(Str, B), File}, "fputs_unlocked");
+
+  if (const Function *Fn = dyn_cast<Function>(F->stripPointerCasts()))
+    CI->setCallingConv(Fn->getCallingConv());
+  return CI;
+}
+
 Value *llvm::emitFWrite(Value *Ptr, Value *Size, Value *File, IRBuilder<> &B,
                         const DataLayout &DL, const TargetLibraryInfo *TLI) {
   if (!TLI->has(LibFunc_fwrite))
     return nullptr;
 
   Module *M = B.GetInsertBlock()->getModule();
   LLVMContext &Context = B.GetInsertBlock()->getContext();
   StringRef FWriteName = TLI->getName(LibFunc_fwrite);
   Constant *F = M->getOrInsertFunction(
       FWriteName, DL.getIntPtrType(Context), B.getInt8PtrTy(),
       DL.getIntPtrType(Context), DL.getIntPtrType(Context), File->getType());
 
   if (File->getType()->isPointerTy())
     inferLibFuncAttributes(*M->getFunction(FWriteName), *TLI);
   CallInst *CI =
       B.CreateCall(F, {castToCStr(Ptr, B), Size,
                        ConstantInt::get(DL.getIntPtrType(Context), 1), File});
 
   if (const Function *Fn = dyn_cast<Function>(F->stripPointerCasts()))
     CI->setCallingConv(Fn->getCallingConv());
   return CI;
 }
+
+Value *llvm::emitFWriteUnlocked(Value *Ptr, Value *Size, Value *File,
+                                IRBuilder<> &B, const DataLayout &DL,
+                                const TargetLibraryInfo *TLI) {
+  if (!TLI->has(LibFunc_fwrite_unlocked))
+    return nullptr;
+
+  Module *M = B.GetInsertBlock()->getModule();
+  LLVMContext &Context = B.GetInsertBlock()->getContext();
+  StringRef FWriteUnlockedName = TLI->getName(LibFunc_fwrite_unlocked);
+  Constant *F = M->getOrInsertFunction(
+      FWriteUnlockedName, DL.getIntPtrType(Context), B.getInt8PtrTy(),
+      DL.getIntPtrType(Context), DL.getIntPtrType(Context), File->getType());
+
+  if (File->getType()->isPointerTy())
+    inferLibFuncAttributes(*M->getFunction(FWriteUnlockedName), *TLI);
+  CallInst *CI =
+      B.CreateCall(F,
+                   {castToCStr(Ptr, B), Size,
+                    ConstantInt::get(DL.getIntPtrType(Context), 1), File});
+
+  if (const Function *Fn = dyn_cast<Function>(F->stripPointerCasts()))
+    CI->setCallingConv(Fn->getCallingConv());
+  return CI;
+}
+
+Value *llvm::emitFGetCUnlocked(Value *File, IRBuilder<> &B,
+                               const TargetLibraryInfo *TLI) {
+  if (!TLI->has(LibFunc_fgetc_unlocked))
+    return nullptr;
+
+  Module *M = B.GetInsertBlock()->getModule();
+  Constant *F =
+      M->getOrInsertFunction("fgetc_unlocked", B.getInt32Ty(), File->getType());
+  if (File->getType()->isPointerTy())
+    inferLibFuncAttributes(*M->getFunction("fgetc_unlocked"), *TLI);
+  CallInst *CI = B.CreateCall(F, File, "fgetc_unlocked");
+
+  if (const Function *Fn = dyn_cast<Function>(F->stripPointerCasts()))
+    CI->setCallingConv(Fn->getCallingConv());
+  return CI;
+}
+
+Value *llvm::emitGetCharUnlocked(IRBuilder<> &B, const TargetLibraryInfo *TLI) {
+  if (!TLI->has(LibFunc_getchar_unlocked))
+    return nullptr;
+
+  Module *M = B.GetInsertBlock()->getModule();
+  Constant *F = M->getOrInsertFunction("getchar_unlocked", B.getInt32Ty());
+  inferLibFuncAttributes(*M->getFunction("getchar_unlocked"), *TLI);
+  CallInst *CI = B.CreateCall(F, {}, "getchar_unlocked");
+
+  if (const Function *Fn = dyn_cast<Function>(F->stripPointerCasts()))
+    CI->setCallingConv(Fn->getCallingConv());
+  return CI;
+}
+
+Value *llvm::emitFGetSUnlocked(Value *Str, Value *Size, Value *File,
+                               IRBuilder<> &B, const TargetLibraryInfo *TLI) {
+  if (!TLI->has(LibFunc_fgets_unlocked))
+    return nullptr;
+
+  Module *M = B.GetInsertBlock()->getModule();
+  Constant *F =
+      M->getOrInsertFunction("fgets_unlocked", B.getInt32Ty(), B.getInt8PtrTy(),
+                             B.getInt32Ty(), File->getType());
+  inferLibFuncAttributes(*M->getFunction("fgets_unlocked"), *TLI);
+  CallInst *CI =
+      B.CreateCall(F, {castToCStr(Str, B), Size, File}, "fgets_unlocked");
+
+  if (const Function *Fn = dyn_cast<Function>(F->stripPointerCasts()))
+    CI->setCallingConv(Fn->getCallingConv());
+  return CI;
+}
+
+Value *llvm::emitFReadUnlocked(Value *Ptr, Value *Size, Value *File,
+                               IRBuilder<> &B, const DataLayout &DL,
+                               const TargetLibraryInfo *TLI) {
+  if (!TLI->has(LibFunc_fread_unlocked))
+    return nullptr;
+
+  Module *M = B.GetInsertBlock()->getModule();
+  LLVMContext &Context = B.GetInsertBlock()->getContext();
+  StringRef FReadUnlockedName = TLI->getName(LibFunc_fread_unlocked);
+  Constant *F = M->getOrInsertFunction(
+      FReadUnlockedName, DL.getIntPtrType(Context), B.getInt8PtrTy(),
+      DL.getIntPtrType(Context), DL.getIntPtrType(Context), File->getType());
+
+  if (File->getType()->isPointerTy())
+    inferLibFuncAttributes(*M->getFunction(FReadUnlockedName), *TLI);
+  CallInst *CI =
+      B.CreateCall(F,
+                   {castToCStr(Ptr, B), Size,
+                    ConstantInt::get(DL.getIntPtrType(Context), 1), File});
+
+  if (const Function *Fn = dyn_cast<Function>(F->stripPointerCasts()))
+    CI->setCallingConv(Fn->getCallingConv());
+  return CI;
+}
 No newline at end of file

lib/Transforms/Utils/SimplifyLibCalls.cpp

 #include "llvm/Transforms/Utils/SimplifyLibCalls.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/Analysis/ConstantFolding.h"
 #include "llvm/Analysis/OptimizationRemarkEmitter.h"
 #include "llvm/Analysis/TargetLibraryInfo.h"
 #include "llvm/Analysis/ValueTracking.h"
+#include "llvm/Analysis/CaptureTracking.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/IntrinsicInst.h"
 #include "llvm/IR/Intrinsics.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/PatternMatch.h"
case Type::FloatTyID:
     return TLI->has(FloatFn);
   case Type::DoubleTyID:
     return TLI->has(DoubleFn);
   default:
     return TLI->has(LongDoubleFn);
   }
 }
 
+static bool isReplaceableWithUnlockedVariant(CallInst *CI, IRBuilder<> &B,
+                                             const TargetLibraryInfo *TLI) {
+  if (!CI->getFunction()->hasInternalLinkage())
+    return false;
+
+  inferLibFuncAttributes(*CI->getCalledFunction(), *TLI);
+  for (unsigned i = 1; i < CI->getNumArgOperands(); ++i) {
+    Value *Op = CI->getArgOperand(i);
+    if (Op->getType()->isPointerTy() && !isa<GlobalValue>(Op)) {
+      if (PointerMayBeCaptured(Op, true, true))
+        return false;
+    }
+  }
+
+  return true;
+}
+
 //===----------------------------------------------------------------------===//
 // String and Memory Library Call Optimizations
 //===----------------------------------------------------------------------===//
 
 Value *LibCallSimplifier::optimizeStrCat(CallInst *CI, IRBuilder<> &B) {
   // Extract some information from the instruction
   Value *Dst = CI->getArgOperand(0);
   Value *Src = CI->getArgOperand(1);

 }
 
 Value *LibCallSimplifier::optimizeFWrite(CallInst *CI, IRBuilder<> &B) {
   optimizeErrorReporting(CI, B, 3);
 
   // Get the element size and count.
   ConstantInt *SizeC = dyn_cast<ConstantInt>(CI->getArgOperand(1));
   ConstantInt *CountC = dyn_cast<ConstantInt>(CI->getArgOperand(2));
-  if (!SizeC || !CountC)
-    return nullptr;
+  if (SizeC && CountC) {
     uint64_t Bytes = SizeC->getZExtValue() * CountC->getZExtValue();
 
     // If this is writing zero records, remove the call (it's a noop).
     if (Bytes == 0)
       return ConstantInt::get(CI->getType(), 0);
 
     // If this is writing one byte, turn it into fputc.
     // This optimisation is only valid, if the return value is unused.
     if (Bytes == 1 && CI->use_empty()) { // fwrite(S,1,1,F) -> fputc(S[0],F)
       Value *Char = B.CreateLoad(castToCStr(CI->getArgOperand(0), B), "char");
       Value *NewCI = emitFPutC(Char, CI->getArgOperand(3), B, TLI);
       return NewCI ? ConstantInt::get(CI->getType(), 1) : nullptr;
     }
+  }
+
+  if (isReplaceableWithUnlockedVariant(CI, B, TLI))
+    return emitFWriteUnlocked(CI->getArgOperand(0), CI->getArgOperand(1),
+                              CI->getArgOperand(2), B, DL, TLI);
 
   return nullptr;
 }
 
 Value *LibCallSimplifier::optimizeFPuts(CallInst *CI, IRBuilder<> &B) {
   optimizeErrorReporting(CI, B, 1);
 
   // Don't rewrite fputs to fwrite when optimising for size because fwrite
   // requires more arguments and thus extra MOVs are required.
   if (CI->getParent()->getParent()->optForSize())
     return nullptr;
 
+  if (CI->use_empty()) {
+    if (isReplaceableWithUnlockedVariant(CI, B, TLI))
+      return emitFPutSUnlocked(CI->getArgOperand(0), CI->getArgOperand(1), B,
+                               TLI);
+    else
       // We can't optimize if return value is used.
-  if (!CI->use_empty())
       return nullptr;
+  }
 
   // fputs(s,F) --> fwrite(s,1,strlen(s),F)
   uint64_t Len = GetStringLength(CI->getArgOperand(0));
   if (!Len)
     return nullptr;
 
   // Known to have no uses (see above).
   return emitFWrite(
       CI->getArgOperand(0),
       ConstantInt::get(DL.getIntPtrType(CI->getContext()), Len - 1),
       CI->getArgOperand(1), B, DL, TLI);
 }
 
+Value *LibCallSimplifier::optimizeFPutc(CallInst *CI, IRBuilder<> &B) {
+  optimizeErrorReporting(CI, B, 1);
+
+  if (isReplaceableWithUnlockedVariant(CI, B, TLI))
+    return emitFPutCUnlocked(CI->getArgOperand(0), CI->getArgOperand(1), B,
+                             TLI);
+
+  return nullptr;
+}
+
+Value *LibCallSimplifier::optimizeFGetc(CallInst *CI, IRBuilder<> &B) {
+  if (isReplaceableWithUnlockedVariant(CI, B, TLI))
+    return emitFGetCUnlocked(CI->getArgOperand(0), B, TLI);
+
+  return nullptr;
+}
+
+Value *LibCallSimplifier::optimizePutChar(CallInst *CI, IRBuilder<> &B) {
+  if (isReplaceableWithUnlockedVariant(CI, B, TLI))
+    return emitPutCharUnlocked(CI->getArgOperand(0), B, TLI);
+
+  return nullptr;
+}
+
+Value *LibCallSimplifier::optimizeGetChar(CallInst *CI, IRBuilder<> &B) {
+  if (isReplaceableWithUnlockedVariant(CI, B, TLI))
+    return emitGetCharUnlocked(B, TLI);
+
+  return nullptr;
+}
+
+Value *LibCallSimplifier::optimizeFGets(CallInst *CI, IRBuilder<> &B) {
+  if (isReplaceableWithUnlockedVariant(CI, B, TLI))
+    return emitFGetSUnlocked(CI->getArgOperand(0), CI->getArgOperand(1), CI->getArgOperand(2), B, TLI);
+
+  return nullptr;
+}
+
+Value *LibCallSimplifier::optimizeFRead(CallInst *CI, IRBuilder<> &B) {
+  if (isReplaceableWithUnlockedVariant(CI, B, TLI))
+    return emitFReadUnlocked(CI->getArgOperand(0), CI->getArgOperand(1),
+                             CI->getArgOperand(2), B, DL, TLI);
+
+  return nullptr;
+}
+
 Value *LibCallSimplifier::optimizePuts(CallInst *CI, IRBuilder<> &B) {
   // Check for a constant string.
   StringRef Str;
   if (!getConstantStringInfo(CI->getArgOperand(0), Str))
     return nullptr;
 
   if (Str.empty() && CI->use_empty()) {
     // puts("") -> putchar('\n')
if (TLI->getLibFunc(*Callee, Func) && TLI->has(Func)) {
     case LibFunc_printf:
       return optimizePrintF(CI, Builder);
     case LibFunc_sprintf:
       return optimizeSPrintF(CI, Builder);
     case LibFunc_fprintf:
       return optimizeFPrintF(CI, Builder);
     case LibFunc_fwrite:
       return optimizeFWrite(CI, Builder);
+    case LibFunc_fread:
+      return optimizeFRead(CI, Builder);
     case LibFunc_fputs:
       return optimizeFPuts(CI, Builder);
+    case LibFunc_fgets:
+      return optimizeFGets(CI, Builder);
+    case LibFunc_fputc:
+    case LibFunc_putc:
+      return optimizeFPutc(CI, Builder);
+    case LibFunc_fgetc:
+    case LibFunc_getc:
+      return optimizeFGetc(CI, Builder);
     case LibFunc_puts:
       return optimizePuts(CI, Builder);
+    case LibFunc_putchar:
+      return optimizePutChar(CI, Builder);
+    case LibFunc_getchar:
+      return optimizeGetChar(CI, Builder);
     case LibFunc_perror:
       return optimizeErrorReporting(CI, Builder);
     case LibFunc_vfprintf:
     case LibFunc_fiprintf:
       return optimizeErrorReporting(CI, Builder, 0);
-    case LibFunc_fputc:
-      return optimizeErrorReporting(CI, Builder, 1);
     default:
       return nullptr;
     }
   }
   return nullptr;
 }
 
 LibCallSimplifier::LibCallSimplifier(