[LibCalls] Add argument extension attributes to more functions.

[jonpa]

Summary

This continues the work of having inferLibFuncAttributes() add the right extension attribute to i32 arguments (as started with https://reviews.llvm.org/D123030).

As far as I can tell this covers all the remaining functions handled in inferLibFuncAttributes() that is present on SystemZ (there may however still be more library functions not yet handled there per the comment in the bottom.).

Notes:

@under_IO_putc(i32, %opaque*) is not present on SystemZ and not handled.

@memset_chk(i8*, i32, i64, i64) is also not present/handled, but @__memset_chk() is, which I am not sure is correct....

[efriedma]

llvm/lib/Transforms/Utils/BuildLibCalls.cpp

607

Are uid_t/gid_t unsigned on all targets?

(I wouldn't mind just dropping LibFunc recognition for chown etc. if necessary...)

[efriedma]

@under_IO_putc(i32, %opaque*) is not present on SystemZ and not handled.

This has the same signature as putc; please fix while you're here.

@memset_chk(i8*, i32, i64, i64) is also not present/handled, but @__memset_chk() is, which I am not sure is correct....

LibFunc_memset_chk refers to __memset_chk; see TargetLibraryInfo.def. I don't think memset_chk is a thing.

[jonpa]

Patch updated per review (see inline commenting).

@under_IO_putc(i32, %opaque*) is not present on SystemZ and not handled.

This has the same signature as putc; please fix while you're here.

OK - it is now under the same switch case as putc (although still untested in annotate.ll as before). I also moved under_IO_getc into the getc handling as they are also identical.

llvm/lib/Transforms/Utils/BuildLibCalls.cpp

607

I see your point: since uid_t/gid_t (as far as I could see) are either unsigned or signed we cannot have a generic BuildLibCall utility for them with the current implementation.

If this is needed it seems to me we would need to add a target based flag similar to ShouldExtI32Param for this to properly determine the types of uid_t and gid_t.

All tests are however now passing after removing chown and lchown, so I did this instead now per your suggestion.

[xbolva00]

Previously, the SExt attribute was always added to the i32 ldexp* argument as it was expected to be ignored by targets not needing it. This patch now changes this so that it is only added for the targets that need it in the first place.

So required? required for correctness? Then is this right place to add them? With -O0, you will not get these attributes, no?

[xbolva00]

llvm/lib/Transforms/Utils/BuildLibCalls.cpp

607

Why do you need to drop it all? You added nothing so how this blocks you now?

llvm/test/Transforms/InferFunctionAttrs/annotate.ll

318

Do not remove test coverage.

[jonpa]

llvm/lib/Transforms/Utils/BuildLibCalls.cpp

607

It doesn't seem right to keep incorrect prototypes around if they are not fixed.

llvm/test/Transforms/InferFunctionAttrs/annotate.ll

318

see above

[xbolva00]

llvm/lib/Transforms/Utils/BuildLibCalls.cpp

607

So it would be better to fix it properly.

Somebody in the future may reintroduce handling of chown…

[xbolva00]

In D123198#3440759, @xbolva00 wrote:

Previously, the SExt attribute was always added to the i32 ldexp* argument as it was expected to be ignored by targets not needing it. This patch now changes this so that it is only added for the targets that need it in the first place.

So required? required for correctness? Then is this right place to add them? With -O0, you will not get these attributes, no?

^

[jonpa]

In D123198#3440759, @xbolva00 wrote:

Previously, the SExt attribute was always added to the i32 ldexp* argument as it was expected to be ignored by targets not needing it. This patch now changes this so that it is only added for the targets that need it in the first place.

So required? required for correctness? Then is this right place to add them? With -O0, you will not get these attributes, no?

Yes, required for correctness. The SystemZ ABI says that any integer argument less than 64 bits should be extended as appropriate (sext/zext) by the caller. If this is not done, wrong-code may result, and it has nothing to do with optimization levels.
See https://reviews.llvm.org/D112942 with (link to) discussion.

[jonpa]

llvm/lib/Transforms/Utils/BuildLibCalls.cpp

607

Eli wrote he thought we could remove them which made sense to me given the issue with uid_t/gid_t...

Do you see a need for them here to motivate adding a recogniziton of uid_t/gid_t types signedness per target?

Since no tests fail if they are removed (other than the immediate annotate.ll test), I thought this could be done later if needed...

@efriedma : I now actually wonder if you meant that these functions be removed also in TargetLibraryInfo.def and other places..?

[xbolva00]

In D123198#3440784, @jonpa wrote:

In D123198#3440759, @xbolva00 wrote:

Previously, the SExt attribute was always added to the i32 ldexp* argument as it was expected to be ignored by targets not needing it. This patch now changes this so that it is only added for the targets that need it in the first place.

So required? required for correctness? Then is this right place to add them? With -O0, you will not get these attributes, no?

Yes, required for correctness. The SystemZ ABI says that any integer argument less than 64 bits should be extended as appropriate (sext/zext) by the caller. If this is not done, wrong-code may result, and it has nothing to do with optimization levels.
See https://reviews.llvm.org/D112942 with (link to) discussion.

BuildLibCalls does not run under -O0 afaik .. so you wont get these attrs. So I dont think this is a correct place if my assumption holds.

[xbolva00]

And I also think that things will break for you if somebody uses eg. -fno-builtin-memccpy .. you will not get this ext attribute.

[jonpa]

BuildLibCalls does not run under -O0 afaik .. so you wont get these attrs. So I dont think this is a correct place if my assumption holds.

I am quite sure there are more places to handle, but fixing BuildLibCalls seems like a step in the right direction, wouldn't you agree? This is an existing problem we are trying to fix by carefully finding and handling all call sites throughout the code base.

And I also think that things will break for you if somebody uses eg. -fno-builtin-memccpy .. you will not get this ext attribute.

I would be very grateful if you helped with this work by filing bug reports with test cases, and maybe even patches...

[xbolva00]

In D123198#3442063, @jonpa wrote:

BuildLibCalls does not run under -O0 afaik .. so you wont get these attrs. So I dont think this is a correct place if my assumption holds.

I am quite sure there are more places to handle, but fixing BuildLibCalls seems like a step in the right direction, wouldn't you agree? This is an existing problem we are trying to fix by carefully finding and handling all call sites throughout the code base.

I dont stiĺ think this is a correct place.

If this attribute is required for correctness, you should write simple pass which adds this atrribute very soon in pipeline and runs even under -O0. Or @efriedma may propose something…

And I also think that things will break for you if somebody uses eg. -fno-builtin-memccpy .. you will not get this ext attribute.

I would be very grateful if you helped with this work by filing bug reports with test cases, and maybe even patches...

This is by design - if -ifno-builtin-xxx is used, a libcall is not annotated with any attribute here. This works fine and you are misusing BuildLibCalls and the solution is not to change when and how BuildLibCalls runs.

[nikic]

I think there is a bit of confusion here, because this code (inferLibFuncAttributes) is used for two purposes: To add attributes to existing libcalls, and to add attributes to newly created libcalls. Adding signext/zeroext attributes is not necessary for existing libcalls, because this is a frontend responsibility -- if these attributes are absent (but are required by ABI) then that is a bug in the frontend, and there is no requirement for LLVM to "fix" that problem (though it also doesn't hurt if it does). On the other hand, if LLVM introduces new libcalls, then it is LLVM's responsibility to add necessary signext/zeroext attributes.

If we wanted to make that clearer, we could separate out this part to only add these attributes when creating new libcalls. That should also make it obvious that it's fine that this code doesn't run under O0, because we only care about libcalls introduced by optimizations.

[jonpa]

I dont stiĺ think this is a correct place.

If this attribute is required for correctness, you should write simple pass which adds this atrribute very soon in pipeline and runs even under -O0. Or @efriedma may propose something…

It is not a question if it is required for correctness or not (even though not all targets have this in their ABIs). The SystemZ Clang Front End does this already, so there should not be any need for an early pass to do this. Basically all front ends emitting code for SystemZ are obliged to annotate call parameters with the proper extension attribute, but that is not what this patch is handling.

This is by design - if -ifno-builtin-xxx is used, a libcall is not annotated with any attribute here. This works fine and you are misusing BuildLibCalls and the solution is not to change when and how BuildLibCalls runs.

I would hope that with -fno-builtin the original call would be already be correctly emitted by Clang (if not, that's the place to fix it probably).

I don't understand your objections to this patch. I am not changing when or how BuildLibCalls is used, merely making sure it adds the needed parameter attributes for the targets that need it. If your concern is about chown() and lchown(), let's see what Eli has to say about that...

[xbolva00]

In D123198#3442063, @jonpa wrote:

BuildLibCalls does not run under -O0 afaik .. so you wont get these attrs. So I dont think this is a correct place if my assumption holds.

I am quite sure there are more places to handle, but fixing BuildLibCalls seems like a step in the right direction, wouldn't you agree? This is an existing problem we are trying to fix by carefully finding and handling all call sites throughout the code base.

I dont stiĺ think this is a correct place.

If this attribute is required for correctness, you should write simple pass which adds this atrribute very soon in pipeline and runs even under -O0. Or @efriedma may propose something…

And I also think that things will break for you if somebody uses eg. -fno-builtin-memccpy .. you will not get this ext attribute.

I would be very grateful if you helped with this work by filing bug reports with test cases, and maybe even patches...

This is by design - if -ifno-builtin-xxx is used, a libcall is not annotated with any attribute here. This works fine and you are misusing BuildLibCalls and the solution is not to change when and how BuildLibCalls runs.

In D123198#3442133, @jonpa wrote:

I dont stiĺ think this is a correct place.

If this attribute is required for correctness, you should write simple pass which adds this atrribute very soon in pipeline and runs even under -O0. Or @efriedma may propose something…

It is not a question if it is required for correctness or not (even though not all targets have this in their ABIs). The SystemZ Clang Front End does this already, so there should not be any need for an early pass to do this. Basically all front ends emitting code for SystemZ are obliged to annotate call parameters with the proper extension attribute, but that is not what this patch is handling.

This is by design - if -ifno-builtin-xxx is used, a libcall is not annotated with any attribute here. This works fine and you are misusing BuildLibCalls and the solution is not to change when and how BuildLibCalls runs.

I would hope that with -fno-builtin the original call would be already be correctly emitted by Clang (if not, that's the place to fix it probably).

I don't understand your objections to this patch. I am not changing when or how BuildLibCalls is used, merely making sure it adds the needed parameter attributes for the targets that need it. If your concern is about chown() and lchown(), let's see what Eli has to say about that...

Thanks, it makes more sense now. But info like this info should be in patch description to better understand the whole problem.

[xbolva00]

In D123198#3442121, @nikic wrote:

I think there is a bit of confusion here, because this code (inferLibFuncAttributes) is used for two purposes: To add attributes to existing libcalls, and to add attributes to newly created libcalls. Adding signext/zeroext attributes is not necessary for existing libcalls, because this is a frontend responsibility -- if these attributes are absent (but are required by ABI) then that is a bug in the frontend, and there is no requirement for LLVM to "fix" that problem (though it also doesn't hurt if it does). On the other hand, if LLVM introduces new libcalls, then it is LLVM's responsibility to add necessary signext/zeroext attributes.

If we wanted to make that clearer, we could separate out this part to only add these attributes when creating new libcalls. That should also make it obvious that it's fine that this code doesn't run under O0, because we only care about libcalls introduced by optimizations.

Yeah!

[xbolva00]

Removing my “block”

[efriedma]

In D123198#3442121, @nikic wrote:

If we wanted to make that clearer, we could separate out this part to only add these attributes when creating new libcalls. That should also make it obvious that it's fine that this code doesn't run under O0, because we only care about libcalls introduced by optimizations.

This might make sense... I guess we could introduce a separate routine to compute the "mandatory" attributes. Maybe make it a combined routine, actually; have it call getOrInsertFunction, then compute the mandatory attributes for that function. That would let us be more strict, also: we could assert() that we don't build new libcalls that don't have the code for computing mandatory attributes.

Then we can say inferLibFuncAttributes is just an optimization (and the emit* utilities call it just for the sake of avoiding pass ordering issues).

llvm/lib/Transforms/Utils/BuildLibCalls.cpp

607

I don't think LibFunc_chown/LibFunc_lchown are used anywhere else... so dropping them from TargetLibraryInfo wouldn't have any practical effect.

That said, like @nikic noted, we only really need to add sign/zeroext attributes to new libcalls; existing ones should already have the right attributes. So we could get away with still recognizing chown/lchown as long as we don't try to construct calls to them.

[jonpa]

Thanks for review so far everyone! Since all of you seemed to like the idea of separating these mandatory arguments from the other ones ("inferred"), and I also thought it made sense, I decided to give it a try per your suggestions.

This might make sense... I guess we could introduce a separate routine to compute the "mandatory" attributes. Maybe make it a combined routine, actually; have it call getOrInsertFunction, then compute the mandatory attributes for that function. That would let us be more strict, also: we could assert() that we don't build new libcalls that don't have the code for computing mandatory attributes.

I called this new function getOrInsertLibFunc() which is basically mirrors/wraps the getOrInsertFunction() definitions, with added handling of mandatory argument attributes. I also changed the name of inferLibFuncAttributes() to inferNonMandatoryLibFuncAttrs() to make this point clear.

The idea is now that getOrInsertLibFunc() is called instead of getOrInsertFunction() anytime a libcall is being created, for instance in LoopIdiomRecognize.cpp. It would have been nice to assert in getOrInsertFunction() that a libcall is not being created "on the side", but that does not seem practical as it would require checking with *TLI.

I left inferNonMandatoryLibFuncAttrs() outside of getOrInsertLibFunc() as it is not always called, for instance in emitFPutC().

I started out with demanding all functions in getOrInsertLibFunc() to be "seen", and listed also those without any i32 argument explicitly (with no action in the 'default' case). It seemed however more reasonable to instead do the check afterwards so that e.g. a new libfunction without any i32 argument would not all of a sudden trigger an assert. This is not "perfect", but at least it can report if there is not any type of extension at all being done on such an argument when the target requires it.

There are many more functions (found in annotate.ll) that are not currently being emitted in calls by any optimizer (or at least not tested). I added a test for one of them (LibFunc_ldexpl) as it actually can be generated by SimplifyLibCalls, but I am not sure what to do with the others. They could either be added now without any test, or they could simply be left out in the hopes that they would be handled/discovered if they ever where to be added later (what if someone makes an optimization but only tests it on their target and then clang is built in release-mode on SystemZ..? It would probably be missed then, but on the other hand there could always be new libfunctions added that we don't know about now...). The functions I have omitted for now are:

case LibFunc_setitimer:
 case LibFunc_read:
 case LibFunc_write:
 case LibFunc_fdopen:
 case LibFunc_fputc:
 case LibFunc_fputc_unlocked:
 case LibFunc_fstat:
 case LibFunc_fstatvfs:
 case LibFunc_getitimer:
 case LibFunc_ungetc:
 case LibFunc_putc:
 case LibFunc_putc_unlocked:
 case LibFunc_under_IO_putc:
 case LibFunc_pread:
 case LibFunc_pwrite:
 case LibFunc_htonl:
 case LibFunc_htons:
 case LibFunc_ntohl:
 case LibFunc_ntohs:
 case LibFunc_fstat64:
 case LibFunc_fstatvfs64:
 case LibFunc_abs:
 case LibFunc_ffs:
 case LibFunc_isascii:
 case LibFunc_isdigit:
 case LibFunc_toascii:
 case LibFunc_putchar_unlocked:
   Changed |= setArgExtAttr(F, 0, TLI);

 case LibFunc_strchr:
 case LibFunc_strrchr:
 case LibFunc_memchr:
 case LibFunc_memrchr:
 case LibFunc_access:
 case LibFunc_fgets:
 case LibFunc_fgets_unlocked:
 case LibFunc_open:
 case LibFunc_open64:
 case LibFunc_memset_pattern4:
 case LibFunc_memset_pattern8:
 case LibFunc_memset_pattern16:
 case LibFunc_memset:
 case LibFunc_memset_chk:
 case LibFunc_memrchr:
 case LibFunc_strrchr:
   Changed |= setArgExtAttr(F, 1, TLI);

 case LibFunc_strtol:
 case LibFunc_strtoll:
 case LibFunc_strtoul:
 case LibFunc_strtoull:
 case LibFunc_setvbuf:
 case LibFunc_memccpy:
 case LibFunc_fseek:
 case LibFunc_fseeko:
 case LibFunc_fseeko64:
   Changed |= setArgExtAttr(F, 2, TLI);

Should any of these be added at this point?

BuildLibCalls:
Changed getFloatFnName() to getFloatFn() and made it also return the LibFunc via reference. This is needed as it may happen that the original LibFunc is first mapped to a name that is specific to a target. Then it happened that this name was not mapped back to the LibFunc, so I had to pass the LibFunc argument (in addition to the name) to getOrInsertLibFunc(). This mapping from name to LibFunc however seems to work fine in emitUnaryFloatFnCall() and emitBinaryFloatFnCall() ...

Since TLI is now needed in getOrInsertLibFunc() I added it where it was previously missing (/optional) to versions of emitUnaryFloatFnCall() and emitBinaryFloatFnCall(), as well as in SimplifyLibCalls.cpp as needed.

Tests:
Removed the previous changes in annotate.ll and instead tested the functions handled especially on SystemZ in some files. In two cases I had to remove the datalayout string so that there would not be i32 arguments on SystemZ (for instance for a pointer or size_t), but I think those test changes should be ok.

[jonpa]

llvm/test/Transforms/InstCombine/strchr-1.ll

3 ↗

(On Diff #423089)

Will this test pass on all targets or should the first line here have a target triple to match the output (uses of i64)...?
Or perhaps running it just once on SystemZ would work?

(fputs-1.ll same)

[efriedma]

llvm/include/llvm/Transforms/Utils/BuildLibCalls.h

38 ↗

(On Diff #423089)

Does getOrInsertLibFunc really need a "Name" argument? We have TargetLibraryInfo; we can just look up the correct name.

llvm/lib/Transforms/Utils/BuildLibCalls.cpp

1253

I'd prefer to make the assertion target-independent if possible; if someone is adding a new libcall optimization, they might not remember to write a test specifically for SystemZ.

Can we just add a check in the "default" case that the call doesn't pass/return any integer values, or something like that? (I guess in that case, you'd have to list out all the calls we build that have a size_t argument or return value, but that should be a much smaller list than every function supported by inferNonMandatoryLibFuncAttrs.)

llvm/test/Transforms/InstCombine/strchr-1.ll

3 ↗

(On Diff #423089)

In general, if you're going to manually hack at tests with an "Assertions have been autogenerated" marking, please either regenerate them or drop the marking.

These tests were written with the assumption the generated IR wouldn't be target-specific. Since it turns out the input and result are in fact target-specific, we should just pick a target, and shove them into the relevant target-specific subdirectory (llvm/test/Transforms/InstCombine/X86/ etc.). And maybe add a few tests to llvm/test/Transforms/InstCombine/SystemZ/ to confirm the whole signext marking mechanism is working.

Alternatively, you could try to hack at the tests to try make them agnostic to whether there's a signext marking, but that seems like extra work for not much benefit.

[jonpa]

Updated per review (see inline comments)

llvm/include/llvm/Transforms/Utils/BuildLibCalls.h

38 ↗

(On Diff #423089)

I removed it and it seems that it is nearly identical, but for one test case:

double-float-shrink-1.ll

-; MS64-NEXT:     [[LOGBF:%.*]] = call fast float @logbf(float [[F:%.*]])
+; MS64-NEXT:     [[LOGBF:%.*]] = call fast float @_logbf(float [[F:%.*]])

On this target the name gets a different name with 'TLI.setAvailableWithName(LibFunc_logbf, "_logbf");'.

I am not sure what the difference here means, but I am hoping that it would work to make that call to the preferred version directly, so I kept this change and updated the test.

llvm/lib/Transforms/Utils/BuildLibCalls.cpp

1253

Ah, that seems to work: if we can assume that size_t never needs extension (which I "hope") we get only a small list of functions here to exclude and can have the check enabled for all targets...

llvm/test/Transforms/InstCombine/strchr-1.ll

3 ↗

(On Diff #423089)

ok - I backed out of those tests and instead made a new SystemZ test file.

I think those tests don't have CHECKs for any target-specific result, so leaving them as is under /InstCombine.

[efriedma]

llvm/include/llvm/Transforms/Utils/BuildLibCalls.h

38 ↗

(On Diff #423089)

That's what we want this code to be doing, yes.

(Looking at the latest Microsoft documentation, I'm not sure the TargetLibraryInfo description is actually doing what we want, but that's not really related to this patch.)

llvm/lib/Transforms/Utils/BuildLibCalls.cpp

1253

I think it's true at the moment that size_t never needs extension. If some future target does need extension, we have a list of functions we'd need to mark up. (I can imagine some 64-bit target with an alternate 32-bit ABI.)

1265

Do you need to check the bitwidth here? There should be very few libfuncs which take a 64-bit integer as an argument, and I'd like to avoid tripping someone up if they, for example, add a call to a libfunc with a size_t argument and forget to test it on a 32-bit target.

[jonpa]

Updated per review (see inline comment)

llvm/lib/Transforms/Utils/BuildLibCalls.cpp

1265

I tried checking for any integer argument here which succeeded on tests after adding some more functions.

We by this now also see two vararg functions here (snprintf, vsnprintf). They have a size_t argument which we consider ok, but they also have varargs, which could *theoritically* be emitted by the compiler as well, right? It seems that currently this is done only by SimplifyLibCalls which removes a check and simply passes on the varargs to the new function, so they really should be ok as they are, I think.

I can imagine we either:

1. Accept these varargs as "safe" and assume they will never ever be emitted by an optimizer on its own and so ignores adding any mandatory attributes on them. We could add a comment somewhere documenting this.

2. We check the varargs here with an assert that any i32 arg is extended if target demands it.

3. We rewrite the emission of these libcalls so that it is part of the code design that the valist is being reused (as emitted by the front end). (Maybe this could if desirable be done at some later point?)

#2 and #3 would include all of them and not just the two with a size_t arg...

[efriedma]

llvm/lib/Transforms/Utils/BuildLibCalls.cpp

1265

vsprintf/vsnprintf aren't varargs functions, strictly speaking. (The fact that they have a va_list argument isn't really relevant here.)

emitSPrintf/emitSNPrintf are used to lower calls to __sprintf_chk etc. If we do perform this lowering, we need to copy the zext/sext flags from the corresponding call, I think. But I think we can leave that for a followup.

[efriedma]

llvm/lib/Transforms/Utils/BuildLibCalls.cpp

1265

Also, I don't think that varargs handling would belong in this function, in any case. For a varargs call, any attributes on varargs arguments need to be attached to the specific call, not the function.

[jonpa]

llvm/lib/Transforms/Utils/BuildLibCalls.cpp

1265

makes sense to me...

[efriedma]

LGTM

[eugenis]

This breaks ubsan on the bot:

FAIL: LLVM :: Transforms/InstCombine/pr39177.ll (51198 of 64150)
******************** TEST 'LLVM :: Transforms/InstCombine/pr39177.ll' FAILED ********************
Script:
--
: 'RUN: at line 2';   /b/sanitizer-x86_64-linux-fast/build/llvm_build_ubsan/bin/opt < /b/sanitizer-x86_64-linux-fast/build/llvm-project/llvm/test/Transforms/InstCombine/pr39177.ll -passes=instcombine -S | /b/sanitizer-x86_64-linux-fast/build/llvm_build_ubsan/bin/FileCheck /b/sanitizer-x86_64-linux-fast/build/llvm-project/llvm/test/Transforms/InstCombine/pr39177.ll
--
Exit Code: 2

Command Output (stderr):
--
/b/sanitizer-x86_64-linux-fast/build/llvm-project/llvm/lib/Transforms/Utils/BuildLibCalls.cpp:1217:17: runtime error: reference binding to null pointer of type 'llvm::Function'
    #0 0x55892440c92e in llvm::getOrInsertLibFunc(llvm::Module*, llvm::TargetLibraryInfo const&, llvm::LibFunc, llvm::FunctionType*, llvm::AttributeList) /b/sanitizer-x86_64-linux-fast/build/llvm-project/llvm/lib/Transforms/Utils/BuildLibCalls.cpp:1217:13
    #1 0x55892441213d in llvm::FunctionCallee llvm::getOrInsertLibFunc<llvm::PointerType*, llvm::IntegerType*, llvm::IntegerType*, llvm::Type*>(llvm::Module*, llvm::TargetLibraryInfo const&, llvm::LibFunc, llvm::AttributeList, llvm::Type*, llvm::PointerType*, llvm::IntegerType*, llvm::IntegerType*, llvm::Type*) /b/sanitizer-x86_64-linux-fast/build/llvm-project/llvm/include/llvm/Transforms/Utils/BuildLibCalls.h:47:12
    #2 0x55892441124e in getOrInsertLibFunc<llvm::PointerType *, llvm::IntegerType *, llvm::IntegerType *, llvm::Type *> /b/sanitizer-x86_64-linux-fast/build/llvm-project/llvm/include/llvm/Transforms/Utils/BuildLibCalls.h:55:12
    #3 0x55892441124e in llvm::emitFWrite(llvm::Value*, llvm::Value*, llvm::Value*, llvm::IRBuilderBase&, llvm::DataLayout const&, llvm::TargetLibraryInfo const*) /b/sanitizer-x86_64-linux-fast/build/llvm-project/llvm/lib/Transforms/Utils/BuildLibCalls.cpp:1725:22
    #4 0x5589245c6ee9 in llvm::LibCallSimplifier::optimizeFPrintFString(llvm::CallInst*, llvm::IRBuilderBase&) /b/sanitizer-x86_64-linux-fast/build/llvm-project/llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp:2705:14
    #5 0x5589245c7168 in llvm::LibCallSimplifier::optimizeFPrintF(llvm::CallInst*, llvm::IRBuilderBase&) /b/sanitizer-x86_64-linux-fast/build/llvm-project/llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp:2738:18
    #6 0x5589245c8ce1 in llvm::LibCallSimplifier::optimizeCall(llvm::CallInst*, llvm::IRBuilderBase&) /b/sanitizer-x86_64-linux-fast/build/llvm-project/llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp:3159:14
    #7 0x558923d02e5d in llvm::InstCombinerImpl::tryOptimizeCall(llvm::CallInst*) /b/sanitizer-x86_64-linux-fast/build/llvm-project/llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp:2726:32
    #8 0x558923cfc23b in llvm::InstCombinerImpl::visitCallBase(llvm::CallBase&) /b/sanitizer-x86_64-linux-fast/build/llvm-project/llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp:2997:22
    #9 0x558923cf0b00 in llvm::InstCombinerImpl::visitCallInst(llvm::CallInst&) /b/sanitizer-x86_64-linux-fast/build/llvm-project/llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp
    #10 0x558923c8ac69 in llvm::InstCombinerImpl::run() /b/sanitizer-x86_64-linux-fast/build/llvm-project/llvm/lib/Transforms/InstCombine/InstructionCombining.cpp:4120:31
    #11 0x558923c8cfcc in combineInstructionsOverFunction(llvm::Function&, llvm::InstructionWorklist&, llvm::AAResults*, llvm::AssumptionCache&, llvm::TargetLibraryInfo&, llvm::TargetTransformInfo&, llvm::DominatorTree&, llvm::OptimizationRemarkEmitter&, llvm::BlockFrequencyInfo*, llvm::ProfileSummaryInfo*, unsigned int, llvm::LoopInfo*) /b/sanitizer-x86_64-linux-fast/build/llvm-project/llvm/lib/Transforms/InstCombine/InstructionCombining.cpp:4408:13
    #12 0x558923c8cc02 in llvm::InstCombinePass::run(llvm::Function&, llvm::AnalysisManager<llvm::Function>&) /b/sanitizer-x86_64-linux-fast/build/llvm-project/llvm/lib/Transforms/InstCombine/InstructionCombining.cpp:4439:8
    #13 0x5589247a1281 in llvm::detail::PassModel<llvm::Function, llvm::InstCombinePass, llvm::PreservedAnalyses, llvm::AnalysisManager<llvm::Function> >::run(llvm::Function&, llvm::AnalysisManager<llvm::Function>&) /b/sanitizer-x86_64-linux-fast/build/llvm-project/llvm/include/llvm/IR/PassManagerInternal.h:88:17
    #14 0x55892394d939 in llvm::PassManager<llvm::Function, llvm::AnalysisManager<llvm::Function> >::run(llvm::Function&, llvm::AnalysisManager<llvm::Function>&) /b/sanitizer-x86_64-linux-fast/build/llvm-project/llvm/include/llvm/IR/PassManager.h:522:21
    #15 0x558921bdc0f1 in llvm::detail::PassModel<llvm::Function, llvm::PassManager<llvm::Function, llvm::AnalysisManager<llvm::Function> >, llvm::PreservedAnalyses, llvm::AnalysisManager<llvm::Function> >::run(llvm::Function&, llvm::AnalysisManager<llvm::Function>&) /b/sanitizer-x86_64-linux-fast/build/llvm-project/llvm/include/llvm/IR/PassManagerInternal.h:88:17
    #16 0x5589239520fb in llvm::ModuleToFunctionPassAdaptor::run(llvm::Module&, llvm::AnalysisManager<llvm::Module>&) /b/sanitizer-x86_64-linux-fast/build/llvm-project/llvm/lib/IR/PassManager.cpp:127:22
    #17 0x558921bdbe61 in llvm::detail::PassModel<llvm::Module, llvm::ModuleToFunctionPassAdaptor, llvm::PreservedAnalyses, llvm::AnalysisManager<llvm::Module> >::run(llvm::Module&, llvm::AnalysisManager<llvm::Module>&) /b/sanitizer-x86_64-linux-fast/build/llvm-project/llvm/include/llvm/IR/PassManagerInternal.h:88:17
    #18 0x55892394cb49 in llvm::PassManager<llvm::Module, llvm::AnalysisManager<llvm::Module> >::run(llvm::Module&, llvm::AnalysisManager<llvm::Module>&) /b/sanitizer-x86_64-linux-fast/build/llvm-project/llvm/include/llvm/IR/PassManager.h:522:21
    #19 0x5589216d6db9 in llvm::runPassPipeline(llvm::StringRef, llvm::Module&, llvm::TargetMachine*, llvm::TargetLibraryInfoImpl*, llvm::ToolOutputFile*, llvm::ToolOutputFile*, llvm::ToolOutputFile*, llvm::StringRef, llvm::ArrayRef<llvm::StringRef>, llvm::ArrayRef<llvm::PassPlugin>, llvm::opt_tool::OutputKind, llvm::opt_tool::VerifierKind, bool, bool, bool, bool, bool) /b/sanitizer-x86_64-linux-fast/build/llvm-project/llvm/tools/opt/NewPMDriver.cpp:496:7
    #20 0x5589216f2d84 in main /b/sanitizer-x86_64-linux-fast/build/llvm-project/llvm/tools/opt/opt.cpp:830:12

https://lab.llvm.org/buildbot/#/builders/5/builds/22427

[MaskRay]

llvm/include/llvm/Transforms/Utils/BuildLibCalls.h

31 ↗

(On Diff #423705)

While updating function signatures, it may be worth checking whether M is non-null and may use Module &M

[MaskRay]

Review: Eli Friedman, Nikita Popov, Dávid Bolvanský

Please use Reviewed by: <who-has-accepted-the-revision> instead of Review: <all-people-on-the-review-line>

[MaskRay]

llvm/include/llvm/Transforms/Utils/BuildLibCalls.h

46 ↗

(On Diff #423705)

Consider using a plain array.

[jonpa]

It seems that the failing test case (Transforms/InstCombine/pr39177.ll) is a bit peculiar in that it contains an fwrite *alias*:

fwrite = alias i64 (i8*, i64, i64, %struct._IO_FILE*), i64 (i8*, i64, i64, %struct._IO_FILE*)* @__fwrite_alias

It defines the @__fwrite_alias() function, and then has a foo() function containing a call to @fprintf() which SimplifyLibCalls is trying to replace with a call to fwrite(). This is when it crashes because of a nullptr as discovered by the sanitizer.

I am not sure what the idea is here with having an fwrite alias, but it is clear that BuildLibCalls is getting confused:

 FunctionCallee llvm::getOrInsertLibFunc(Module *M, const TargetLibraryInfo &TLI,
                                        LibFunc TheLibFunc, FunctionType *T,
                                        AttributeList AttributeList) {
  assert(TLI.has(TheLibFunc) &&
         "Creating call to non-existing library function.");
  StringRef Name = TLI.getName(TheLibFunc);
=>FunctionCallee C = M->getOrInsertFunction(Name, T, AttributeList);

at this point M returns the alias:

(gdb) p C.Callee->dump()
@fwrite = alias i64 (i8*, i64, i64, %struct._IO_FILE*), i64 (i8*, i64, i64, %struct._IO_FILE*)* @__fwrite_alias

This is a GlobalAlias and not a Function, which is why getFunction() returned nullptr:

Function &F = *M->getFunction(Name);

Looking at the test case, it seems to be valid to write your own fwrite and expect the compiler use it as a replacement for the standard fwrite call..? I guess this means that getOrInsertLibFunc() should also be able to handle a GlobalAlias?

llvm/include/llvm/Transforms/Utils/BuildLibCalls.h

46 ↗

(On Diff #423705)

Do you have anything special in mind? This was copied from getOrInsertFunction().

[efriedma]

I guess there are two possibilities in that case:

1. Abandon the transform, as if we don't have an fwrite function.
2. Return the necessary attributes from getOrInsertLibFunc, and make the caller apply them to the call.

llvm/include/llvm/Transforms/Utils/BuildLibCalls.h

46 ↗

(On Diff #423705)

I assume something like Type *ArgTys[] = {Args...}; should work.

[jonpa]

In D123198#3462581, @efriedma wrote:

I guess there are two possibilities in that case:

1. Abandon the transform, as if we don't have an fwrite function.
2. Return the necessary attributes from getOrInsertLibFunc, and make the caller apply them to the call.

If the user wrote a function either with the same identical name as a library function, or it ends up being aliased with such a name, it seems we should here as well trust that the front end has added the mandatory attributes, or?

Maybe we should change getOrInsertLibFunc() to first check for any existing Function or GlobalAlias matching Name. If there is already one of those, we could then assume that we have either already created it in getOrInsertLibFunc() earlier or that it is an alias created by the front end. So only when we are actually inserting a library function into the Module the first time do we need to add the attributes, right?

The user could either write a function named e.g. fwrite(), or an alias called fwrite. It seems that an optimizer emitting fwrite() therefore unknowingly either uses the library function, or the user provided function, which is somewhat strange to me: I would have guessed that the libcall emissions only emit libcalls and nothing else. I wonder even if that could lead to problems - what if the user wrote a function that did something entirely different and just happened to give it the same name as a libfunction? Is there something preventing unintended "libcall" emissions in such a case? This seems broken to me unless the user really is supposed to be able to write his own library function and expect it to be used entirely the same as the standard library function would be, as a stand-in. That is a separate topic from this patch, though...

[efriedma]

If the user wrote a function either with the same identical name as a library function, or it ends up being aliased with such a name, it seems we should here as well trust that the front end has added the mandatory attributes, or?

If we find an alias, I wouldn't trust that the alias points to a function with a real signature.

Maybe we should change getOrInsertLibFunc() to first check for any existing Function or GlobalAlias matching Name. If there is already one of those, we could then assume that we have either already created it in getOrInsertLibFunc() earlier or that it is an alias created by the front end. So only when we are actually inserting a library function into the Module the first time do we need to add the attributes, right?

We could, sure. If we want to be conservative, I guess we could mess with isValidProtoForLibFunc to verify the attributes.

The user could either write a function named e.g. fwrite(), or an alias called fwrite. It seems that an optimizer emitting fwrite() therefore unknowingly either uses the library function, or the user provided function, which is somewhat strange to me: I would have guessed that the libcall emissions only emit libcalls and nothing else. I wonder even if that could lead to problems - what if the user wrote a function that did something entirely different and just happened to give it the same name as a libfunction? Is there something preventing unintended "libcall" emissions in such a case? This seems broken to me unless the user really is supposed to be able to write his own library function and expect it to be used entirely the same as the standard library function would be, as a stand-in. That is a separate topic from this patch, though...

If the user is defining functions that overlap with core libc function names, we expect them to use "-fno-builtin-fwrite" etc. If the user doesn't specify the right no-builtin attributes, we just sort of best-effort avoid crashing.

[jonpa]

If we find an alias, I wouldn't trust that the alias points to a function with a real signature.

I am not sure how that could be: per the LLVM LangRef an alias must have

@<Name> = alias <AliaseeTy>, <AliaseeTy>* @<Aliasee>

, which to me looks like there must be a function defined or declared, provided as @Aliasee, with a function type..?

Would both the alias and Aliasee always come from the front end (and so be assumed to have the required attributes)...?

[efriedma]

In D123198#3472615, @jonpa wrote:

If we find an alias, I wouldn't trust that the alias points to a function with a real signature.

, which to me looks like there must be a function defined or declared, provided as @Aliasee, with a function type..?

An alias has to point to something, but it could point to a variable.

Would both the alias and Aliasee always come from the front end (and so be assumed to have the required attributes)...?

Even if there is a function, I wouldn't trust it has the right signature. In general, we don't require that function declarations have the right signature. (For example, you can write struct A; struct A f(void), (*g)(void) = f; in C.)

[alexgatea]

When I compile the following valid test case:

#include <string.h>
int main(){
   char a[]="123";
   char b[5];

  memset(b, 0, 5);
    __builtin___stpncpy_chk (b, a, 2, 5);
}

An Assert in BuildLibCalls.cpp fails:

llvm::FunctionCallee llvm::getOrInsertLibFunc(llvm::Module *, const llvm::TargetLibraryInfo &, llvm::LibFunc, llvm::FunctionType *, llvm::AttributeList): Assertion `!isa<IntegerType>(T->getParamType(i)) && "Unhandled integer argument."' failed.

[jonpa]

... An Assert in BuildLibCalls.cpp fails ...

Thanks for reporting this. This is because InstCombiner is replacing the @__stpncpy_chk() call with a call to @stpncpy(), which has a sizeof parameter (see earlier discussion). This went undetected as there was no regression test covering this. I suppose there must be more of these...

I guess I should make a list of all built libcalls with a sizeof parameter and include them as accepted in getOrInsertLibFunc()?

Even if there is a function, I wouldn't trust it has the right signature. In general, we don't require that function declarations have the right signature. (For example, you can write struct A; struct A f(void), (*g)(void) = f; in C.)

OK - now I understand better: the Function Type may actually be incomplete at this point.

IIUC, this is basically the users responsibility: If user decides to write e.g. a function named fwrite (or a function alias of that name), either

-fno-builtin-fwrite is passed in which case fwrite will not be available to generate so getOrInsertLibFunc() will never be reached.
-fno-builtin-fwrite is *not* passed (as in pr39177.ll) and any problem is then basically the users fault and getOrInsertLibFunc() does not have to care about this.

In getOrInsertLibFunc() we could either

1. Insert into Module a Function with the given Name
2. Get back a previusly inserted Function a. a proper libcall b. a user defined function
3. Get back a GlobalAlias matching Name.

I think we really only need to care about #1. We could check with isValidProtoForLibFunc() and add mandatory arguments also in cases of #2b and #3 where the prototype matches, but maybe that is not worth the effort since this is not really supposed to happen..? (And again, the front end should have emitted those I think).

Would it makes sense then to simply add to the patch to skip adding mandatory attributes in case #3 (when we get a function alias)?

[efriedma]

When we see an alias, there are two options: we fail the transform (getOrInsertLibFunc returns null or something like that), or we return the attributes the caller needs to attach.

We can't just skip adding the attributes: we end up generating a broken call that won't perform the necessary sign-extension. So it breaks even if the alias points to a proper fwrite implementation. (Even if we don't technically promise anything in this case, generating a call that's provably broken is bad.)

[jonpa]

We can't just skip adding the attributes: we end up generating a broken call that won't perform the necessary sign-extension. So it breaks even if the alias points to a proper fwrite implementation. (Even if we don't technically promise anything in this case, generating a call that's provably broken is bad.)

OK - we don't have the responsibility here but it wouldn't hurt to help if we could, makes sense.

I started look into the difference in having a function alias replacing a libcall, and was surprised to find that the final assembly output is actually identical, which I hadn't expected. I was assuming that in the following program @__ldexp_alias() would end up being called:

@ldexp = alias double (double, i32), double (double, i32)* @__ldexp_alias
define double @__ldexp_alias(double %X, i32 %Exp) #0 {
 ret double 0.000000e+00
}
;declare double @ldexp(double, i32) 

define double @fake_ldexp() #0 {
  %ldexp = call double @ldexp(double 1.000000e+00, i32 2)
  ret double %ldexp
}

It however has no difference as to when the "declare @ldexp" is used instead... In both cases SelectionDAGBuilder creates a node like

i64 = GlobalAddress<double (double, i32)* @ldexp> 0

Resulting in

brasl   %r14, ldexp@PLT

The function with the name of the alias is called even though that is not supposed to exist on its own (same thing with non library like name)... Not sure what to think of this... Maybe I am using the alias incorrectly somehow?

[efriedma]

If you dig through the assembly in your example, you'll find a directive .set ldexp, __ldexp_alias. The assembler will resolve the alias.

[nickdesaulniers]

Should I be using this approach to solve: https://github.com/llvm/llvm-project/issues/53645?

[efriedma]

Yes, computing the attributes in getOrInsertLibFunc() seems correct.

[jonpa]

Thanks for review.

I painstakingly went through SimplifyLibCalls and made a list of all emitted libcalls with integer arguments, and found that indeed the emission of stpncpy() was missing (but no others (!). The emission of stpncpy() never had a test, but I added one in addition to the needed recognition in getOrInsertLibFunc().

When we see an alias, there are two options: we fail the transform (getOrInsertLibFunc returns null or something like that), or we return the attributes the caller needs to attach.

It seems most reasonable to not have the optimizers emit a call to a library function that is in fact not available. So I added a new function isLibCallEmittable() that can be used instead of TLI->has(): it also checks for an existing alias of the function. I also added an assert in getOrInsertLibFunc() that getOrInsertFunction() actually returns a Function.

I have tried to make all callers of getOrInsertLibFunc() first call isLibFuncEmittable() before emitting a libcall, which is required.

Also replaced getOrInsertFunction() with getOrInsertLibFunc() in few more places in SimplifyLibCalls.cpp

In a way this is still kind of a "mixed policy": We don't stop a libcall emission in the presence of a user defined function, but an alias however disables it. A function coming from the front end should have mandatory attributes already, so it should hopefully be ok. I was hoping the same should be true for a function alias, but IIUC the previous review that is not the case (due to incomplete function prototypes?). As this is after all the users responsibility, I don't think there has to be a full consistency and also that this is a separate topic that could perhaps be improved upon in the future if desired. There could for instance be a check that the Function seen in getOrInsertLibFunc() is a declaration with the proper libfunc arguments, and not a definition (unless the opposite handling would be done to instead try to do a best effort to add mandatory attributes to any user definitions and proceed with the libcall emission).

What do you think?

[efriedma]

llvm/lib/Transforms/Utils/BuildLibCalls.cpp

1232

Instead of calling getFunction(), should we just cast<Function>(C.getCallee())?

Actually, also, should we check that the type of the Function is actually "T"?

[efriedma]

I mostly want to make sure what we're doing here is sufficient to avoid crashing/verifier errors in the presence of weird user inputs. I don't want to keep expanding the scope of this.

[jonpa]

Instead of calling getFunction(), should we just cast<Function>(C.getCallee())?
Actually, also, should we check that the type of the Function is actually "T"?

Patch updated per review.

[efriedma]

llvm/lib/Transforms/Utils/BuildLibCalls.cpp

1292

Not sure !M->getNamedAlias(FuncName) is quite sufficient. What happens if we find a GlobalVariable? Or a Function with the wrong type?

[jonpa]

Not sure !M->getNamedAlias(FuncName) is quite sufficient. What happens if we find a GlobalVariable? Or a Function with the wrong type?

Yes, I guess the more full treatment would be to check for other things as well, which makes sense.

I think I managed to improve the check from just checking for an Alias to checking for any GlobalValue and if found then making sure it's a Function.

As for the FunctionType, it doesn't seem feasible (at least not with the current patch), to have the caller to isLibFuncEmittable() provide the FunctionType. It however seems to work to use isValidProtoForLibFunc() for this purpose. I don't see that function used anywhere, but I remember you mentioned it earlier.

[efriedma]

LGTM

llvm/lib/Transforms/Utils/BuildLibCalls.cpp

case LibFunc_wcslen:
     Changed |= setOnlyReadsMemory(F);
     Changed |= setDoesNotThrow(F);
     Changed |= setOnlyAccessesArgMemory(F);
     Changed |= setWillReturn(F);
     Changed |= setDoesNotCapture(F, 0);
     return Changed;
   case LibFunc_strchr:
   case LibFunc_strrchr:
+    Changed |= setArgExtAttr(F, 1, TLI);
     Changed |= setOnlyAccessesArgMemory(F);
     Changed |= setOnlyReadsMemory(F);
     Changed |= setDoesNotThrow(F);
     Changed |= setWillReturn(F);
     return Changed;
   case LibFunc_strtol:
+  case LibFunc_strtoll:
+  case LibFunc_strtoul:
+  case LibFunc_strtoull:
+    Changed |= setArgExtAttr(F, 2, TLI);
+    LLVM_FALLTHROUGH;
   case LibFunc_strtod:
   case LibFunc_strtof:
-  case LibFunc_strtoul:
-  case LibFunc_strtoll:
   case LibFunc_strtold:
-  case LibFunc_strtoull:
     Changed |= setDoesNotThrow(F);
     Changed |= setWillReturn(F);
     Changed |= setDoesNotCapture(F, 1);
     Changed |= setOnlyReadsMemory(F, 0);
     return Changed;
   case LibFunc_strcat:
   case LibFunc_strncat:
     Changed |= setOnlyAccessesArgMemory(F);
case LibFunc_strtok_r:
     Changed |= setOnlyReadsMemory(F, 1);
     return Changed;
   case LibFunc_scanf:
     Changed |= setRetAndArgsNoUndef(F);
     Changed |= setDoesNotThrow(F);
     Changed |= setDoesNotCapture(F, 0);
     Changed |= setOnlyReadsMemory(F, 0);
     return Changed;
-  case LibFunc_setbuf:
   case LibFunc_setvbuf:
+    Changed |= setArgExtAttr(F, 2, TLI);
+    LLVM_FALLTHROUGH;
+  case LibFunc_setbuf:
     Changed |= setRetAndArgsNoUndef(F);
     Changed |= setDoesNotThrow(F);
     Changed |= setDoesNotCapture(F, 0);
     return Changed;
   case LibFunc_strndup:
     Changed |= setArgNoUndef(F, 1);
     LLVM_FALLTHROUGH;
   case LibFunc_strdup:
case LibFunc_snprintf:
     Changed |= setDoesNotCapture(F, 0);
     Changed |= setDoesNotAlias(F, 0);
     Changed |= setOnlyWritesMemory(F, 0);
     Changed |= setDoesNotCapture(F, 2);
     Changed |= setOnlyReadsMemory(F, 2);
     return Changed;
   case LibFunc_setitimer:
     Changed |= setRetAndArgsNoUndef(F);
+    Changed |= setArgExtAttr(F, 0, TLI);
     Changed |= setDoesNotThrow(F);
     Changed |= setWillReturn(F);
     Changed |= setDoesNotCapture(F, 1);
     Changed |= setDoesNotCapture(F, 2);
     Changed |= setOnlyReadsMemory(F, 1);
     return Changed;
   case LibFunc_system:
     // May throw; "system" is a valid pthread cancellation point.
case LibFunc_memcmp:
     Changed |= setOnlyReadsMemory(F);
     Changed |= setDoesNotThrow(F);
     Changed |= setWillReturn(F);
     Changed |= setDoesNotCapture(F, 0);
     Changed |= setDoesNotCapture(F, 1);
     return Changed;
   case LibFunc_memchr:
   case LibFunc_memrchr:
+    Changed |= setArgExtAttr(F, 1, TLI);
     Changed |= setDoesNotThrow(F);
     Changed |= setOnlyAccessesArgMemory(F);
     Changed |= setOnlyReadsMemory(F);
     Changed |= setWillReturn(F);
     return Changed;
   case LibFunc_modf:
   case LibFunc_modff:
   case LibFunc_modfl:
case LibFunc_memmove:
     Changed |= setDoesNotThrow(F);
     Changed |= setOnlyAccessesArgMemory(F);
     Changed |= setWillReturn(F);
     Changed |= setReturnedArg(F, 0);
     Changed |= setOnlyWritesMemory(F, 0);
     Changed |= setDoesNotCapture(F, 1);
     Changed |= setOnlyReadsMemory(F, 1);
     return Changed;
-  case LibFunc_mempcpy:
   case LibFunc_memccpy:
+    Changed |= setArgExtAttr(F, 2, TLI);
+    LLVM_FALLTHROUGH;
+  case LibFunc_mempcpy:
     Changed |= setWillReturn(F);
     LLVM_FALLTHROUGH;
   case LibFunc_memcpy_chk:
     Changed |= setDoesNotThrow(F);
     Changed |= setOnlyAccessesArgMemory(F);
     Changed |= setDoesNotAlias(F, 0);
     Changed |= setOnlyWritesMemory(F, 0);
     Changed |= setDoesNotAlias(F, 1);
case LibFunc_reallocf:
     Changed |= setRetDoesNotAlias(F);
     Changed |= setWillReturn(F);
     Changed |= setDoesNotCapture(F, 0);
     Changed |= setArgNoUndef(F, 1);
     return Changed;
   case LibFunc_read:
     // May throw; "read" is a valid pthread cancellation point.
     Changed |= setRetAndArgsNoUndef(F);
+    Changed |= setArgExtAttr(F, 0, TLI);
     Changed |= setDoesNotCapture(F, 1);
     return Changed;
   case LibFunc_rewind:
     Changed |= setRetAndArgsNoUndef(F);
     Changed |= setDoesNotThrow(F);
     Changed |= setDoesNotCapture(F, 0);
     return Changed;
   case LibFunc_rmdir:
case LibFunc_readlink:
     Changed |= setDoesNotThrow(F);
     Changed |= setDoesNotCapture(F, 0);
     Changed |= setDoesNotCapture(F, 1);
     Changed |= setOnlyReadsMemory(F, 0);
     return Changed;
   case LibFunc_write:
     // May throw; "write" is a valid pthread cancellation point.
     Changed |= setRetAndArgsNoUndef(F);
+    Changed |= setArgExtAttr(F, 0, TLI);
     Changed |= setDoesNotCapture(F, 1);
     Changed |= setOnlyReadsMemory(F, 1);
     return Changed;
   case LibFunc_bcopy:
     Changed |= setDoesNotThrow(F);
     Changed |= setOnlyAccessesArgMemory(F);
     Changed |= setWillReturn(F);
     Changed |= setDoesNotCapture(F, 0);
bool llvm::inferLibFuncAttributes(Function &F, const TargetLibraryInfo &TLI) {
   case LibFunc_vec_calloc:
     Changed |= setOnlyAccessesInaccessibleMemory(F);
     Changed |= setRetAndArgsNoUndef(F);
     Changed |= setDoesNotThrow(F);
     Changed |= setRetDoesNotAlias(F);
     Changed |= setWillReturn(F);
     return Changed;
   case LibFunc_chmod:
-  case LibFunc_chown:
     Changed |= setRetAndArgsNoUndef(F);
     Changed |= setDoesNotThrow(F);
     Changed |= setDoesNotCapture(F, 0);
     Changed |= setOnlyReadsMemory(F, 0);
     return Changed;
   case LibFunc_ctermid:
   case LibFunc_clearerr:
   case LibFunc_closedir:
     Changed |= setRetAndArgsNoUndef(F);
     Changed |= setDoesNotThrow(F);
     Changed |= setDoesNotCapture(F, 0);
     return Changed;
   case LibFunc_atoi:
   case LibFunc_atol:
   case LibFunc_atof:
   case LibFunc_atoll:
     Changed |= setDoesNotThrow(F);
     Changed |= setOnlyReadsMemory(F);
     Changed |= setWillReturn(F);
     Changed |= setDoesNotCapture(F, 0);
     return Changed;
   case LibFunc_access:
     Changed |= setRetAndArgsNoUndef(F);
+    Changed |= setArgExtAttr(F, 1, TLI);
     Changed |= setDoesNotThrow(F);
     Changed |= setDoesNotCapture(F, 0);
     Changed |= setOnlyReadsMemory(F, 0);
     return Changed;
   case LibFunc_fopen:
     Changed |= setRetAndArgsNoUndef(F);
     Changed |= setDoesNotThrow(F);
     Changed |= setRetDoesNotAlias(F);
     Changed |= setDoesNotCapture(F, 0);
     Changed |= setDoesNotCapture(F, 1);
     Changed |= setOnlyReadsMemory(F, 0);
     Changed |= setOnlyReadsMemory(F, 1);
     return Changed;
   case LibFunc_fdopen:
     Changed |= setRetAndArgsNoUndef(F);
+    Changed |= setArgExtAttr(F, 0, TLI);
     Changed |= setDoesNotThrow(F);
     Changed |= setRetDoesNotAlias(F);
     Changed |= setDoesNotCapture(F, 1);
     Changed |= setOnlyReadsMemory(F, 1);
     return Changed;
   case LibFunc_feof:
     Changed |= setRetAndArgsNoUndef(F);
     Changed |= setDoesNotThrow(F);
     Changed |= setDoesNotCapture(F, 0);
     return Changed;
   case LibFunc_free:
   case LibFunc_vec_free:
     Changed |= setOnlyAccessesInaccessibleMemOrArgMem(F);
     Changed |= setArgsNoUndef(F);
     Changed |= setDoesNotThrow(F);
     Changed |= setWillReturn(F);
     Changed |= setDoesNotCapture(F, 0);
     return Changed;
   case LibFunc_fseek:
+  case LibFunc_fseeko:
+    Changed |= setArgExtAttr(F, 2, TLI);
+    LLVM_FALLTHROUGH;
   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 |= setRetAndArgsNoUndef(F);
     Changed |= setDoesNotThrow(F);
     Changed |= setDoesNotCapture(F, 0);
     return Changed;
   case LibFunc_ferror:
     Changed |= setRetAndArgsNoUndef(F);
     Changed |= setDoesNotThrow(F);
     Changed |= setDoesNotCapture(F, 0);
     Changed |= setOnlyReadsMemory(F);
     return Changed;
   case LibFunc_fputc:
   case LibFunc_fputc_unlocked:
   case LibFunc_fstat:
     Changed |= setRetAndArgsNoUndef(F);
+    Changed |= setArgExtAttr(F, 0, TLI);
     Changed |= setDoesNotThrow(F);
     Changed |= setDoesNotCapture(F, 1);
     return Changed;
   case LibFunc_frexp:
   case LibFunc_frexpf:
   case LibFunc_frexpl:
     Changed |= setDoesNotThrow(F);
     Changed |= setWillReturn(F);
     Changed |= setDoesNotCapture(F, 1);
     return Changed;
   case LibFunc_fstatvfs:
     Changed |= setRetAndArgsNoUndef(F);
+    Changed |= setArgExtAttr(F, 0, TLI);
     Changed |= setDoesNotThrow(F);
     Changed |= setDoesNotCapture(F, 1);
     return Changed;
   case LibFunc_fgets:
   case LibFunc_fgets_unlocked:
     Changed |= setRetAndArgsNoUndef(F);
+    Changed |= setArgExtAttr(F, 1, TLI);
     Changed |= setDoesNotThrow(F);
     Changed |= setDoesNotCapture(F, 2);
     return Changed;
   case LibFunc_fread:
   case LibFunc_fread_unlocked:
     Changed |= setRetAndArgsNoUndef(F);
     Changed |= setDoesNotThrow(F);
     Changed |= setDoesNotCapture(F, 0);
case LibFunc_fprintf:
     return Changed;
   case LibFunc_fgetpos:
     Changed |= setRetAndArgsNoUndef(F);
     Changed |= setDoesNotThrow(F);
     Changed |= setDoesNotCapture(F, 0);
     Changed |= setDoesNotCapture(F, 1);
     return Changed;
   case LibFunc_getc:
+  case LibFunc_under_IO_getc:
     Changed |= setRetAndArgsNoUndef(F);
     Changed |= setDoesNotThrow(F);
     Changed |= setDoesNotCapture(F, 0);
     return Changed;
   case LibFunc_getlogin_r:
     Changed |= setRetAndArgsNoUndef(F);
     Changed |= setDoesNotThrow(F);
     Changed |= setDoesNotCapture(F, 0);
bool llvm::inferLibFuncAttributes(Function &F, const TargetLibraryInfo &TLI) {
   case LibFunc_gets:
   case LibFunc_getchar:
   case LibFunc_getchar_unlocked:
     Changed |= setRetAndArgsNoUndef(F);
     Changed |= setDoesNotThrow(F);
     return Changed;
   case LibFunc_getitimer:
     Changed |= setRetAndArgsNoUndef(F);
+    Changed |= setArgExtAttr(F, 0, TLI);
     Changed |= setDoesNotThrow(F);
     Changed |= setDoesNotCapture(F, 1);
     return Changed;
   case LibFunc_getpwnam:
     Changed |= setRetAndArgsNoUndef(F);
     Changed |= setDoesNotThrow(F);
     Changed |= setDoesNotCapture(F, 0);
     Changed |= setOnlyReadsMemory(F, 0);
     return Changed;
   case LibFunc_ungetc:
     Changed |= setRetAndArgsNoUndef(F);
+    Changed |= setArgExtAttr(F, 0, TLI);
     Changed |= setDoesNotThrow(F);
     Changed |= setDoesNotCapture(F, 1);
     return Changed;
   case LibFunc_uname:
     Changed |= setRetAndArgsNoUndef(F);
     Changed |= setDoesNotThrow(F);
     Changed |= setDoesNotCapture(F, 0);
     return Changed;
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:
+  case LibFunc_under_IO_putc:
     Changed |= setRetAndArgsNoUndef(F);
+    Changed |= setArgExtAttr(F, 0, TLI);
     Changed |= setDoesNotThrow(F);
     Changed |= setDoesNotCapture(F, 1);
     return Changed;
   case LibFunc_puts:
   case LibFunc_printf:
   case LibFunc_perror:
     Changed |= setRetAndArgsNoUndef(F);
     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 |= setRetAndArgsNoUndef(F);
+    Changed |= setArgExtAttr(F, 0, TLI);
     Changed |= setDoesNotCapture(F, 1);
     return Changed;
   case LibFunc_pwrite:
     // May throw; "pwrite" is a valid pthread cancellation point.
     Changed |= setRetAndArgsNoUndef(F);
+    Changed |= setArgExtAttr(F, 0, TLI);
     Changed |= setDoesNotCapture(F, 1);
     Changed |= setOnlyReadsMemory(F, 1);
     return Changed;
   case LibFunc_putchar:
   case LibFunc_putchar_unlocked:
     Changed |= setRetAndArgsNoUndef(F);
     Changed |= setArgExtAttr(F, 0, TLI);
     Changed |= setDoesNotThrow(F);
case LibFunc_vsnprintf:
     Changed |= setDoesNotThrow(F);
     Changed |= setDoesNotCapture(F, 0);
     Changed |= setDoesNotCapture(F, 2);
     Changed |= setOnlyReadsMemory(F, 2);
     return Changed;
   case LibFunc_open:
     // May throw; "open" is a valid pthread cancellation point.
     Changed |= setRetAndArgsNoUndef(F);
+    Changed |= setArgExtAttr(F, 1, TLI);
     Changed |= setDoesNotCapture(F, 0);
     Changed |= setOnlyReadsMemory(F, 0);
     return Changed;
   case LibFunc_opendir:
     Changed |= setRetAndArgsNoUndef(F);
     Changed |= setDoesNotThrow(F);
     Changed |= setRetDoesNotAlias(F);
     Changed |= setDoesNotCapture(F, 0);
     Changed |= setOnlyReadsMemory(F, 0);
     return Changed;
   case LibFunc_tmpfile:
     Changed |= setRetAndArgsNoUndef(F);
     Changed |= setDoesNotThrow(F);
     Changed |= setRetDoesNotAlias(F);
     return Changed;
   case LibFunc_times:
     Changed |= setRetAndArgsNoUndef(F);
     Changed |= setDoesNotThrow(F);
     Changed |= setDoesNotCapture(F, 0);
     return Changed;
   case LibFunc_htonl:
   case LibFunc_htons:
   case LibFunc_ntohl:
   case LibFunc_ntohs:
+    Changed |= setArgExtAttr(F, 0, TLI, false/*Signed*/);
     Changed |= setDoesNotThrow(F);
     Changed |= setDoesNotAccessMemory(F);
     return Changed;
   case LibFunc_lstat:
     Changed |= setRetAndArgsNoUndef(F);
     Changed |= setDoesNotThrow(F);
     Changed |= setDoesNotCapture(F, 0);
     Changed |= setDoesNotCapture(F, 1);
     Changed |= setOnlyReadsMemory(F, 0);
     return Changed;
-  case LibFunc_lchown:
-    Changed |= setRetAndArgsNoUndef(F);
-    Changed |= setDoesNotThrow(F);
-    Changed |= setDoesNotCapture(F, 0);
-    Changed |= setOnlyReadsMemory(F, 0);
-    return Changed;
   case LibFunc_qsort:
     // May throw; places call through function pointer.
     // Cannot give undef pointer/size
     Changed |= setRetAndArgsNoUndef(F);
     Changed |= setDoesNotCapture(F, 3);
     return Changed;
   case LibFunc_dunder_strndup:
     Changed |= setArgNoUndef(F, 1);
     LLVM_FALLTHROUGH;
   case LibFunc_dunder_strdup:
     Changed |= setDoesNotThrow(F);
     Changed |= setRetDoesNotAlias(F);
     Changed |= setWillReturn(F);
     Changed |= setDoesNotCapture(F, 0);
     Changed |= setOnlyReadsMemory(F, 0);
     return Changed;
   case LibFunc_dunder_strtok_r:
     Changed |= setDoesNotThrow(F);
     Changed |= setDoesNotCapture(F, 1);
     Changed |= setOnlyReadsMemory(F, 1);
     return Changed;
-  case LibFunc_under_IO_getc:
-    Changed |= setRetAndArgsNoUndef(F);
-    Changed |= setDoesNotThrow(F);
-    Changed |= setDoesNotCapture(F, 0);
-    return Changed;
-  case LibFunc_under_IO_putc:
-    Changed |= setRetAndArgsNoUndef(F);
-    Changed |= setDoesNotThrow(F);
-    Changed |= setDoesNotCapture(F, 1);
-    return Changed;
   case LibFunc_dunder_isoc99_scanf:
     Changed |= setRetAndArgsNoUndef(F);
     Changed |= setDoesNotThrow(F);
     Changed |= setDoesNotCapture(F, 0);
     Changed |= setOnlyReadsMemory(F, 0);
     return Changed;
   case LibFunc_stat64:
   case LibFunc_lstat64:
case LibFunc_fopen64:
     Changed |= setDoesNotThrow(F);
     Changed |= setRetDoesNotAlias(F);
     Changed |= setDoesNotCapture(F, 0);
     Changed |= setDoesNotCapture(F, 1);
     Changed |= setOnlyReadsMemory(F, 0);
     Changed |= setOnlyReadsMemory(F, 1);
     return Changed;
   case LibFunc_fseeko64:
+    Changed |= setArgExtAttr(F, 2, TLI);
+    LLVM_FALLTHROUGH;
   case LibFunc_ftello64:
     Changed |= setRetAndArgsNoUndef(F);
     Changed |= setDoesNotThrow(F);
     Changed |= setDoesNotCapture(F, 0);
     return Changed;
   case LibFunc_tmpfile64:
     Changed |= setRetAndArgsNoUndef(F);
     Changed |= setDoesNotThrow(F);
     Changed |= setRetDoesNotAlias(F);
     return Changed;
   case LibFunc_fstat64:
   case LibFunc_fstatvfs64:
     Changed |= setRetAndArgsNoUndef(F);
+    Changed |= setArgExtAttr(F, 0, TLI);
     Changed |= setDoesNotThrow(F);
     Changed |= setDoesNotCapture(F, 1);
     return Changed;
   case LibFunc_open64:
     // May throw; "open" is a valid pthread cancellation point.
     Changed |= setRetAndArgsNoUndef(F);
+    Changed |= setArgExtAttr(F, 1, TLI);
     Changed |= setDoesNotCapture(F, 0);
     Changed |= setOnlyReadsMemory(F, 0);
     return Changed;
   case LibFunc_gettimeofday:
     // Currently some platforms have the restrict keyword on the arguments to
     // gettimeofday. To be conservative, do not add noalias to gettimeofday's
     // arguments.
     Changed |= setRetAndArgsNoUndef(F);
     Changed |= setDoesNotThrow(F);
     Changed |= setDoesNotCapture(F, 0);
     Changed |= setDoesNotCapture(F, 1);
     return Changed;
   case LibFunc_memset_pattern4:
   case LibFunc_memset_pattern8:
   case LibFunc_memset_pattern16:
     Changed |= setDoesNotCapture(F, 0);
     Changed |= setDoesNotCapture(F, 1);
     Changed |= setOnlyReadsMemory(F, 1);
     LLVM_FALLTHROUGH;
   case LibFunc_memset:
     Changed |= setWillReturn(F);
     LLVM_FALLTHROUGH;
   case LibFunc_memset_chk:
+    Changed |= setArgExtAttr(F, 1, TLI);
     Changed |= setOnlyAccessesArgMemory(F);
     Changed |= setOnlyWritesMemory(F, 0);
     Changed |= setDoesNotThrow(F);
     return Changed;
   // int __nvvm_reflect(const char *)
   case LibFunc_nvvm_reflect:
     Changed |= setRetAndArgsNoUndef(F);
     Changed |= setDoesNotAccessMemory(F);
     Changed |= setDoesNotThrow(F);
     return Changed;
   case LibFunc_ldexp:
   case LibFunc_ldexpf:
   case LibFunc_ldexpl:
     Changed |= setArgExtAttr(F, 1, TLI);
     Changed |= setWillReturn(F);
     return Changed;
   case LibFunc_abs:
+  case LibFunc_ffs:
+  case LibFunc_isascii:
+  case LibFunc_isdigit:
+  case LibFunc_toascii:
+    Changed |= setArgExtAttr(F, 0, TLI);
+    LLVM_FALLTHROUGH;
   case LibFunc_acos:
   case LibFunc_acosf:
   case LibFunc_acosh:
   case LibFunc_acoshf:
   case LibFunc_acoshl:
   case LibFunc_acosl:
   case LibFunc_asin:
   case LibFunc_asinf:
bool llvm::inferLibFuncAttributes(Function &F, const TargetLibraryInfo &TLI) {
   case LibFunc_exp2f:
   case LibFunc_exp2l:
   case LibFunc_expm1:
   case LibFunc_expm1f:
   case LibFunc_expm1l:
   case LibFunc_fabs:
   case LibFunc_fabsf:
   case LibFunc_fabsl:
-  case LibFunc_ffs:
   case LibFunc_ffsl:
   case LibFunc_ffsll:
   case LibFunc_floor:
   case LibFunc_floorf:
   case LibFunc_floorl:
   case LibFunc_fls:
   case LibFunc_flsl:
   case LibFunc_flsll:
   case LibFunc_fmax:
   case LibFunc_fmaxf:
   case LibFunc_fmaxl:
   case LibFunc_fmin:
   case LibFunc_fminf:
   case LibFunc_fminl:
   case LibFunc_fmod:
   case LibFunc_fmodf:
   case LibFunc_fmodl:
-  case LibFunc_isascii:
-  case LibFunc_isdigit:
   case LibFunc_labs:
   case LibFunc_llabs:
   case LibFunc_log:
   case LibFunc_log10:
   case LibFunc_log10f:
   case LibFunc_log10l:
   case LibFunc_log1p:
   case LibFunc_log1pf:
bool llvm::inferLibFuncAttributes(Function &F, const TargetLibraryInfo &TLI) {
   case LibFunc_sqrtf:
   case LibFunc_sqrtl:
   case LibFunc_tan:
   case LibFunc_tanf:
   case LibFunc_tanh:
   case LibFunc_tanhf:
   case LibFunc_tanhl:
   case LibFunc_tanl:
-  case LibFunc_toascii:
   case LibFunc_trunc:
   case LibFunc_truncf:
   case LibFunc_truncl:
     Changed |= setDoesNotThrow(F);
     Changed |= setDoesNotFreeMemory(F);
     Changed |= setOnlyWritesMemory(F);
     Changed |= setWillReturn(F);
     return Changed;
StringRef llvm::getFloatFnName(const TargetLibraryInfo *TLI, Type *Ty,
                                LibFunc DoubleFn, LibFunc FloatFn,
                                LibFunc LongDoubleFn) {
   assert(hasFloatFn(TLI, Ty, DoubleFn, FloatFn, LongDoubleFn) &&
          "Cannot get name for unavailable function!");
 
   switch (Ty->getTypeID()) {
   case Type::HalfTyID:
     llvm_unreachable("No name for HalfTy!");
   case Type::FloatTyID:
     return TLI->getName(FloatFn);
   case Type::DoubleTyID:
     return TLI->getName(DoubleFn);
   default:
     return TLI->getName(LongDoubleFn);
   }
 }
 
 //- Emit LibCalls ------------------------------------------------------------//
 
 Value *llvm::castToCStr(Value *V, IRBuilderBase &B) {
   unsigned AS = V->getType()->getPointerAddressSpace();
   return B.CreateBitCast(V, B.getInt8PtrTy(AS), "cstr");
 }
 
 static Value *emitLibCall(LibFunc TheLibFunc, Type *ReturnType,
                           ArrayRef<Type *> ParamTypes,
                           ArrayRef<Value *> Operands, IRBuilderBase &B,
                           const TargetLibraryInfo *TLI,
                           bool IsVaArgs = false) {
   if (!TLI->has(TheLibFunc))
     return nullptr;
 
   Module *M = B.GetInsertBlock()->getModule();
   StringRef FuncName = TLI->getName(TheLibFunc);
   FunctionType *FuncType = FunctionType::get(ReturnType, ParamTypes, IsVaArgs);
   FunctionCallee Callee = M->getOrInsertFunction(FuncName, FuncType);
   inferLibFuncAttributes(M, FuncName, *TLI);
   CallInst *CI = B.CreateCall(Callee, Operands, FuncName);
   if (const Function *F =
           dyn_cast<Function>(Callee.getCallee()->stripPointerCasts()))
     CI->setCallingConv(F->getCallingConv());
   return CI;
 }
 
 Value *llvm::emitStrLen(Value *Ptr, IRBuilderBase &B, const DataLayout &DL,
                         const TargetLibraryInfo *TLI) {
   LLVMContext &Context = B.GetInsertBlock()->getContext();
   return emitLibCall(LibFunc_strlen, DL.getIntPtrType(Context),
                      B.getInt8PtrTy(), castToCStr(Ptr, B), B, TLI);
 }
Value *llvm::emitStrChr(Value *Ptr, char C, IRBuilderBase &B,
   Type *I32Ty = B.getInt32Ty();
   return emitLibCall(LibFunc_strchr, I8Ptr, {I8Ptr, I32Ty},
                      {castToCStr(Ptr, B), ConstantInt::get(I32Ty, C)}, B, TLI);
 }
 
 Value *llvm::emitStrNCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilderBase &B,
                          const DataLayout &DL, const TargetLibraryInfo *TLI) {
   LLVMContext &Context = B.GetInsertBlock()->getContext();
   return emitLibCall(
       LibFunc_strncmp, B.getInt32Ty(),
       {B.getInt8PtrTy(), B.getInt8PtrTy(), DL.getIntPtrType(Context)},
       {castToCStr(Ptr1, B), castToCStr(Ptr2, B), Len}, B, TLI);
 }
 
 Value *llvm::emitStrCpy(Value *Dst, Value *Src, IRBuilderBase &B,
                         const TargetLibraryInfo *TLI) {
   Type *I8Ptr = Dst->getType();

llvm/test/Transforms/InferFunctionAttrs/annotate.ll

 
 ; CHECK: declare double @__sinpi(double)
 declare double @__sinpi(double)
 
 ; CHECK: declare float @__sinpif(float)
 declare float @__sinpif(float)
 
 ; CHECK: declare i32 @abs(i32) [[NOFREE_NOUNWIND_WILLRETURN_WRITEONLY:#[0-9]+]]
+; CHECK-SYSTEMZ: declare i32 @abs(i32 signext)
 declare i32 @abs(i32)
 
 ; CHECK: declare noundef i32 @access(i8* nocapture noundef readonly, i32 noundef) [[NOFREE_NOUNWIND:#[0-9]+]]
+; CHECK-SYSTEMZ: declare noundef i32 @access(i8* nocapture noundef readonly, i32 noundef signext)
 declare i32 @access(i8*, i32)
 
 ; CHECK: declare double @acos(double) [[NOFREE_NOUNWIND_WILLRETURN_WRITEONLY]]
 declare double @acos(double)
 
 ; CHECK: declare float @acosf(float) [[NOFREE_NOUNWIND_WILLRETURN_WRITEONLY]]
 declare float @acosf(float)
 

 ; CHECK: declare float @ceilf(float) [[NOFREE_NOUNWIND_WILLRETURN_WRITEONLY]]
 declare float @ceilf(float)
 
 ; CHECK: declare x86_fp80 @ceill(x86_fp80) [[NOFREE_NOUNWIND_WILLRETURN_WRITEONLY]]
 declare x86_fp80 @ceill(x86_fp80)
 
 ; CHECK: declare noundef i32 @chmod(i8* nocapture noundef readonly, i16 noundef zeroext) [[NOFREE_NOUNWIND]]
 declare i32 @chmod(i8*, i16 zeroext)
 
-; CHECK: declare noundef i32 @chown(i8* nocapture noundef readonly, i32 noundef, i32 noundef) [[NOFREE_NOUNWIND]]
-declare i32 @chown(i8*, i32, i32)
-
 ; CHECK: declare void @clearerr(%opaque* nocapture noundef) [[NOFREE_NOUNWIND]]
 declare void @clearerr(%opaque*)
 
 ; CHECK: declare noundef i32 @closedir(%opaque* nocapture noundef) [[NOFREE_NOUNWIND]]
 declare i32 @closedir(%opaque*)
 
 ; CHECK: declare double @copysign(double, double) [[NOFREE_NOUNWIND_WILLRETURN_WRITEONLY]]
 declare double @copysign(double, double)

 
 ; CHECK: declare x86_fp80 @fabsl(x86_fp80) [[NOFREE_NOUNWIND_WILLRETURN_WRITEONLY]]
 declare x86_fp80 @fabsl(x86_fp80)
 
 ; CHECK: declare noundef i32 @fclose(%opaque* nocapture noundef) [[NOFREE_NOUNWIND]]
 declare i32 @fclose(%opaque*)
 
 ; CHECK: declare noalias noundef %opaque* @fdopen(i32 noundef, i8* nocapture noundef readonly) [[NOFREE_NOUNWIND]]
+; CHECK-SYSTEMZ: declare noalias noundef %opaque* @fdopen(i32 noundef signext, i8* nocapture noundef readonly)
 declare %opaque* @fdopen(i32, i8*)
 
 ; CHECK: declare noundef i32 @feof(%opaque* nocapture noundef) [[NOFREE_NOUNWIND]]
 declare i32 @feof(%opaque*)
 
 ; CHECK: declare noundef i32 @ferror(%opaque* nocapture noundef) [[NOFREE_NOUNWIND_READONLY:#[0-9]+]]
 declare i32 @ferror(%opaque*)
 
 ; CHECK: declare noundef i32 @fflush(%opaque* nocapture noundef) [[NOFREE_NOUNWIND]]
 declare i32 @fflush(%opaque*)
 
 ; CHECK: declare i32 @ffs(i32) [[NOFREE_NOUNWIND_WILLRETURN_WRITEONLY]]
+; CHECK-SYSTEMZ: declare i32 @ffs(i32 signext)
 declare i32 @ffs(i32)
 
 ; CHECK-KNOWN: declare i32 @ffsl(i64) [[NOFREE_NOUNWIND_WILLRETURN_WRITEONLY]]
 ; CHECK-UNKNOWN: declare i32 @ffsl(i64){{$}}
 declare i32 @ffsl(i64)
 
 ; CHECK-KNOWN: declare i32 @ffsll(i64) [[NOFREE_NOUNWIND_WILLRETURN_WRITEONLY]]
 ; CHECK-UNKNOWN: declare i32 @ffsll(i64){{$}}
 declare i32 @ffsll(i64)
 
 ; CHECK: declare noundef i32 @fgetc(%opaque* nocapture noundef) [[NOFREE_NOUNWIND]]
 declare i32 @fgetc(%opaque*)
 
 ; CHECK: declare noundef i32 @fgetpos(%opaque* nocapture noundef, i64* nocapture noundef) [[NOFREE_NOUNWIND]]
 declare i32 @fgetpos(%opaque*, i64*)
 
 ; CHECK: declare noundef i8* @fgets(i8* noundef, i32 noundef, %opaque* nocapture noundef) [[NOFREE_NOUNWIND]]
+; CHECK-SYSTEMZ: declare noundef i8* @fgets(i8* noundef, i32 noundef signext, %opaque* nocapture noundef)
 declare i8* @fgets(i8*, i32, %opaque*)
 
+; CHECK-SYSTEMZ: declare noundef i8* @fgets_unlocked(i8* noundef, i32 noundef signext, %opaque* nocapture noundef)
+declare i8* @fgets_unlocked(i8*, i32, %opaque*)
+
 ; CHECK: declare noundef i32 @fileno(%opaque* nocapture noundef) [[NOFREE_NOUNWIND]]
 declare i32 @fileno(%opaque*)
 
 ; CHECK: declare void @flockfile(%opaque* nocapture noundef) [[NOFREE_NOUNWIND]]
 declare void @flockfile(%opaque*)
 
 ; CHECK: declare double @floor(double) [[NOFREE_NOUNWIND_WILLRETURN_WRITEONLY]]
 declare double @floor(double)

 
 ; CHECK: declare noalias noundef %opaque* @fopen(i8* nocapture noundef readonly, i8* nocapture noundef readonly) [[NOFREE_NOUNWIND]]
 declare %opaque* @fopen(i8*, i8*)
 
 ; CHECK: declare noundef i32 @fprintf(%opaque* nocapture noundef, i8* nocapture noundef readonly, ...) [[NOFREE_NOUNWIND]]
 declare i32 @fprintf(%opaque*, i8*, ...)
 
 ; CHECK: declare noundef i32 @fputc(i32 noundef, %opaque* nocapture noundef) [[NOFREE_NOUNWIND]]
+; CHECK-SYSTEMZ: declare noundef i32 @fputc(i32 noundef signext, %opaque* nocapture noundef)
 declare i32 @fputc(i32, %opaque*)
 
+; CHECK-SYSTEMZ: declare noundef i32 @fputc_unlocked(i32 noundef signext, %opaque* nocapture noundef)
+declare i32 @fputc_unlocked(i32, %opaque*)
+
 ; CHECK: declare noundef i32 @fputs(i8* nocapture noundef readonly, %opaque* nocapture noundef) [[NOFREE_NOUNWIND]]
 declare i32 @fputs(i8*, %opaque*)
 
 ; CHECK: declare noundef i64 @fread(i8* nocapture noundef, i64 noundef, i64 noundef, %opaque* nocapture noundef) [[NOFREE_NOUNWIND]]
 declare i64 @fread(i8*, i64, i64, %opaque*)
 
 ; CHECK: declare void @free(i8* nocapture noundef) [[INACCESSIBLEMEMORARGMEMONLY_NOUNWIND_WILLRETURN:#[0-9]+]]
 declare void @free(i8*)
 
 ; CHECK: declare double @frexp(double, i32* nocapture) [[NOFREE_NOUNWIND_WILLRETURN:#[0-9]+]]
 declare double @frexp(double, i32*)
 
 ; CHECK: declare float @frexpf(float, i32* nocapture) [[NOFREE_NOUNWIND_WILLRETURN]]
 declare float @frexpf(float, i32*)
 
 ; CHECK: declare x86_fp80 @frexpl(x86_fp80, i32* nocapture) [[NOFREE_NOUNWIND_WILLRETURN]]
 declare x86_fp80 @frexpl(x86_fp80, i32*)
 
 ; CHECK: declare noundef i32 @fscanf(%opaque* nocapture noundef, i8* nocapture noundef readonly, ...) [[NOFREE_NOUNWIND]]
 declare i32 @fscanf(%opaque*, i8*, ...)
 
 ; CHECK: declare noundef i32 @fseek(%opaque* nocapture noundef, i64 noundef, i32 noundef) [[NOFREE_NOUNWIND]]
+; CHECK-SYSTEMZ: declare noundef i32 @fseek(%opaque* nocapture noundef, i64 noundef, i32 noundef signext)
 declare i32 @fseek(%opaque*, i64, i32)
 
 ; CHECK: declare noundef i32 @fseeko(%opaque* nocapture noundef, i64 noundef, i32 noundef) [[NOFREE_NOUNWIND]]
+; CHECK-SYSTEMZ: declare noundef i32 @fseeko(%opaque* nocapture noundef, i64 noundef, i32 noundef signext)
 declare i32 @fseeko(%opaque*, i64, i32)
 
 ; CHECK-LINUX: declare noundef i32 @fseeko64(%opaque* nocapture noundef, i64 noundef, i32 noundef) [[NOFREE_NOUNWIND]]
+; CHECK-SYSTEMZ: declare noundef i32 @fseeko64(%opaque* nocapture noundef, i64 noundef, i32 noundef signext)
 declare i32 @fseeko64(%opaque*, i64, i32)
 
 ; CHECK: declare noundef i32 @fsetpos(%opaque* nocapture noundef, i64* noundef) [[NOFREE_NOUNWIND]]
 declare i32 @fsetpos(%opaque*, i64*)
 
 ; CHECK: declare noundef i32 @fstat(i32 noundef, %opaque* nocapture noundef) [[NOFREE_NOUNWIND]]
+; CHECK-SYSTEMZ: declare noundef i32 @fstat(i32 noundef signext, %opaque* nocapture noundef)
 declare i32 @fstat(i32, %opaque*)
 
 ; CHECK-LINUX: declare noundef i32 @fstat64(i32 noundef, %opaque* nocapture noundef) [[NOFREE_NOUNWIND]]
+; CHECK-SYSTEMZ: declare noundef i32 @fstat64(i32 noundef signext, %opaque* nocapture noundef)
 declare i32 @fstat64(i32, %opaque*)
 
 ; CHECK: declare noundef i32 @fstatvfs(i32 noundef, %opaque* nocapture noundef) [[NOFREE_NOUNWIND]]
+; CHECK-SYSTEMZ: declare noundef i32 @fstatvfs(i32 noundef signext, %opaque* nocapture noundef)
 declare i32 @fstatvfs(i32, %opaque*)
 
 ; CHECK-LINUX: declare noundef i32 @fstatvfs64(i32 noundef, %opaque* nocapture noundef) [[NOFREE_NOUNWIND]]
+; CHECK-SYSTEMZ: declare noundef i32 @fstatvfs64(i32 noundef signext, %opaque* nocapture noundef)
 declare i32 @fstatvfs64(i32, %opaque*)
 
 ; CHECK: declare noundef i64 @ftell(%opaque* nocapture noundef) [[NOFREE_NOUNWIND]]
 declare i64 @ftell(%opaque*)
 
 ; CHECK: declare noundef i64 @ftello(%opaque* nocapture noundef) [[NOFREE_NOUNWIND]]
 declare i64 @ftello(%opaque*)
 

 ; CHECK-KNOWN: declare noundef i32 @getchar_unlocked() [[NOFREE_NOUNWIND]]
 ; CHECK-UNKNOWN: declare i32 @getchar_unlocked(){{$}}
 declare i32 @getchar_unlocked()
 
 ; CHECK: declare noundef i8* @getenv(i8* nocapture noundef) [[NOFREE_NOUNWIND_READONLY]]
 declare i8* @getenv(i8*)
 
 ; CHECK: declare noundef i32 @getitimer(i32 noundef, %opaque* nocapture noundef) [[NOFREE_NOUNWIND]]
+; CHECK-SYSTEMZ: declare noundef i32 @getitimer(i32 noundef signext, %opaque* nocapture noundef)
 declare i32 @getitimer(i32, %opaque*)
 
 ; CHECK: declare noundef i32 @getlogin_r(i8* nocapture noundef, i64 noundef) [[NOFREE_NOUNWIND]]
 declare i32 @getlogin_r(i8*, i64)
 
 ; CHECK: declare noundef %opaque* @getpwnam(i8* nocapture noundef readonly) [[NOFREE_NOUNWIND]]
 declare %opaque* @getpwnam(i8*)
 
 ; CHECK: declare noundef i8* @gets(i8* noundef) [[NOFREE_NOUNWIND]]
 declare i8* @gets(i8*)
 
 ; CHECK: declare noundef i32 @gettimeofday(%opaque* nocapture noundef, i8* nocapture noundef) [[NOFREE_NOUNWIND]]
 declare i32 @gettimeofday(%opaque*, i8*)
 
+; CHECK-SYSTEMZ: declare i32 @htonl(i32 zeroext)
+declare i32 @htonl(i32)
+
+; CHECK-SYSTEMZ: declare i16 @htons(i16 zeroext)
+declare i16 @htons(i16)
+
 ; CHECK: declare i32 @isascii(i32) [[NOFREE_NOUNWIND_WILLRETURN_WRITEONLY]]
+; CHECK-SYSTEMZ: declare i32 @isascii(i32 signext)
 declare i32 @isascii(i32)
 
 ; CHECK: declare i32 @isdigit(i32) [[NOFREE_NOUNWIND_WILLRETURN_WRITEONLY]]
+; CHECK-SYSTEMZ: declare i32 @isdigit(i32 signext)
 declare i32 @isdigit(i32)
 
 ; CHECK: declare i64 @labs(i64) [[NOFREE_NOUNWIND_WILLRETURN_WRITEONLY]]
 declare i64 @labs(i64)
 
-; CHECK: declare noundef i32 @lchown(i8* nocapture noundef readonly, i32 noundef, i32 noundef) [[NOFREE_NOUNWIND]]
-declare i32 @lchown(i8*, i32, i32)
-
 ; CHECK: declare double @ldexp(double, i32) [[NOFREE_WILLRETURN:#[0-9]+]]
 ; CHECK-SYSTEMZ: declare double @ldexp(double, i32 signext)
 declare double @ldexp(double, i32)
 
 ; CHECK: declare float @ldexpf(float, i32) [[NOFREE_WILLRETURN]]
 ; CHECK-SYSTEMZ: declare float @ldexpf(float, i32 signext)
 declare float @ldexpf(float, i32)
 

 
 ; CHECK: declare noalias noundef i8* @malloc(i64 noundef) [[INACCESSIBLEMEMONLY_NOFREE_NOUNWIND_WILLRETURN]]
 declare i8* @malloc(i64)
 
 ; CHECK-LINUX: declare noalias noundef i8* @memalign(i64 allocalign, i64) [[INACCESSIBLEMEMONLY_NOFREE_NOUNWIND_WILLRETURN:#[0-9]+]]
 declare i8* @memalign(i64, i64)
 
 ; CHECK: declare i8* @memccpy(i8* noalias writeonly, i8* noalias nocapture readonly, i32, i64) [[ARGMEMONLY_NOFREE_NOUNWIND_WILLRETURN]]
+; CHECK-SYSTEMZ: declare i8* @memccpy(i8* noalias writeonly, i8* noalias nocapture readonly, i32 signext, i64)
 declare i8* @memccpy(i8*, i8*, i32, i64)
 
 ; CHECK-LINUX:   declare i8* @memchr(i8*, i32, i64) [[ARGMEMONLY_NOFREE_NOUNWIND_READONLY]]
 ; CHECK-DARWIN:  declare i8* @memchr(i8*, i32, i64) [[ARGMEMONLY_NOFREE_NOUNWIND_READONLY:#[0-9]+]]
 ; CHECK-UNKNOWN: declare i8* @memchr(i8*, i32, i64) [[ARGMEMONLY_NOFREE_NOUNWIND_READONLY:#[0-9]+]]
+; CHECK-SYSTEMZ: declare i8* @memchr(i8*, i32 signext, i64)
 declare i8* @memchr(i8*, i32, i64)
 
+; CHECK-SYSTEMZ: declare i8* @memrchr(i8*, i32 signext, i64)
+declare i8* @memrchr(i8*, i32, i64)
+
 ; CHECK: declare i32 @memcmp(i8* nocapture, i8* nocapture, i64) [[ARGMEMONLY_NOFREE_NOUNWIND_READONLY]]
 declare i32 @memcmp(i8*, i8*, i64)
 
 ; CHECK: declare i8* @memcpy(i8* noalias returned writeonly, i8* noalias nocapture readonly, i64) [[ARGMEMONLY_NOFREE_NOUNWIND_WILLRETURN]]
 declare i8* @memcpy(i8*, i8*, i64)
 
 ; CHECK: declare i8* @__memcpy_chk(i8* noalias writeonly, i8* noalias nocapture readonly, i64, i64) [[ARGMEMONLY_NOFREE_NOUNWIND:#[0-9]+]]
 declare i8* @__memcpy_chk(i8*, i8*, i64, i64)
 
 ; CHECK: declare i8* @mempcpy(i8* noalias writeonly, i8* noalias nocapture readonly, i64) [[ARGMEMONLY_NOFREE_NOUNWIND_WILLRETURN]]
 declare i8* @mempcpy(i8*, i8*, i64)
 
 ; CHECK: declare i8* @memmove(i8* returned writeonly, i8* nocapture readonly, i64) [[ARGMEMONLY_NOFREE_NOUNWIND_WILLRETURN]]
 declare i8* @memmove(i8*, i8*, i64)
 
 ; CHECK: declare i8* @memset(i8* writeonly, i32, i64) [[ARGMEMONLY_NOFREE_NOUNWIND_WILLRETURN:#[0-9]+]]
+; CHECK-SYSTEMZ: declare i8* @memset(i8* writeonly, i32 signext, i64)
 declare i8* @memset(i8*, i32, i64)
 
 ; CHECK: declare i8* @__memset_chk(i8* writeonly, i32, i64, i64) [[ARGMEMONLY_NOFREE_NOUNWIND]]
+; CHECK-SYSTEMZ: declare i8* @__memset_chk(i8* writeonly, i32 signext, i64, i64)
 declare i8* @__memset_chk(i8*, i32, i64, i64)
 
 ; CHECK: declare noundef i32 @mkdir(i8* nocapture noundef readonly, i16 noundef zeroext) [[NOFREE_NOUNWIND]]
 declare i32 @mkdir(i8*, i16 zeroext)
 
 ; CHECK: declare noundef i64 @mktime(%opaque* nocapture noundef) [[NOFREE_NOUNWIND_WILLRETURN]]
 declare i64 @mktime(%opaque*)
 

 declare double @nearbyint(double)
 
 ; CHECK: declare float @nearbyintf(float) [[NOFREE_NOUNWIND_WILLRETURN_WRITEONLY]]
 declare float @nearbyintf(float)
 
 ; CHECK: declare x86_fp80 @nearbyintl(x86_fp80) [[NOFREE_NOUNWIND_WILLRETURN_WRITEONLY]]
 declare x86_fp80 @nearbyintl(x86_fp80)
 
+; CHECK-SYSTEMZ: declare i32 @ntohl(i32 zeroext)
+declare i32 @ntohl(i32)
+
+; CHECK-SYSTEMZ: declare i16 @ntohs(i16 zeroext)
+declare i16 @ntohs(i16)
+
 ; CHECK-LINUX: declare noundef i32 @open(i8* nocapture noundef readonly, i32 noundef, ...) [[NOFREE]]
 ; CHECK-OPEN: declare noundef i32 @open(i8* nocapture noundef readonly, i32 noundef, ...) [[NOFREE:#[0-9]+]]
+; CHECK-SYSTEMZ: declare noundef i32 @open(i8* nocapture noundef readonly, i32 noundef signext, ...)
 declare i32 @open(i8*, i32, ...)
 
 ; CHECK-LINUX: declare noundef i32 @open64(i8* nocapture noundef readonly, i32 noundef, ...) [[NOFREE]]
+; CHECK-SYSTEMZ: declare noundef i32 @open64(i8* nocapture noundef readonly, i32 noundef signext, ...)
 declare i32 @open64(i8*, i32, ...)
 
 ; CHECK: declare noalias noundef %opaque* @opendir(i8* nocapture noundef readonly) [[NOFREE_NOUNWIND]]
 declare %opaque* @opendir(i8*)
 
 ; CHECK: declare noundef i32 @pclose(%opaque* nocapture noundef) [[NOFREE_NOUNWIND]]
 declare i32 @pclose(%opaque*)
 

 
 ; CHECK: declare float @powf(float, float) [[NOFREE_NOUNWIND_WILLRETURN_WRITEONLY]]
 declare float @powf(float, float)
 
 ; CHECK: declare x86_fp80 @powl(x86_fp80, x86_fp80) [[NOFREE_NOUNWIND_WILLRETURN_WRITEONLY]]
 declare x86_fp80 @powl(x86_fp80, x86_fp80)
 
 ; CHECK: declare noundef i64 @pread(i32 noundef, i8* nocapture noundef, i64 noundef, i64 noundef) [[NOFREE]]
+; CHECK-SYSTEMZ: declare noundef i64 @pread(i32 noundef signext, i8* nocapture noundef, i64 noundef, i64 noundef)
 declare i64 @pread(i32, i8*, i64, i64)
 
 ; CHECK: declare noundef i32 @printf(i8* nocapture noundef readonly, ...) [[NOFREE_NOUNWIND]]
 declare i32 @printf(i8*, ...)
 
 ; CHECK: declare noundef i32 @putc(i32 noundef, %opaque* nocapture noundef) [[NOFREE_NOUNWIND]]
+; CHECK-SYSTEMZ: declare noundef i32 @putc(i32 noundef signext, %opaque* nocapture noundef)
 declare i32 @putc(i32, %opaque*)
 
+; CHECK-SYSTEMZ: declare noundef i32 @putc_unlocked(i32 noundef signext, %opaque* nocapture noundef)
+declare i32 @putc_unlocked(i32, %opaque*)
+
 ; CHECK: declare noundef i32 @putchar(i32 noundef) [[NOFREE_NOUNWIND]]
 ; CHECK-SYSTEMZ: declare noundef i32 @putchar(i32 noundef signext)
 declare i32 @putchar(i32)
 
 ; CHECK-KNOWN: declare noundef i32 @putchar_unlocked(i32 noundef) [[NOFREE_NOUNWIND]]
 ; CHECK-UNKNOWN: declare i32 @putchar_unlocked(i32){{$}}
 ; CHECK-SYSTEMZ: declare noundef i32 @putchar_unlocked(i32 noundef signext)
 declare i32 @putchar_unlocked(i32)
 
 ; CHECK: declare noundef i32 @puts(i8* nocapture noundef readonly) [[NOFREE_NOUNWIND]]
 declare i32 @puts(i8*)
 
 ; CHECK: declare noundef i64 @pwrite(i32 noundef, i8* nocapture noundef readonly, i64 noundef, i64 noundef) [[NOFREE]]
+; CHECK-SYSTEMZ: declare noundef i64 @pwrite(i32 noundef signext, i8* nocapture noundef readonly, i64 noundef, i64 noundef)
 declare i64 @pwrite(i32, i8*, i64, i64)
 
 ; CHECK: declare void @qsort(i8* noundef, i64 noundef, i64 noundef, i32 (i8*, i8*)* nocapture noundef) [[NOFREE]]
 declare void @qsort(i8*, i64, i64, i32 (i8*, i8*)*)
 
 ; CHECK: declare noundef i64 @read(i32 noundef, i8* nocapture noundef, i64 noundef) [[NOFREE]]
+; CHECK-SYSTEMZ: declare noundef i64 @read(i32 noundef signext, i8* nocapture noundef, i64 noundef)
 declare i64 @read(i32, i8*, i64)
 
 ; CHECK: declare noundef i64 @readlink(i8* nocapture noundef readonly, i8* nocapture noundef, i64 noundef) [[NOFREE_NOUNWIND]]
 declare i64 @readlink(i8*, i8*, i64)
 
 ; CHECK: declare noalias noundef i8* @realloc(i8* nocapture, i64 noundef) [[INACCESSIBLEMEMORARGMEMONLY_NOUNWIND_WILLRETURN]]
 declare i8* @realloc(i8*, i64)
 

 
 ; CHECK: declare noundef i32 @scanf(i8* nocapture noundef readonly, ...) [[NOFREE_NOUNWIND]]
 declare i32 @scanf(i8*, ...)
 
 ; CHECK: declare void @setbuf(%opaque* nocapture noundef, i8* noundef) [[NOFREE_NOUNWIND]]
 declare void @setbuf(%opaque*, i8*)
 
 ; CHECK: declare noundef i32 @setitimer(i32 noundef, %opaque* nocapture noundef readonly, %opaque* nocapture noundef) [[NOFREE_NOUNWIND_WILLRETURN]]
+; CHECK-SYSTEMZ: declare noundef i32 @setitimer(i32 noundef signext, %opaque* nocapture noundef readonly, %opaque* nocapture noundef)
 declare i32 @setitimer(i32, %opaque*, %opaque*)
 
 ; CHECK: declare noundef i32 @setvbuf(%opaque* nocapture noundef, i8* noundef, i32 noundef, i64 noundef) [[NOFREE_NOUNWIND]]
+; CHECK-SYSTEMZ: declare noundef i32 @setvbuf(%opaque* nocapture noundef, i8* noundef, i32 noundef signext, i64 noundef)
 declare i32 @setvbuf(%opaque*, i8*, i32, i64)
 
 ; CHECK: declare double @sin(double) [[NOFREE_NOUNWIND_WILLRETURN_WRITEONLY]]
 declare double @sin(double)
 
 ; CHECK: declare float @sinf(float) [[NOFREE_NOUNWIND_WILLRETURN_WRITEONLY]]
 declare float @sinf(float)
 

 
 ; CHECK: declare i32 @strcasecmp(i8* nocapture, i8* nocapture) [[NOFREE_NOUNWIND_READONLY_WILLRETURN:#[0-9]+]]
 declare i32 @strcasecmp(i8*, i8*)
 
 ; CHECK: declare i8* @strcat(i8* noalias returned, i8* noalias nocapture readonly) [[ARGMEMONLY_NOFREE_NOUNWIND_WILLRETURN]]
 declare i8* @strcat(i8*, i8*)
 
 ; CHECK: declare i8* @strchr(i8*, i32) [[ARGMEMONLY_NOFREE_NOUNWIND_READONLY]]
+; CHECK-SYSTEMZ: declare i8* @strchr(i8*, i32 signext)
 declare i8* @strchr(i8*, i32)
 
 ; CHECK: declare i32 @strcmp(i8* nocapture, i8* nocapture) [[ARGMEMONLY_NOFREE_NOUNWIND_READONLY]]
 declare i32 @strcmp(i8*, i8*)
 
 ; CHECK: declare i32 @strcoll(i8* nocapture, i8* nocapture) [[NOFREE_NOUNWIND_READONLY_WILLRETURN]]
 declare i32 @strcoll(i8*, i8*)
 

 
 ; CHECK: declare i64 @strnlen(i8* nocapture, i64) [[ARGMEMONLY_NOFREE_NOUNWIND_READONLY_WILLRETURN:#[0-9]+]]
 declare i64 @strnlen(i8*, i64)
 
 ; CHECK: declare i8* @strpbrk(i8*, i8* nocapture) [[ARGMEMONLY_NOFREE_NOUNWIND_READONLY_WILLRETURN]]
 declare i8* @strpbrk(i8*, i8*)
 
 ; CHECK: declare i8* @strrchr(i8*, i32) [[ARGMEMONLY_NOFREE_NOUNWIND_READONLY]]
+; CHECK-SYSTEMZ: declare i8* @strrchr(i8*, i32 signext)
 declare i8* @strrchr(i8*, i32)
 
 ; CHECK: declare i64 @strspn(i8* nocapture, i8* nocapture) [[ARGMEMONLY_NOFREE_NOUNWIND_READONLY]]
 declare i64 @strspn(i8*, i8*)
 
 ; CHECK: declare i8* @strstr(i8*, i8* nocapture) [[ARGMEMONLY_NOFREE_NOUNWIND_READONLY_WILLRETURN]]
 declare i8* @strstr(i8*, i8*)
 
 ; CHECK: declare double @strtod(i8* readonly, i8** nocapture) [[NOFREE_NOUNWIND_WILLRETURN]]
 declare double @strtod(i8*, i8**)
 
 ; CHECK: declare float @strtof(i8* readonly, i8** nocapture) [[NOFREE_NOUNWIND_WILLRETURN]]
 declare float @strtof(i8*, i8**)
 
 ; CHECK: declare i8* @strtok(i8*, i8* nocapture readonly) [[NOFREE_NOUNWIND_WILLRETURN]]
 declare i8* @strtok(i8*, i8*)
 
 ; CHECK: declare i8* @strtok_r(i8*, i8* nocapture readonly, i8**) [[NOFREE_NOUNWIND_WILLRETURN]]
 declare i8* @strtok_r(i8*, i8*, i8**)
 
 ; CHECK: declare i64 @strtol(i8* readonly, i8** nocapture, i32) [[NOFREE_NOUNWIND_WILLRETURN]]
+; CHECK-SYSTEMZ: declare i64 @strtol(i8* readonly, i8** nocapture, i32 signext)
 declare i64 @strtol(i8*, i8**, i32)
 
 ; CHECK: declare x86_fp80 @strtold(i8* readonly, i8** nocapture) [[NOFREE_NOUNWIND_WILLRETURN]]
 declare x86_fp80 @strtold(i8*, i8**)
 
 ; CHECK: declare i64 @strtoll(i8* readonly, i8** nocapture, i32) [[NOFREE_NOUNWIND_WILLRETURN]]
+; CHECK-SYSTEMZ: declare i64 @strtoll(i8* readonly, i8** nocapture, i32 signext)
 declare i64 @strtoll(i8*, i8**, i32)
 
 ; CHECK: declare i64 @strtoul(i8* readonly, i8** nocapture, i32) [[NOFREE_NOUNWIND_WILLRETURN]]
+; CHECK-SYSTEMZ: declare i64 @strtoul(i8* readonly, i8** nocapture, i32 signext)
 declare i64 @strtoul(i8*, i8**, i32)
 
 ; CHECK: declare i64 @strtoull(i8* readonly, i8** nocapture, i32) [[NOFREE_NOUNWIND_WILLRETURN]]
+; CHECK-SYSTEMZ: declare i64 @strtoull(i8* readonly, i8** nocapture, i32 signext)
 declare i64 @strtoull(i8*, i8**, i32)
 
 ; CHECK: declare i64 @strxfrm(i8* nocapture, i8* nocapture readonly, i64) [[NOFREE_NOUNWIND_WILLRETURN]]
 declare i64 @strxfrm(i8*, i8*, i64)
 
 ; CHECK: declare noundef i32 @system(i8* nocapture noundef readonly) [[NOFREE]]
 declare i32 @system(i8*)
 

 
 ; CHECK: declare noalias noundef %opaque* @tmpfile() [[NOFREE_NOUNWIND]]
 declare %opaque* @tmpfile()
 
 ; CHECK-LINUX: declare noalias noundef %opaque* @tmpfile64() [[NOFREE_NOUNWIND]]
 declare %opaque* @tmpfile64()
 
 ; CHECK: declare i32 @toascii(i32) [[NOFREE_NOUNWIND_WILLRETURN_WRITEONLY]]
+; CHECK-SYSTEMZ: declare i32 @toascii(i32 signext)
 declare i32 @toascii(i32)
 
 ; CHECK: declare double @trunc(double) [[NOFREE_NOUNWIND_WILLRETURN_WRITEONLY]]
 declare double @trunc(double)
 
 ; CHECK: declare float @truncf(float) [[NOFREE_NOUNWIND_WILLRETURN_WRITEONLY]]
 declare float @truncf(float)
 
 ; CHECK: declare x86_fp80 @truncl(x86_fp80) [[NOFREE_NOUNWIND_WILLRETURN_WRITEONLY]]
 declare x86_fp80 @truncl(x86_fp80)
 
 ; CHECK: declare noundef i32 @uname(%opaque* nocapture noundef) [[NOFREE_NOUNWIND]]
 declare i32 @uname(%opaque*)
 
 ; CHECK: declare noundef i32 @ungetc(i32 noundef, %opaque* nocapture noundef) [[NOFREE_NOUNWIND]]
+; CHECK-SYSTEMZ: declare noundef i32 @ungetc(i32 noundef signext, %opaque* nocapture noundef)
 declare i32 @ungetc(i32, %opaque*)
 
 ; CHECK: declare noundef i32 @unlink(i8* nocapture noundef readonly) [[NOFREE_NOUNWIND]]
 declare i32 @unlink(i8*)
 
 ; CHECK: declare noundef i32 @unsetenv(i8* nocapture noundef readonly) [[NOFREE_NOUNWIND]]
 declare i32 @unsetenv(i8*)
 

 
 ; CHECK: declare noundef i32 @vsprintf(i8* nocapture noundef, i8* nocapture noundef readonly, %opaque* noundef) [[NOFREE_NOUNWIND]]
 declare i32 @vsprintf(i8*, i8*, %opaque*)
 
 ; CHECK: declare noundef i32 @vsscanf(i8* nocapture noundef readonly, i8* nocapture noundef readonly, %opaque* noundef) [[NOFREE_NOUNWIND]]
 declare i32 @vsscanf(i8*, i8*, %opaque*)
 
 ; CHECK: declare noundef i64 @write(i32 noundef, i8* nocapture noundef readonly, i64 noundef) [[NOFREE]]
+; CHECK-SYSTEMZ: declare noundef i64 @write(i32 noundef signext, i8* nocapture noundef readonly, i64 noundef)
 declare i64 @write(i32, i8*, i64)
 
 
 ; memset_pattern{4,8,16} aren't available everywhere.
 ; CHECK-DARWIN: declare void @memset_pattern4(i8* nocapture writeonly, i8* nocapture readonly, i64) [[ARGMEMONLY_NOFREE_NOUNWIND_WILLRETURN]]
 declare void @memset_pattern4(i8*, i8*, i64)
 ; CHECK-DARWIN: declare void @memset_pattern8(i8* nocapture writeonly, i8* nocapture readonly, i64) [[ARGMEMONLY_NOFREE_NOUNWIND_WILLRETURN]]
 declare void @memset_pattern8(i8*, i8*, i64)