[X86] Always extend the integer parameters in callee

[LiuChen3]

Summary

For now clang will assume the integer parameters have been sign/zero extended in the caller, which will cause some ABI compatibility issues.
This patch will add -mextend-small-integer which can specify how to handle small integer arguments.

1. Adds one new ConservativeExtend Kind, which means we shouldn't make any assumptions about the caller and callee. In this case, we must do zero/sign extension for integer parameters in caller and callee.
2. Adds -mextend-small-integer=<arg> option:
   • none : Pass the small integer parameter directly in caller.
   • conserative: Always extend small integer parameter in the caller but do not assume in the callee that the caller actually did the extension. This is the default value.
   • assumed: Assume the small integer parameter has been extened in the caller.
   • default: Use the default rule for the target.

[LiuChen3]

fix bug

[skan]

Should we update the clang/docs/ReleaseNotes.rst for this?

[LiuChen3]

In D124435#3474130, @skan wrote:

Should we update the clang/docs/ReleaseNotes.rst for this?

Maybe? I will update it in the next patch.

[pengfei]

clang/docs/ClangCommandLineReference.rst

2988–2992

Combine like others?

clang/include/clang/CodeGen/CGFunctionInfo.h

202–205

AI.setSignExt(Ty->hasSignedIntegerRepresentation()) for short?
Or we can remove the else block since SignExt is initialized to false?

333

Can we move it to isExtend? e.g. TheKind == Expand | TheKind == ConservativeExtend

clang/lib/CodeGen/CGCall.cpp

2451

Does the change affect Windows? Seems Win64 doesn't extend on caller. https://godbolt.org/z/c95hvvsWf

clang/test/CodeGen/X86/integer_argument_passing.c

2

Maybe we can remove the tests for i386 given it's only for 64 bits ABI?

[LiuChen3]

clang/lib/CodeGen/CGCall.cpp

2451

No. This patch didn't nothing for Win64 ABI.

clang/test/CodeGen/X86/integer_argument_passing.c

2

According to the meaning of ConservativeExtend, I think the 32bit ABI needs to be modified as well:
https://godbolt.org/z/W1Ma1T3f3
The dump of currently clang-cl:

_square:
        movb    4(%esp), %al
        mulb    %al
        mulb    8(%esp)
        retl

        .def    _baz;
        .scl    2;
        .type   32;
        .endef
        .section        .text,"xr",one_only,_baz
        .globl  _baz
        .p2align        4, 0x90
_baz:
        movswl  4(%esp), %eax
        pushl   %eax
        calll   _bar
        addl    $4, %esp
        retl

Of course with this patch the behavior of clang-cl is still different from cl.exe, but I think it fits the meaning of ConservativeExtend.

[pengfei]

clang/lib/CodeGen/CGCall.cpp

2451

But I found some Windows tests are affected?

clang/test/CodeGen/X86/integer_argument_passing.c

2

My point was, i386 is passing arguments by stack. The extensions don't make sense under the circumstances. That's what I understood the comments in above test 2007-06-18-SextAttrAggregate.c

[pengfei]

clang/test/CodeGen/X86/integer_argument_passing.c

2

Oh, seems I misunderstood it. The stack still needs extensions since it's aligned to 4 bytes. But from the above output, the clang-cl is wrong, because it extends on caller which MSVC extends on callee. So back the another question, we should change for Windows too, right?

[LiuChen3]

clang/test/CodeGen/X86/integer_argument_passing.c

2

I just change the behavior of win32. Windows 64 will always do the extensions in callee. I didn't support ConservativeExtend for win64. The dump IR of currently clang-cl is:

define dso_local i8 @square(i8 noundef %a, i8 noundef %b) local_unnamed_addr #0 {
...
}

  %call = tail call i32 @bar(i16 noundef %conv) #3
...
}

define dso_local i32 @baz(i32 noundef %num) local_unnamed_addr #1 {
...
  %call = tail call i32 @bar(i16 noundef %conv) #3
...
}

I think maybe we don't need to do the extension both in caller and callee for WIN64?

[rnk]

clang/include/clang/CodeGen/CGFunctionInfo.h

120

Instead of introducing a new ABIInfo::Kind value, should this be a boolean flag that is part of ABIInfo::Extend? That seems like it would be simpler.

clang/test/CodeGen/X86/integer_argument_passing.c

2

I agree, I think there is only one use of getExtend in the win64 argument code, and it is for bool / i1:
https://github.com/llvm/llvm-project/blob/main/clang/lib/CodeGen/TargetInfo.cpp#L4359

Basically, on Windows, we never extend. That seems to correspond to the behavior we observed in MSVC.

Regarding Windows x86_32, I personally think your behavior change is correct. We shouldn't rely on MSVC to extend its arguments for us. In any case, it's conservatively correct, and hopefully nobody cares about minor efficiency issues for x86_32.

[rjmccall]

clang/docs/ClangCommandLineReference.rst

2988–2992

How about:

In the past, Clang passed small integer arguments on certain targets using a
parameter convention in which the caller was assumed to have sign-extended
or zero-extended the argument to a certain width.  This convention was not
conformant with the documented ABI on these platforms, which does not
require the caller to perform this extension.  Clang no longer assumes that
callers perform this extension, but for compatibility with code compiled by
previous releases of Clang, Clang defaults to still extending the argument in the
caller.  `-mno-conservative-extend` disables this, which may improve
performance and code size if compatibility with old versions of Clang is not
required.

This affects most 32-bit and 64-bit x86 targets, except:
- Windows, which Clang has never assumed extension on
- Apple platforms, which use a non-standard ABI that unconditionally assumes extension

Note that I need to check that that's what Apple actually wants to do. You should also reach out to the Sony folks to see what they want to do, but I expect that it's to assume extension unconditionally.

clang/include/clang/Basic/CodeGenOptions.def

475

"Whether callers should extend small integer parameters even though callees are not supposed to expect extension."

clang/include/clang/CodeGen/CGFunctionInfo.h

48

"...but do not assume in the callee that the caller actually did the extension."

120

I think adding a new Kind is better; it's a significantly different ABI that clients should be forced to handle correctly, which they will not if it's just a flag.

clang/include/clang/Driver/Options.td

3335

The callee isn't really extending anything; please the wording I suggest above.

clang/lib/CodeGen/CGCall.cpp

1617

Please write the code to work correctly for return types even if we aren't using it anywhere yet.

2450

"Under ConservativeExtend, add sext/zext only on the call site; the callee does not get to assume extension."

3655

Please make this correct when used on return types.

5573

Please make this correct when used on return types.

clang/lib/CodeGen/TargetInfo.cpp

1938

This looks wrong. In non-ConservativeExtend mode, we don't get to assume extension at all and should use Direct, right?

3818

Same comment: this should use Direct when we're not in ConservativeExtend mode, right?

[LiuChen3]

clang/docs/ClangCommandLineReference.rst

2988–2992

Thanks a lot! It's much clearer.
Just a small correction for windows: only windows64 is not affected.

clang/include/clang/CodeGen/CGFunctionInfo.h

333

I prefer to set it alone as it is a different Kind from Extend.

clang/lib/CodeGen/CGCall.cpp

2451

I checked it again and it should be that only win32 is affected.

clang/lib/CodeGen/TargetInfo.cpp

1938

As I understand it, Direct means do nothing with the parameters. Caller won't do the extension and callee can't assume the parameter is correct. This makes new clang behave in the opposite way to currently clang behavior, which will cause incompatibility issue. e.g:
https://godbolt.org/z/d3Peq4nsG

3818

Same as above.

[LiuChen3]

Address comments

[LiuChen3]

clang/lib/CodeGen/CGCall.cpp

2310

At present, ConservativeExtend has no specific definition for return value, so I just make it follow the behavior of Extend .

[LiuChen3]

add one missing comment

[LiuChen3]

In D124435#3474130, @skan wrote:

Should we update the clang/docs/ReleaseNotes.rst for this?

The ReleaseNotes says "written by LLVM Team". So I am not sure if I can update this.

[LiuChen3]

clang/docs/ClangCommandLineReference.rst

2988–2992

Hi, @RKSimon , @probinson. This patch will extend the integer parameters in the caller. Is there any concern about this for Sony?

[rjmccall]

clang/docs/ClangCommandLineReference.rst

2988–2992

Slight revision:

In the past, on certain targets, Clang passed promotable integer arguments
(arguments with types smaller than int) using a parameter convention in
which the caller was assumed to have sign-extended or zero-extended the
argument to the width of an int. This convention did not conform to the
documented ABI for these targets, which does not require the caller to
perform this extension.

clang/lib/CodeGen/TargetInfo.cpp

1938

Oh, I see, you're thinking that -mno-conservative-extend means "do what old versions of clang did" rather than "break compatibility with old versions of clang and just follow the x86_64 ABI". That's definitely different from the documentation I suggested, so something's got to change.

I think these are the possibilities here:

1. Some platforms, like Apple's, are probably going to define Clang's current behavior as the platform ABI. So those platforms need to continue to use Extend. My previous comment about using Direct wasn't paying due attention to this case.

2. On other platforms, we need to maintain compatibility by default with both the platform ABI and old Clang behavior. Those platforms will need to use ConservativeExtend.

3. Some people may want to opt out of (2) and just be compatible with the platform ABI, which has minor code-size and performance wins. If we support that with an option, I believe it should cause us to emit Direct. This is what I was thinking -mno-conservative-extend would mean.

4. Some people may want to force the use of (1) even on platforms where that isn't the platform ABI. I don't know if this is really something we should support in the long term, but it might be valuable for people staging this change in. This is what you seem to be thinking -mno-conservative-extend would mean.

I would suggest these spellings for the argument, instead of making it boolean:

-mextend-small-integers=none    // Force the use of Direct
-mextend-small-integers=conservative // Force the use of ConservativeExtend
-mextend-small-integers=assumed // Force the use of Extend
-mextend-small-integers=default // Use the default rule for the target

[LiuChen3]

clang/lib/CodeGen/TargetInfo.cpp

1938

Yes. That's what I mean. I totally misunderstood your meaning before.
I agree with your method. I will work on that. Just one concern about the 'default': the default behavior is 'conservative' instead of 'default'. Wouldn't that be a little weird? But with my limited English I can't think of a better word. 'default' is ok for me. :-)

[rjmccall]

clang/lib/CodeGen/TargetInfo.cpp

1938

The default will be platform-specific. For example, the de facto macOS x86_64 ABI is to extend in the caller, because clang is the system compiler, and that's what clang does. Apple just needs to update its documentation.

[LiuChen3]

Use -mextend-small-integers=<arg> instead of boolean option

[rjmccall]

clang/docs/ClangCommandLineReference.rst

3034

Specifies how to handle small integer arguments on i386 and x86_64
targets that generally follow the System V ABI. The value must be `none`,
`conservative, assumed, or default`. The default behavior
depends on the target and can be explicitly requested with `default`.

In the past, on System V i386 and x86_64 targets, Clang passed promotable
integer arguments (non-variadic arguments with types smaller than 'int')
using a parameter convention in which the caller was assumed to have
sign-extended or zero-extended the argument to the width of an 'int'. This
convention did not conform to the documented ABI for these targets, which
does not require the caller to perform this extension. This can introduce
incompatibilities with code generated by other compilers on these targets.

On most targets using the System V ABI, Clang no longer assumes that
callers perform this extension. In order to maintain compatibility with
code compiled by old versions of Clang, Clang will still perform the extension
in the caller. This is the `conservative` behavior. If compatibility with old
Clang code is not required, extension in the caller can be disabled using
`none`, which may have minor performance and code-size benefits.

On certain targets which use Clang as the system compiler, Clang continues
to perform extension in the caller and assume it in in the callee. This is the
behavior of `assumed`. These platforms therefore diverge from the
standard System V ABI. If compatibility with other compilers which do not
recognize this divergence is required, `conservative` may be used.
Using `none` on these targets is allowed but may lead to ABI mismatches.
These targets include Apple and PlayStation platforms.

clang/include/clang/Driver/Options.td

3344

clang/lib/CodeGen/TargetInfo.cpp

1938

Please go ahead and implement the target-specific logic. Since Apple (and probably Sony) is opting out of it, it's incorrect to change the ABI there, even briefly.

I would suggest folding away the Default case so that you just deal with one of assumed/conservative/direct here, either when you construct the ABIInfo or maybe even when you parse the frontend options in CompilerInvocation.

[LiuChen3]

Thanks, @rjmccall . I'm sorry I don't have much time on this patch recently. I will update it later.

[jyknight]

I find the option names you have a bit confusing. I'd like to suggest calling them, instead:

caller: Extend a small integer parameter in the caller; callee will assume it has already been extended.
callee : Pass a small integer parameter directly in caller, extend in callee when converting to full-width.
both: Extend a small integer parameter in the caller; callee ALSO extends when converting to full-width.
default: Use the default rule for the target.

I think that gets more to the point of what's going on here, even though it's not exactly the case that "callee" always extends.

[rjmccall]

I'm fine with alternatives on the names. I just don't think we want names that imply that the caller and callee are parallel here, as if there were some sort of requirement that the callee always extends. In those conventions, the callee gets passed 8 or 16 meaningful bits; if it wants an extended value, it's responsible for doing that extension, just like it would be responsible for doing the opposite extension if it wanted that.

[LiuChen3]

rebase and address rjmccall's comments

[LiuChen3]

Sorry for the late update. I hope you can take the time to continue reviewing, @rjmccall .
I'm not sure if I understand you correctly. Now if the -mextend-small-integers=default is used, compiler will report error.

[LiuChen3]

In D124435#3515541, @jyknight wrote:

I find the option names you have a bit confusing. I'd like to suggest calling them, instead:

caller: Extend a small integer parameter in the caller; callee will assume it has already been extended.
callee : Pass a small integer parameter directly in caller, extend in callee when converting to full-width.
both: Extend a small integer parameter in the caller; callee ALSO extends when converting to full-width.
default: Use the default rule for the target.

I think that gets more to the point of what's going on here, even though it's not exactly the case that "callee" always extends.

rjmccall's comment convinced me.

[rjmccall]

It looks like you haven't implemented the target-specific logic for this yet. I cannot let you commit until you do that, because you will be breaking the ABI on Apple platforms.

clang/include/clang/Basic/CodeGenOptions.h

150 ↗

(On Diff #449230)

This comment is incorrect.

clang/include/clang/Driver/Options.td

3346

We're not usually this verbose in the inline help text; this is basically an attempt to document the whole feature, which is excessive, We should do like we do for -mthread-model or similar enum options and just quickly describe the option and list the possible values.

clang/lib/CodeGen/TargetInfo.cpp

1942

3816

[jyknight]

Thinking more about the naming issue, I think the real issue is that the proposed options are an implementation detail, not what we should expose to users. I realize that the non-boolean option was proposed by rjmmccall before, but I'd suggest that we go back to something more like your original boolean option. I believe that the discussion which resulted in the new option, was due to confusion around what "not conservative" should mean -- and that's just because the implementation did not honor fclang-abi-compat.

The main problem I have with the current proposal is that it's both confusing to describe (I still can't really understand the docs), and it invites trouble: if a user is trying to improve performance and specifies -mextend-small-integers=none, that will help on Linux but break the binary on Apple. There's really no reason to even offer "none" on apple.

So, let's provide the ability to adjust behavior according to the goals a user may have. The behaviors I think we need to expose are:

1. (Default) Be compatible both with previous Clang ABI, and with GCC/ICC/new-Clang ABI.
2. Be compatible with previous Clang ABI, don't care about compatibility with standard ABI.
3. Be compatible with standard ABI, don't care about compatibility with previous Clang ABI.

So, for that purpose, I suggest we should use the existing -fclang-abi-compat option, plus a single on/off switch for whether to be conservatively-compatible (which I've renamed -mconservative-small-integer-abi but I don't feel strongly about that if you wanted to go back to -mconservative-extend)

Then, to achieve the 3 goals above, you can specify:

1. No extra args (which implies the defaults of -fclang-abi-compat=16 -mconservative-small-integer-abi)
2. -fclang-abi-compat=15 -mno-conservative-small-integer-abi
3. -mno-conservative-small-integer-abi

On most SysV platforms, with -mno-conservative-small-integer-abi, abi-compat=15 will use Direct, and abi-compat=16 will use Extend. With -mconservative-small-integer-abi, both will use ConservativeExtend mode. On Apple/Playstation platforms, this ABI doesn't change between 15/16, so it should always use Extend regardless of either of the options. (That is, -mconservative-small-integer-abi is a no-op on those platforms.)

Then we can go back to the previous description from rjmmcall, with some minor adjustments to describe the interaction with -fclang-abi-compat:

-mconservative-small-integer-abi

In the past, on certain targets, Clang passed promotable integer arguments
(arguments with types smaller than int) using a parameter convention in which
the caller was assumed to have sign-extended or zero-extended the argument to
the width of an int. This convention did not conform to the documented ABI for
these targets, which does not require the caller to perform this
extension. Under `-fclang-abi-compat=16`, Clang no longer assumes that callers
perform this extension, but for compatibility with code compiled by previous
releases of Clang, Clang defaults to still extending the argument in the
caller.  `-mno-conservative-small-integer-abi` disables this, which may
improve performance and code size if compatibility across Clang versions is
not required.

This option is a no-op for targets which did not have an ABI change (Apple,
Windows, and PlayStation).

[rjmccall]

That is an interesting idea. I like that it integrates this into -fclang-abi-compat. The way that -mno-conservative-small-integer-abi ends up meaning opposite things based on the abi-compat setting worries me a lot, though.

[jyknight]

In D124435#3696862, @rjmccall wrote:

That is an interesting idea. I like that it integrates this into -fclang-abi-compat. The way that -mno-conservative-small-integer-abi ends up meaning opposite things based on the abi-compat setting worries me a lot, though.

The flag means the same thing in both cases, from the user's POV: "Be compatible only with the specified -fclang-abi-compat behavior, not an earlier/later ABI version's behavior."

[rjmccall]

I know what you're saying, but I don't think it matches any model of how programmers use command line flags. You're imagining that a programmer sits down and considers all of their flags deeply and holistically before touching any of them, and that's just not how these things go in actual build systems. Flags have a tendency to be set in separate places and therefore to drift. Someone setting this option is doing it because they have a concrete compatibility need, and the flag going from meaning "be compatible with GCC" to meaning "be compatible with old Clangs" based on the value of a separate flag is surprising and likely to cause bugs.

[jyknight]

In D124435#3697259, @rjmccall wrote:

I know what you're saying, but I don't think it matches any model of how programmers use command line flags. You're imagining that a programmer sits down and considers all of their flags deeply and holistically before touching any of them, and that's just not how these things go in actual build systems. Flags have a tendency to be set in separate places and therefore to drift. Someone setting this option is doing it because they have a concrete compatibility need, and the flag going from meaning "be compatible with GCC" to meaning "be compatible with old Clangs" based on the value of a separate flag is surprising and likely to cause bugs.

Funny, my argument is based precisely on the fact that people _don't_ understand deeply what things are doing, and that the original proposal is likely to trigger bugs via mistakes in its usage!

The default (-mconservative-small-integer-abi) is "be compatible with all Clang and GCC versions" -- it "just works". (I think everyone agrees upon that being the default.)

So, the use-case for -mconservative-small-integer-abi is not a need for compatibility but rather a need for performance/code-size overriding cross-compiler compatibility concerns. In that case, the user better be able to answer "what other compiler/version do you need to be compatible with, if any?" -- and set -fclang-abi-compat flag appropriately based on that answer.

That seems much easier thing to explain to a user than the details of where exactly extension may/must happen in the call ABI.

[rjmccall]

In D124435#3701163, @jyknight wrote:

In D124435#3697259, @rjmccall wrote:

I know what you're saying, but I don't think it matches any model of how programmers use command line flags. You're imagining that a programmer sits down and considers all of their flags deeply and holistically before touching any of them, and that's just not how these things go in actual build systems. Flags have a tendency to be set in separate places and therefore to drift. Someone setting this option is doing it because they have a concrete compatibility need, and the flag going from meaning "be compatible with GCC" to meaning "be compatible with old Clangs" based on the value of a separate flag is surprising and likely to cause bugs.

Funny, my argument is based precisely on the fact that people _don't_ understand deeply what things are doing, and that the original proposal is likely to trigger bugs via mistakes in its usage!

The default (-mconservative-small-integer-abi) is "be compatible with all Clang and GCC versions" -- it "just works". (I think everyone agrees upon that being the default.)

So, the use-case for -mconservative-small-integer-abi is not a need for compatibility but rather a need for performance/code-size overriding cross-compiler compatibility concerns. In that case, the user better be able to answer "what other compiler/version do you need to be compatible with, if any?" -- and set -fclang-abi-compat flag appropriately based on that answer.

That seems much easier thing to explain to a user than the details of where exactly extension may/must happen in the call ABI.

I'm not arguing that we shouldn't work -fclang-abi-compat into this; I think that is a very good idea. And for many people, that'll be all they need. My concern is about the people who do add -mno-conservative-small-integer-abi to their builds.

clang/docs/ClangCommandLineReference.rst

 .. option:: -mcode-object-v3, -mno-code-object-v3
 
 Legacy option to specify code object ABI V3 (AMDGPU only)
 
 .. option:: -mcode-object-version=<arg>
 
 Specify code object ABI version. Allowed values are 2, 3, 4, and 5. Defaults to 4. (AMDGPU only)
 
+.. option:: -mconservative-extend
+Always extend the integer parameter both in the callee and caller.
+
+.. option:: -mno-conservative-extend
+Keep the original integer parameter passing behavior.
+
 .. option:: -mconsole<arg>
 
 .. program:: clang1
 .. option:: -mcpu=<arg>, -mv5 (equivalent to -mcpu=hexagonv5), -mv55 (equivalent to -mcpu=hexagonv55), -mv60 (equivalent to -mcpu=hexagonv60), -mv62 (equivalent to -mcpu=hexagonv62), -mv65 (equivalent to -mcpu=hexagonv65), -mv66 (equivalent to -mcpu=hexagonv66), -mv67 (equivalent to -mcpu=hexagonv67), -mv67t (equivalent to -mcpu=hexagonv67t), -mv68 (equivalent to -mcpu=hexagonv68), -mv69 (equivalent to -mcpu=hexagonv69)
 .. program:: clang
 
 .. option:: -mcrc, -mno-crc
 

 .. option:: -mfloat-abi=<arg>
 
 .. option:: -mfpmath=<arg>
 
 .. option:: -mfpu=<arg>
 
 .. option:: -mgeneral-regs-only
 
 Generate code which only uses the general purpose registers (AArch64/x86 only)
 
 .. option:: -mglobal-merge, -mno-global-merge
 
 Enable merging of globals
 
 .. option:: -mhard-float
 
 .. option:: -mhwdiv=<arg>, --mhwdiv <arg>, --mhwdiv=<arg>

clang/include/clang/Basic/CodeGenOptions.def

 
 /// Whether to zero out caller-used registers before returning.
 ENUM_CODEGENOPT(ZeroCallUsedRegs, llvm::ZeroCallUsedRegs::ZeroCallUsedRegsKind,
                 5, llvm::ZeroCallUsedRegs::ZeroCallUsedRegsKind::Skip)
 
 /// Whether to use opaque pointers.
 CODEGENOPT(OpaquePointers, 1, 0)
 
+/// Whether the ingeter parameter should be extended in callee and caller.
+CODEGENOPT(ConservativeExtend, 1, 1)
+
 #undef CODEGENOPT
 #undef ENUM_CODEGENOPT
 #undef VALUE_CODEGENOPT

clang/include/clang/CodeGen/CGFunctionInfo.h

enum Kind : uint8_t {
     /// representation. A dummy argument is emitted before the real argument
     /// if the specified type stored in "PaddingType" is not zero.
     Direct,
 
     /// Extend - Valid only for integer argument types. Same as 'direct'
     /// but also emit a zero/sign extension attribute.
     Extend,
 
+    /// ConservativeExtend - Valid only for integer argument types. Same as
+    /// 'Extend' but do not make any assumptions about the caller and callee.
+    ConservativeExtend,
+
     /// Indirect - Pass the argument indirectly via a hidden pointer with the
     /// specified alignment (0 indicates default alignment) and address space.
     Indirect,
 
     /// IndirectAliased - Similar to Indirect, but the pointer may be to an
     /// object that is otherwise referenced.  The object is known to not be
     /// modified through any other references for the duration of the call, and
     /// the callee must not itself modify the object.  Because C allows
private:
   };
   Kind TheKind;
   bool PaddingInReg : 1;
   bool InAllocaSRet : 1;    // isInAlloca()
   bool InAllocaIndirect : 1;// isInAlloca()
   bool IndirectByVal : 1;   // isIndirect()
   bool IndirectRealign : 1; // isIndirect()
   bool SRetAfterThis : 1;   // isIndirect()
   bool InReg : 1;           // isDirect() || isExtend() || isIndirect()
   bool CanBeFlattened: 1;   // isDirect()
   bool SignExt : 1;         // isExtend()
 
   bool canHavePaddingType() const {
     return isDirect() || isExtend() || isIndirect() || isIndirectAliased() ||
-           isExpand();
+           isExpand() || isConservativeExtend();
   }
   void setPaddingType(llvm::Type *T) {
     assert(canHavePaddingType());
     PaddingType = T;
   }
 
   void setUnpaddedCoerceToType(llvm::Type *T) {
     assert(isCoerceAndExpand());
public:
   // of its type.
   static ABIArgInfo getExtend(QualType Ty, llvm::Type *T = nullptr) {
     assert(Ty->isIntegralOrEnumerationType() && "Unexpected QualType");
     if (Ty->hasSignedIntegerRepresentation())
       return getSignExtend(Ty, T);
     return getZeroExtend(Ty, T);
   }
 
+  static ABIArgInfo getConservativeExtend(QualType Ty,
+                                          llvm::Type *T = nullptr) {
+    assert(Ty->isIntegralOrEnumerationType() && "Unexpected QualType");
+    auto AI = ABIArgInfo(ConservativeExtend);
+    AI.setCoerceToType(T);
+    AI.setPaddingType(nullptr);
+    AI.setDirectOffset(0);
+    AI.setDirectAlign(0);
+    if (Ty->hasSignedIntegerRepresentation())
+      AI.setSignExt(true);
+    else
+      AI.setSignExt(false);
+    return AI;
+  }
+
+  static ABIArgInfo getConservativeExtendInReg(QualType Ty,
+                                               llvm::Type *T = nullptr) {
+    auto AI = getConservativeExtend(Ty, T);
+    AI.setInReg(true);
+    return AI;
+  }
+
   static ABIArgInfo getExtendInReg(QualType Ty, llvm::Type *T = nullptr) {
     auto AI = getExtend(Ty, T);
     AI.setInReg(true);
     return AI;
   }
   static ABIArgInfo getIgnore() {
     return ABIArgInfo(Ignore);
   }
#endif
   bool isDirect() const { return TheKind == Direct; }
   bool isInAlloca() const { return TheKind == InAlloca; }
   bool isExtend() const { return TheKind == Extend; }
   bool isIgnore() const { return TheKind == Ignore; }
   bool isIndirect() const { return TheKind == Indirect; }
   bool isIndirectAliased() const { return TheKind == IndirectAliased; }
   bool isExpand() const { return TheKind == Expand; }
   bool isCoerceAndExpand() const { return TheKind == CoerceAndExpand; }
+  bool isConservativeExtend() const { return TheKind == ConservativeExtend; }
 
   bool canHaveCoerceToType() const {
-    return isDirect() || isExtend() || isCoerceAndExpand();
+    return isDirect() || isExtend() || isCoerceAndExpand() ||
+           isConservativeExtend();
   }
 
-  // Direct/Extend accessors
+  // Direct/Extend/ConservativeExtend accessors
   unsigned getDirectOffset() const {
-    assert((isDirect() || isExtend()) && "Not a direct or extend kind");
+    assert((isDirect() || isExtend() || isConservativeExtend()) &&
+           "Invalid kind!");
     return DirectAttr.Offset;
   }
   void setDirectOffset(unsigned Offset) {
-    assert((isDirect() || isExtend()) && "Not a direct or extend kind");
+    assert((isDirect() || isExtend() || isConservativeExtend()) &&
+           "Invalid kind");
     DirectAttr.Offset = Offset;
   }
 
   unsigned getDirectAlign() const {
-    assert((isDirect() || isExtend()) && "Not a direct or extend kind");
+    assert((isDirect() || isExtend() || isConservativeExtend()) &&
+           "Invalid kind");
     return DirectAttr.Align;
   }
   void setDirectAlign(unsigned Align) {
-    assert((isDirect() || isExtend()) && "Not a direct or extend kind");
+    assert((isDirect() || isExtend() || isConservativeExtend()) &&
+           "Invalid kind");
     DirectAttr.Align = Align;
   }
 
   bool isSignExt() const {
-    assert(isExtend() && "Invalid kind!");
+    assert((isExtend() || isConservativeExtend()) && "Invalid kind!");
     return SignExt;
   }
   void setSignExt(bool SExt) {
-    assert(isExtend() && "Invalid kind!");
+    assert((isExtend() || isConservativeExtend()) && "Invalid kind!");
     SignExt = SExt;
   }
 
   llvm::Type *getPaddingType() const {
     return (canHavePaddingType() ? PaddingType : nullptr);
   }
 
   bool getPaddingInReg() const {
if (auto structTy =
           dyn_cast<llvm::StructType>(UnpaddedCoerceAndExpandType)) {
       return structTy->elements();
     } else {
       return llvm::makeArrayRef(&UnpaddedCoerceAndExpandType, 1);
     }
   }
 
   bool getInReg() const {
-    assert((isDirect() || isExtend() || isIndirect()) && "Invalid kind!");
+    assert(
+        (isDirect() || isExtend() || isIndirect() || isConservativeExtend()) &&
+        "Invalid kind!");
     return InReg;
   }
 
   void setInReg(bool IR) {
-    assert((isDirect() || isExtend() || isIndirect()) && "Invalid kind!");
+    assert(
+        (isDirect() || isExtend() || isIndirect() || isConservativeExtend()) &&
+        "Invalid kind!");
     InReg = IR;
   }
 
   // Indirect accessors
   CharUnits getIndirectAlign() const {
     assert((isIndirect() || isIndirectAliased()) && "Invalid kind!");
     return CharUnits::fromQuantity(IndirectAttr.Align);
   }

clang/include/clang/Driver/Options.td

def mthread_model : Separate<["-"], "mthread-model">, Group<m_Group>, Flags<[CC1Option]>,
   MarshallingInfoEnum<LangOpts<"ThreadModel">, "POSIX">;
 def meabi : Separate<["-"], "meabi">, Group<m_Group>, Flags<[CC1Option]>,
   HelpText<"Set EABI type. Default depends on triple)">, Values<"default,4,5,gnu">,
   MarshallingInfoEnum<TargetOpts<"EABIVersion">, "Default">,
   NormalizedValuesScope<"llvm::EABI">,
   NormalizedValues<["Default", "EABI4", "EABI5", "GNU"]>;
 def mtargetos_EQ : Joined<["-"], "mtargetos=">, Group<m_Group>,
   HelpText<"Set the deployment target to be the specified OS and OS version">;
+def mconservative_extend : Flag<["-"], "mconservative-extend">, Group<m_Group>, Flags<[CC1Option]>,
+  HelpText<"Always extend the integer parameter both in the callee and caller."
+           "Do not make any assumptions about the callee and caller">;
+def mno_conservative_extend : Flag<["-"], "mno-conservative-extend">, Group<m_Group>,
+  Flags<[CC1Option]>, MarshallingInfoNegativeFlag<CodeGenOpts<"ConservativeExtend">>,
+  HelpText<"Keep the original integer parameter passing behavior">;
 
 def mno_constant_cfstrings : Flag<["-"], "mno-constant-cfstrings">, Group<m_Group>;
 def mno_global_merge : Flag<["-"], "mno-global-merge">, Group<m_Group>, Flags<[CC1Option]>,
   HelpText<"Disable merging of globals">;
 def mno_pascal_strings : Flag<["-"], "mno-pascal-strings">,
   Alias<fno_pascal_strings>;
 def mno_red_zone : Flag<["-"], "mno-red-zone">, Group<m_Group>;
 def mno_tls_direct_seg_refs : Flag<["-"], "mno-tls-direct-seg-refs">, Group<m_Group>, Flags<[CC1Option]>,
   HelpText<"Disable direct TLS access through segment registers">,
   MarshallingInfoFlag<CodeGenOpts<"IndirectTlsSegRefs">>;
 def mno_relax_all : Flag<["-"], "mno-relax-all">, Group<m_Group>;
 def mno_rtd: Flag<["-"], "mno-rtd">, Group<m_Group>;
 def mno_soft_float : Flag<["-"], "mno-soft-float">, Group<m_Group>;
 def mno_stackrealign : Flag<["-"], "mno-stackrealign">, Group<m_Group>;
 
 def mretpoline : Flag<["-"], "mretpoline">, Group<m_Group>, Flags<[CoreOption,NoXarchOption]>;

clang/lib/CodeGen/CGCall.cpp

for (CGFunctionInfo::const_arg_iterator I = FI.arg_begin(); ArgNo < NumArgs;
     // Collect data about IR arguments corresponding to Clang argument ArgNo.
     auto &IRArgs = ArgInfo[ArgNo];
 
     if (AI.getPaddingType())
       IRArgs.PaddingArgIndex = IRArgNo++;
 
     switch (AI.getKind()) {
     case ABIArgInfo::Extend:
-    case ABIArgInfo::Direct: {
+    case ABIArgInfo::Direct:
+    case ABIArgInfo::ConservativeExtend: {
       // FIXME: handle sseregparm someday...
       llvm::StructType *STy = dyn_cast<llvm::StructType>(AI.getCoerceToType());
       if (AI.isDirect() && AI.getCanBeFlattened() && STy) {
         IRArgs.NumberOfArgs = STy->getNumElements();
       } else {
         IRArgs.NumberOfArgs = 1;
       }
       break;
CodeGenTypes::GetFunctionType(const CGFunctionInfo &FI) {
   (void)Inserted;
   assert(Inserted && "Recursively being processed?");
 
   llvm::Type *resultType = nullptr;
   const ABIArgInfo &retAI = FI.getReturnInfo();
   switch (retAI.getKind()) {
   case ABIArgInfo::Expand:
   case ABIArgInfo::IndirectAliased:
+  case ABIArgInfo::ConservativeExtend:
     llvm_unreachable("Invalid ABI kind for return argument");
 
   case ABIArgInfo::Extend:
   case ABIArgInfo::Direct:
     resultType = retAI.getCoerceToType();
     break;
 
   case ABIArgInfo::InAlloca:
for (; it != ie; ++it, ++ArgNo) {
     }
     case ABIArgInfo::IndirectAliased: {
       assert(NumIRArgs == 1);
       llvm::Type *LTy = ConvertTypeForMem(it->type);
       ArgTypes[FirstIRArg] = LTy->getPointerTo(ArgInfo.getIndirectAddrSpace());
       break;
     }
     case ABIArgInfo::Extend:
-    case ABIArgInfo::Direct: {
+    case ABIArgInfo::Direct:
+    case ABIArgInfo::ConservativeExtend: {
       // Fast-isel and the optimizer generally like scalar values better than
       // FCAs, so we flatten them if this is safe to do for this argument.
       llvm::Type *argType = ArgInfo.getCoerceToType();
       llvm::StructType *st = dyn_cast<llvm::StructType>(argType);
       if (st && ArgInfo.isDirect() && ArgInfo.getCanBeFlattened()) {
         assert(NumIRArgs == st->getNumElements());
         for (unsigned i = 0, e = st->getNumElements(); i != e; ++i)
           ArgTypes[FirstIRArg + i] = st->getElementType(i);
void CodeGenModule::ConstructAttributeList(StringRef Name,
   if (CodeGenOpts.EnableNoundefAttrs && HasStrictReturn) {
     if (!RetTy->isVoidType() && RetAI.getKind() != ABIArgInfo::Indirect &&
         DetermineNoUndef(RetTy, getTypes(), DL, RetAI))
       RetAttrs.addAttribute(llvm::Attribute::NoUndef);
   }
 
   switch (RetAI.getKind()) {
   case ABIArgInfo::Extend:
     if (RetAI.isSignExt())
       RetAttrs.addAttribute(llvm::Attribute::SExt);
     else
       RetAttrs.addAttribute(llvm::Attribute::ZExt);
     LLVM_FALLTHROUGH;
   case ABIArgInfo::Direct:
     if (RetAI.getInReg())
       RetAttrs.addAttribute(llvm::Attribute::InReg);
     break;
   case ABIArgInfo::Ignore:
     break;
 
   case ABIArgInfo::InAlloca:
   case ABIArgInfo::Indirect: {
     // inalloca and sret disable readnone and readonly
     FuncAttrs.removeAttribute(llvm::Attribute::ReadOnly)
       .removeAttribute(llvm::Attribute::ReadNone);
     break;
   }
 
   case ABIArgInfo::CoerceAndExpand:
     break;
 
   case ABIArgInfo::Expand:
   case ABIArgInfo::IndirectAliased:
+  case ABIArgInfo::ConservativeExtend:
     llvm_unreachable("Invalid ABI kind for return argument");
   }
 
   if (!IsThunk) {
     // FIXME: fix this properly, https://reviews.llvm.org/D100388
     if (const auto *RefTy = RetTy->getAs<ReferenceType>()) {
       QualType PTy = RefTy->getPointeeType();
       if (!PTy->isIncompleteType() && PTy->isConstantSizeType())
if (CodeGenOpts.EnableNoundefAttrs &&
       Attrs.addAttribute(llvm::Attribute::NoUndef);
     }
 
     // 'restrict' -> 'noalias' is done in EmitFunctionProlog when we
     // have the corresponding parameter variable.  It doesn't make
     // sense to do it here because parameters are so messed up.
     switch (AI.getKind()) {
     case ABIArgInfo::Extend:
+    case ABIArgInfo::ConservativeExtend:
+      // Always extend the inter argument in callee and caller if the Kind is
+      // ConservativeExtend. In this case, we should only add sext/zext
+      // attribute to the callee.
+      if (AttrOnCallSite || AI.getKind() == ABIArgInfo::Extend) {
         if (AI.isSignExt())
           Attrs.addAttribute(llvm::Attribute::SExt);
         else
           Attrs.addAttribute(llvm::Attribute::ZExt);
+      }
       LLVM_FALLTHROUGH;
     case ABIArgInfo::Direct:
       if (ArgNo == 0 && FI.isChainCall())
         Attrs.addAttribute(llvm::Attribute::Nest);
       else if (AI.getInReg())
         Attrs.addAttribute(llvm::Attribute::InReg);
       Attrs.addStackAlignmentAttr(llvm::MaybeAlign(AI.getDirectAlign()));
       break;
case ABIArgInfo::IndirectAliased: {
         if (isPromoted)
           V = emitArgumentDemotion(*this, Arg, V);
         ArgVals.push_back(ParamValue::forDirect(V));
       }
       break;
     }
 
     case ABIArgInfo::Extend:
-    case ABIArgInfo::Direct: {
+    case ABIArgInfo::Direct:
+    case ABIArgInfo::ConservativeExtend: {
       auto AI = Fn->getArg(FirstIRArg);
       llvm::Type *LTy = ConvertType(Arg->getType());
 
       // Prepare parameter attributes. So far, only attributes for pointer
       // parameters are prepared. See
       // http://llvm.org/docs/LangRef.html#paramattrs.
       if (ArgI.getDirectOffset() == 0 && LTy->isPointerTy() &&
           ArgI.getCoerceToType()->isPointerTy()) {
// Otherwise, we need to make a first-class aggregate.
       for (unsigned i = 0, e = results.size(); i != e; ++i) {
         RV = Builder.CreateInsertValue(RV, results[i], i);
       }
     }
     break;
   }
   case ABIArgInfo::Expand:
   case ABIArgInfo::IndirectAliased:
+  case ABIArgInfo::ConservativeExtend:
     llvm_unreachable("Invalid ABI kind for return argument");
   }
 
   llvm::Instruction *Ret;
   if (RV) {
     if (CurFuncDecl && CurFuncDecl->hasAttr<CmseNSEntryAttr>()) {
       // For certain return types, clear padding bits, as they may reveal
       // sensitive information.
case ABIArgInfo::IndirectAliased: {
       break;
     }
 
     case ABIArgInfo::Ignore:
       assert(NumIRArgs == 0);
       break;
 
     case ABIArgInfo::Extend:
-    case ABIArgInfo::Direct: {
+    case ABIArgInfo::Direct:
+    case ABIArgInfo::ConservativeExtend: {
       if (!isa<llvm::StructType>(ArgInfo.getCoerceToType()) &&
           ArgInfo.getCoerceToType() == ConvertType(info_it->type) &&
           ArgInfo.getDirectOffset() == 0) {
         assert(NumIRArgs == 1);
         llvm::Value *V;
         if (!I->isAggregate())
           V = I->getKnownRValue().getScalarVal();
         else
case ABIArgInfo::Direct: {
       Address StorePtr = emitAddressAtOffset(*this, DestPtr, RetAI);
       CreateCoercedStore(CI, StorePtr, DestIsVolatile, *this);
 
       return convertTempToRValue(DestPtr, RetTy, SourceLocation());
     }
 
     case ABIArgInfo::Expand:
     case ABIArgInfo::IndirectAliased:
+    case ABIArgInfo::ConservativeExtend:
       llvm_unreachable("Invalid ABI kind for return argument");
     }
 
     llvm_unreachable("Unhandled ABIArgInfo::Kind");
   } ();
 
   // Emit the assume_aligned check on the return value.
   if (Ret.isScalar() && TargetDecl) {

clang/lib/CodeGen/TargetInfo.cpp

case IndirectAliased:
     break;
   case Expand:
     OS << "Expand";
     break;
   case CoerceAndExpand:
     OS << "CoerceAndExpand Type=";
     getCoerceAndExpandType()->print(OS);
     break;
+  case ConservativeExtend:
+    OS << "ConservativeExtend";
+    break;
   }
   OS << ")\n";
 }
 
 // Dynamically round a pointer up to a multiple of the given alignment.
 static llvm::Value *emitRoundPointerUpToAlignment(CodeGenFunction &CGF,
                                                   llvm::Value *Ptr,
                                                   CharUnits Align) {
if (const VectorType *VT = Ty->getAs<VectorType>()) {
     return ABIArgInfo::getDirect();
   }
 
 
   if (const EnumType *EnumTy = Ty->getAs<EnumType>())
     Ty = EnumTy->getDecl()->getIntegerType();
 
   bool InReg = shouldPrimitiveUseInReg(Ty, State);
+  bool IsConservativeExtend = getCodeGenOpts().ConservativeExtend;
 
   if (isPromotableIntegerTypeForABI(Ty)) {
     if (InReg)
-      return ABIArgInfo::getExtendInReg(Ty);
-    return ABIArgInfo::getExtend(Ty);
+      return IsConservativeExtend ? ABIArgInfo::getConservativeExtendInReg(Ty)
+                                  : ABIArgInfo::getExtendInReg(Ty);
+    return IsConservativeExtend ? ABIArgInfo::getConservativeExtend(Ty)
+                                : ABIArgInfo::getExtend(Ty);
   }
 
   if (const auto *EIT = Ty->getAs<BitIntType>()) {
     if (EIT->getNumBits() <= 64) {
       if (InReg)
         return ABIArgInfo::getDirectInReg();
       return ABIArgInfo::getDirect();
     }
     return getIndirectResult(Ty, /*ByVal=*/false, State);
   }
 
   if (InReg)
static bool isArgInAlloca(const ABIArgInfo &Info) {
   case ABIArgInfo::InAlloca:
     return true;
   case ABIArgInfo::Ignore:
   case ABIArgInfo::IndirectAliased:
     return false;
   case ABIArgInfo::Indirect:
   case ABIArgInfo::Direct:
   case ABIArgInfo::Extend:
+  case ABIArgInfo::ConservativeExtend:
     return !Info.getInReg();
   case ABIArgInfo::Expand:
   case ABIArgInfo::CoerceAndExpand:
     // These are aggregate types which are never passed in registers when
     // inalloca is involved.
     return true;
   }
   llvm_unreachable("invalid enum");
case Integer:
     // If we have a sign or zero extended integer, make sure to return Extend
     // so that the parameter gets the right LLVM IR attributes.
     if (Hi == NoClass && isa<llvm::IntegerType>(ResType)) {
       // Treat an enum type as its underlying type.
       if (const EnumType *EnumTy = Ty->getAs<EnumType>())
         Ty = EnumTy->getDecl()->getIntegerType();
 
       if (Ty->isIntegralOrEnumerationType() &&
-          isPromotableIntegerTypeForABI(Ty))
+          isPromotableIntegerTypeForABI(Ty)) {
+        if (getCodeGenOpts().ConservativeExtend)
+          return ABIArgInfo::getConservativeExtend(Ty);
         return ABIArgInfo::getExtend(Ty);
       }
+    }
 
     break;
 
     // AMD64-ABI 3.2.3p3: Rule 3. If the class is SSE, the next
     // available SSE register is used, the registers are taken in the
     // order from %xmm0 to %xmm7.
   case SSE: {
     llvm::Type *IRType = CGT.ConvertType(Ty);

clang/lib/Driver/ToolChains/Clang.cpp

if (!Size.empty())
       CmdArgs.push_back(Args.MakeArgString("-mstack-probe-size=" + Size));
     else
       CmdArgs.push_back("-mstack-probe-size=0");
   }
 
   Args.addOptOutFlag(CmdArgs, options::OPT_mstack_arg_probe,
                      options::OPT_mno_stack_arg_probe);
 
+  Args.addOptOutFlag(CmdArgs, options::OPT_mconservative_extend,
+                    options::OPT_mno_conservative_extend);
+
   if (Arg *A = Args.getLastArg(options::OPT_mrestrict_it,
                                options::OPT_mno_restrict_it)) {
     if (A->getOption().matches(options::OPT_mrestrict_it)) {
       CmdArgs.push_back("-mllvm");
       CmdArgs.push_back("-arm-restrict-it");
     } else {
       CmdArgs.push_back("-mllvm");
       CmdArgs.push_back("-arm-default-it");

clang/test/CodeGen/2007-06-18-SextAttrAggregate.c

 // RUN: %clang_cc1 -no-enable-noundef-analysis %s -o - -emit-llvm | FileCheck %s
-// XFAIL: aarch64, arm64, x86_64-pc-windows-msvc, x86_64-w64-windows-gnu, x86_64-pc-windows-gnu
+// XFAIL: aarch64, arm64, x86_64-pc-windows-msvc, x86_64-w64-windows-gnu, x86_64-pc-windows-gnu, x86_64-linux
 
 // PR1513
 
 // AArch64 ABI actually requires the reverse of what this is testing: the callee
 // does any extensions and remaining bits are unspecified.
 
-// Win64 ABI does expect extensions for type smaller than 64bits.
+// X86_64 ABI does expect extensions for type smaller than 64bits.
 
 // Technically this test wasn't written to test that feature, but it's a
 // valuable check nevertheless.
 
 struct s{
 long a;
 long b;
 };
 
 void f(struct s a, char *b, signed char C) {
   // CHECK: i8 signext
 
 }

clang/test/CodeGen/X86/integer_argument_passing.c

+// RUN: %clang_cc1 -O2 -triple -x86_64-linux-gnu %s -emit-llvm -o - | FileCheck %s --check-prefixes=EXTEND,CHECK
+// RUN: %clang_cc1 -O2 -triple -i386-linux-gnu %s -emit-llvm -o - | FileCheck %s --check-prefixes=EXTEND,CHECK
+// RUN: %clang_cc1 -O2 -triple -i386-pc-win32 %s -emit-llvm -o - | FileCheck %s --check-prefixes=EXTEND,CHECK
+// RUN: %clang_cc1 -O2 -mno-conservative-extend -triple -x86_64-linux-gnu %s -emit-llvm -o - | FileCheck %s --check-prefixes=NOCALLEE-EXTEND,CHECK
+// RUN: %clang_cc1 -O2 -mno-conservative-extend -triple -i386-linux-gnu %s -emit-llvm -o - | FileCheck %s --check-prefixes=NOCALLEE-EXTEND,CHECK
+// RUN: %clang_cc1 -O2 -mno-conservative-extend -triple -i386-pc-win32 %s -emit-llvm -o - | FileCheck %s --check-prefixes=NOCALLEE-EXTEND,CHECK
+
+// EXTEND: define{{.*}} i32 @ZeroExtend(i8 noundef %a, i16 noundef %b)
+// NOCALLEE-EXTEND : define{{.*}} i32 @ZeroExtend(i8 noundef zeroext %a, i16 noundef zeroext %b)
+unsigned ZeroExtend(unsigned char a, unsigned short b) {
+  return a*b;
+}
+
+// EXTEND: define{{.*}} i32 @SignExtend(i8 noundef %a, i16 noundef %b)
+// NOCALLEE-EXTEND: define{{.*}} i32 @SignExtend(i8 noundef signext %a, i16 noundef signext %b)
+int SignExtend(char a, short b) {
+  return a*b;
+}
+
+extern void f0(unsigned char x);
+extern void f1(unsigned short x);
+extern void f2(char x);
+extern void f3(short x);
+
+// CHECK: call void @f0(i8 noundef zeroext {{.*}})
+void caller0(unsigned char x) { f0(x); }
+// CHECK: call void @f1(i16 noundef zeroext {{.*}})
+void caller1(unsigned short x) { f1(x); }
+// CHECK: call void @f2(i8 noundef signext {{.*}})
+void caller2(char x) { f2(x); }
+// CHECK: call void @f3(i16 noundef signext {{.*}})
+void caller3(short x) { f3(x); }

clang/test/CodeGen/X86/x86_32-arguments-darwin.c

double f4(void) {
   return 0;
 }
 
 // CHECK-LABEL: define{{.*}} x86_fp80 @f5()
 long double f5(void) {
   return 0;
 }
 
-// CHECK-LABEL: define{{.*}} void @f6(i8 noundef signext %a0, i16 noundef signext %a1, i32 noundef %a2, i64 noundef %a3, i8* noundef %a4)
+// CHECK-LABEL: define{{.*}} void @f6(i8 noundef %a0, i16 noundef %a1, i32 noundef %a2, i64 noundef %a3, i8* noundef %a4)
 void f6(char a0, short a1, int a2, long long a3, void *a4) {}
 
 // CHECK-LABEL: define{{.*}} void @f7(i32 noundef %a0)
 typedef enum { A, B, C } e7;
 void f7(e7 a0) {}
 
 // CHECK-LABEL: define{{.*}} i64 @f8_1()
 // CHECK-LABEL: define{{.*}} void @f8_2(i32 %a0.0, i32 %a0.1)

 
 typedef int v4i32 __attribute__((__vector_size__(16)));
 
 // CHECK-LABEL: define{{.*}} <2 x i64> @f55(<4 x i32> noundef %arg)
 // PR8029
 v4i32 f55(v4i32 arg) { return arg+arg; }
 
 // CHECK-LABEL: define{{.*}} void @f56(
-// CHECK: i8 noundef signext %a0, %struct.s56_0* noundef byval(%struct.s56_0) align 4 %a1,
+// CHECK: i8 noundef %a0, %struct.s56_0* noundef byval(%struct.s56_0) align 4 %a1,
 // CHECK: i64 noundef %a2.coerce, %struct.s56_1* noundef byval(%struct.s56_1) align 4 %0,
 // CHECK: i64 noundef %a4.coerce, %struct.s56_2* noundef byval(%struct.s56_2) align 4 %1,
 // CHECK: <4 x i32> noundef %a6, %struct.s56_3* noundef byval(%struct.s56_3) align 16 %a7,
 // CHECK: <2 x double> noundef %a8, %struct.s56_4* noundef byval(%struct.s56_4) align 16 %a9,
 // CHECK: <8 x i32> noundef %a10, %struct.s56_5* noundef byval(%struct.s56_5) align 4 %2,
 // CHECK: <4 x double> noundef %a12, %struct.s56_6* noundef byval(%struct.s56_6) align 4 %3)
 
 // CHECK:   call void (i32, ...) @f56_0(i32 noundef 1,

clang/test/CodeGen/X86/x86_32-arguments-linux.c

 // RUN: %clang_cc1 -no-opaque-pointers -w -fblocks -triple i386-pc-linux-gnu -target-cpu pentium4 -emit-llvm -o %t %s
 // RUN: FileCheck < %t %s
 
 // CHECK-LABEL: define{{.*}} void @f56(
-// CHECK: i8 noundef signext %a0, %struct.s56_0* noundef byval(%struct.s56_0) align 4 %a1,
+// CHECK: i8 noundef %a0, %struct.s56_0* noundef byval(%struct.s56_0) align 4 %a1,
 // CHECK: i64 noundef %a2.coerce, %struct.s56_1* noundef byval(%struct.s56_1) align 4 %0,
 // CHECK: <1 x double> noundef %a4, %struct.s56_2* noundef byval(%struct.s56_2) align 4 %1,
 // CHECK: <4 x i32> noundef %a6, %struct.s56_3* noundef byval(%struct.s56_3) align 4 %2,
 // CHECK: <2 x double> noundef %a8, %struct.s56_4* noundef byval(%struct.s56_4) align 4 %3,
 // CHECK: <8 x i32> noundef %a10, %struct.s56_5* noundef byval(%struct.s56_5) align 4 %4,
 // CHECK: <4 x double> noundef %a12, %struct.s56_6* noundef byval(%struct.s56_6) align 4 %5)
 
 // CHECK: call void (i32, ...) @f56_0(i32 noundef 1,

clang/test/CodeGen/X86/x86_64-arguments-nacl.c

 void f1(struct PP_Var p1) { while(1) {} }
 
 // long doubles are 64 bits on NaCl
 // CHECK-LABEL: define{{.*}} double @f5()
 long double f5(void) {
   return 0;
 }
 
-// CHECK-LABEL: define{{.*}} void @f6(i8 noundef signext %a0, i16 noundef signext %a1, i32 noundef %a2, i64 noundef %a3, i8* noundef %a4)
+// CHECK-LABEL: define{{.*}} void @f6(i8 noundef %a0, i16 noundef %a1, i32 noundef %a2, i64 noundef %a3, i8* noundef %a4)
 void f6(char a0, short a1, int a2, long long a3, void *a4) {
 }
 
 // CHECK-LABEL: define{{.*}} i64 @f8_1()
 // CHECK-LABEL: define{{.*}} void @f8_2(i64 %a0.coerce)
 union u8 {
   long double a;
   int b;

clang/test/CodeGen/X86/x86_64-arguments.c

double f4(void) {
   return 0;
 }
 
 // CHECK-LABEL: define{{.*}} x86_fp80 @f5()
 long double f5(void) {
   return 0;
 }
 
-// CHECK-LABEL: define{{.*}} void @f6(i8 noundef signext %a0, i16 noundef signext %a1, i32 noundef %a2, i64 noundef %a3, i8* noundef %a4)
+// CHECK-LABEL: define{{.*}} void @f6(i8 noundef %a0, i16 noundef %a1, i32 noundef %a2, i64 noundef %a3, i8* noundef %a4)
 void f6(char a0, short a1, int a2, long long a3, void *a4) {
 }
 
 // CHECK-LABEL: define{{.*}} void @f7(i32 noundef %a0)
 typedef enum { A, B, C } e7;
 void f7(e7 a0) {
 }
 

clang/test/CodeGen/attr-noundef.cpp

 
 // nullptr_t is never noundef
 // CHECK: [[DEFINE]] i8* @{{.*}}ret_npt{{.*}}()
 // CHECK: [[DEFINE]] void @{{.*}}pass_npt{{.*}}(i8* %
 
 // TODO: for now, ExtInt is only noundef if it is sign/zero-extended
 // CHECK-INTEL: [[DEFINE]] noundef signext i3 @{{.*}}ret_BitInt{{.*}}()
 // CHECK-AARCH: [[DEFINE]] i3 @{{.*}}ret_BitInt{{.*}}()
-// CHECK-INTEL: [[DEFINE]] void @{{.*}}pass_BitInt{{.*}}(i3 noundef signext %
+// CHECK-INTEL: [[DEFINE]] void @{{.*}}pass_BitInt{{.*}}(i3 %
 // CHECK-AARCH: [[DEFINE]] void @{{.*}}pass_BitInt{{.*}}(i3 %
 // CHECK-INTEL: [[DEFINE]] void @{{.*}}pass_large_BitInt{{.*}}(i64 %{{.*}}, i64 %
 // CHECK-AARCH: [[DEFINE]] void @{{.*}}pass_large_BitInt{{.*}}(i127 %
 } // namespace check_exotic

clang/test/CodeGen/builtin-align.c

 // CHECK-LONG-NEXT:  entry:
 // CHECK-LONG-NEXT:    [[ALIGNMENT:%.*]] = zext i32 [[ALIGN]] to i64
 // CHECK-LONG-NEXT:    [[MASK:%.*]] = sub i64 [[ALIGNMENT]], 1
 // CHECK-LONG-NEXT:    [[SET_BITS:%.*]] = and i64 [[PTR]], [[MASK]]
 // CHECK-LONG-NEXT:    [[IS_ALIGNED:%.*]] = icmp eq i64 [[SET_BITS]], 0
 // CHECK-LONG-NEXT:    ret i1 [[IS_ALIGNED]]
 //
 // CHECK-USHORT-LABEL: define {{[^@]+}}@is_aligned
-// CHECK-USHORT-SAME: (i16 noundef zeroext [[PTR:%.*]], i32 noundef [[ALIGN:%.*]]) #0
+// CHECK-USHORT-SAME: (i16 noundef [[PTR:%.*]], i32 noundef [[ALIGN:%.*]]) #0
 // CHECK-USHORT-NEXT:  entry:
 // CHECK-USHORT-NEXT:    [[ALIGNMENT:%.*]] = trunc i32 [[ALIGN]] to i16
 // CHECK-USHORT-NEXT:    [[MASK:%.*]] = sub i16 [[ALIGNMENT]], 1
 // CHECK-USHORT-NEXT:    [[SET_BITS:%.*]] = and i16 [[PTR]], [[MASK]]
 // CHECK-USHORT-NEXT:    [[IS_ALIGNED:%.*]] = icmp eq i16 [[SET_BITS]], 0
 // CHECK-USHORT-NEXT:    ret i1 [[IS_ALIGNED]]
 //
 _Bool is_aligned(TYPE ptr, unsigned align) {

 // CHECK-LONG-NEXT:    [[ALIGNMENT:%.*]] = zext i32 [[ALIGN]] to i64
 // CHECK-LONG-NEXT:    [[MASK:%.*]] = sub i64 [[ALIGNMENT]], 1
 // CHECK-LONG-NEXT:    [[OVER_BOUNDARY:%.*]] = add i64 [[PTR]], [[MASK]]
 // CHECK-LONG-NEXT:    [[INVERTED_MASK:%.*]] = xor i64 [[MASK]], -1
 // CHECK-LONG-NEXT:    [[ALIGNED_RESULT:%.*]] = and i64 [[OVER_BOUNDARY]], [[INVERTED_MASK]]
 // CHECK-LONG-NEXT:    ret i64 [[ALIGNED_RESULT]]
 //
 // CHECK-USHORT-LABEL: define {{[^@]+}}@align_up
-// CHECK-USHORT-SAME: (i16 noundef zeroext [[PTR:%.*]], i32 noundef [[ALIGN:%.*]]) #0
+// CHECK-USHORT-SAME: (i16 noundef [[PTR:%.*]], i32 noundef [[ALIGN:%.*]]) #0
 // CHECK-USHORT-NEXT:  entry:
 // CHECK-USHORT-NEXT:    [[ALIGNMENT:%.*]] = trunc i32 [[ALIGN]] to i16
 // CHECK-USHORT-NEXT:    [[MASK:%.*]] = sub i16 [[ALIGNMENT]], 1
 // CHECK-USHORT-NEXT:    [[OVER_BOUNDARY:%.*]] = add i16 [[PTR]], [[MASK]]
 // CHECK-USHORT-NEXT:    [[INVERTED_MASK:%.*]] = xor i16 [[MASK]], -1
 // CHECK-USHORT-NEXT:    [[ALIGNED_RESULT:%.*]] = and i16 [[OVER_BOUNDARY]], [[INVERTED_MASK]]
 // CHECK-USHORT-NEXT:    ret i16 [[ALIGNED_RESULT]]
 //

 // CHECK-LONG-NEXT:  entry:
 // CHECK-LONG-NEXT:    [[ALIGNMENT:%.*]] = zext i32 [[ALIGN]] to i64
 // CHECK-LONG-NEXT:    [[MASK:%.*]] = sub i64 [[ALIGNMENT]], 1
 // CHECK-LONG-NEXT:    [[INVERTED_MASK:%.*]] = xor i64 [[MASK]], -1
 // CHECK-LONG-NEXT:    [[ALIGNED_RESULT:%.*]] = and i64 [[PTR]], [[INVERTED_MASK]]
 // CHECK-LONG-NEXT:    ret i64 [[ALIGNED_RESULT]]
 //
 // CHECK-USHORT-LABEL: define {{[^@]+}}@align_down
-// CHECK-USHORT-SAME: (i16 noundef zeroext [[PTR:%.*]], i32 noundef [[ALIGN:%.*]]) #0
+// CHECK-USHORT-SAME: (i16 noundef [[PTR:%.*]], i32 noundef [[ALIGN:%.*]]) #0
 // CHECK-USHORT-NEXT:  entry:
 // CHECK-USHORT-NEXT:    [[ALIGNMENT:%.*]] = trunc i32 [[ALIGN]] to i16
 // CHECK-USHORT-NEXT:    [[MASK:%.*]] = sub i16 [[ALIGNMENT]], 1
 // CHECK-USHORT-NEXT:    [[INVERTED_MASK:%.*]] = xor i16 [[MASK]], -1
 // CHECK-USHORT-NEXT:    [[ALIGNED_RESULT:%.*]] = and i16 [[PTR]], [[INVERTED_MASK]]
 // CHECK-USHORT-NEXT:    ret i16 [[ALIGNED_RESULT]]
 //
 TYPE align_down(TYPE ptr, unsigned align) {
   return __builtin_align_down(ptr, align);
 }

clang/test/CodeGen/catch-implicit-integer-sign-changes.c

unsigned char signed_int_to_unsigned_char(signed int src) {
   // CHECK-NEXT: }
 #line 300
   return src;
 }
 
 // These 3 result (after optimizations) in simple 'icmp sge i8 %src, 0'
 
 // CHECK-LABEL: @signed_char_to_unsigned_char
-// CHECK-SAME: (i8 noundef signext %[[SRC:.*]])
+// CHECK-SAME: (i8 noundef %[[SRC:.*]])
 unsigned char signed_char_to_unsigned_char(signed char src) {
   // CHECK: %[[SRC_ADDR:.*]] = alloca i8
   // CHECK-NEXT: store i8 %[[SRC]], i8* %[[SRC_ADDR]]
   // CHECK-NEXT: %[[DST:.*]] = load i8, i8* %[[SRC_ADDR]]
   // CHECK-SANITIZE-NEXT: %[[SRC_NEGATIVITYCHECK:.*]] = icmp slt i8 %[[DST]], 0, !nosanitize
   // CHECK-SANITIZE-NEXT: %[[SIGNCHANGECHECK:.*]] = icmp eq i1 %[[SRC_NEGATIVITYCHECK]], false, !nosanitize
   // CHECK-SANITIZE-NEXT: br i1 %[[SIGNCHANGECHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize
   // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:
   // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i8 %[[DST]] to i64, !nosanitize
   // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize
   // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_400]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
   // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_400]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
   // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize
   // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
   // CHECK-SANITIZE: [[CONT]]:
   // CHECK-NEXT: ret i8 %[[DST]]
   // CHECK-NEXT: }
 #line 400
   return src;
 }
 
 // CHECK-LABEL: @unsigned_char_to_signed_char
-// CHECK-SAME: (i8 noundef zeroext %[[SRC:.*]])
+// CHECK-SAME: (i8 noundef %[[SRC:.*]])
 signed char unsigned_char_to_signed_char(unsigned char src) {
   // CHECK: %[[SRC_ADDR:.*]] = alloca i8
   // CHECK-NEXT: store i8 %[[SRC]], i8* %[[SRC_ADDR]]
   // CHECK-NEXT: %[[DST:.*]] = load i8, i8* %[[SRC_ADDR]]
   // CHECK-SANITIZE-NEXT: %[[DST_NEGATIVITYCHECK:.*]] = icmp slt i8 %[[DST]], 0, !nosanitize
   // CHECK-SANITIZE-NEXT: %[[SIGNCHANGECHECK:.*]] = icmp eq i1 false, %[[DST_NEGATIVITYCHECK]], !nosanitize
   // CHECK-SANITIZE-NEXT: br i1 %[[SIGNCHANGECHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize
   // CHECK-SANITIZE: [[HANDLER_IMPLICIT_CONVERSION]]:
   // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTSRC:.*]] = zext i8 %[[DST]] to i64, !nosanitize
   // CHECK-SANITIZE-ANYRECOVER-NEXT: %[[EXTDST:.*]] = zext i8 %[[DST]] to i64, !nosanitize
   // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_implicit_conversion_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_500]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
   // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_implicit_conversion(i8* bitcast ({ {{{.*}}}, {{{.*}}}*, {{{.*}}}*, i8 }* @[[LINE_500]] to i8*), i64 %[[EXTSRC]], i64 %[[EXTDST]]){{.*}}, !nosanitize
   // CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 7){{.*}}, !nosanitize
   // CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
   // CHECK-SANITIZE: [[CONT]]:
   // CHECK-NEXT: ret i8 %[[DST]]
   // CHECK-NEXT: }
 #line 500
   return src;
 }
 
 // CHECK-LABEL: @signed_char_to_unsigned_int
-// CHECK-SAME: (i8 noundef signext %[[SRC:.*]])
+// CHECK-SAME: (i8 noundef %[[SRC:.*]])
 unsigned int signed_char_to_unsigned_int(signed char src) {
   // CHECK: %[[SRC_ADDR:.*]] = alloca i8
   // CHECK-NEXT: store i8 %[[SRC]], i8* %[[SRC_ADDR]]
   // CHECK-NEXT: %[[DST:.*]] = load i8, i8* %[[SRC_ADDR]]
   // CHECK-NEXT: %[[CONV:.*]] = sext i8 %[[DST]] to i32
   // CHECK-SANITIZE-NEXT: %[[SRC_NEGATIVITYCHECK:.*]] = icmp slt i8 %[[DST]], 0, !nosanitize
   // CHECK-SANITIZE-NEXT: %[[SIGNCHANGECHECK:.*]] = icmp eq i1 %[[SRC_NEGATIVITYCHECK]], false, !nosanitize
   // CHECK-SANITIZE-NEXT: br i1 %[[SIGNCHANGECHECK]], label %[[CONT:.*]], label %[[HANDLER_IMPLICIT_CONVERSION:[^,]+]],{{.*}} !nosanitize

clang/test/CodeGen/ext-int-cc.c

 // PPC64: define{{.*}} void @ParamPassing2(i127 %{{.+}}, i63 signext %{{.+}})
 // PPC32: define{{.*}} void @ParamPassing2(i127* byval(i127) align 8 %{{.+}}, i63 %{{.+}})
 // AARCH64: define{{.*}} void @ParamPassing2(i127 %{{.+}}, i63 %{{.+}})
 // AARCH64DARWIN: define{{.*}} void @ParamPassing2(i127 %{{.+}}, i63 %{{.+}})
 // ARM: define{{.*}} arm_aapcscc void @ParamPassing2(i127* byval(i127) align 8 %{{.+}}, i63 %{{.+}})
 
 // Make sure we follow the signext rules for promotable integer types.
 void ParamPassing3(_BitInt(15) a, _BitInt(31) b) {}
-// LIN64: define{{.*}} void @ParamPassing3(i15 signext %{{.+}}, i31 signext %{{.+}})
+// LIN64: define{{.*}} void @ParamPassing3(i15 %{{.+}}, i31 %{{.+}})
 // WIN64: define dso_local void @ParamPassing3(i15 %{{.+}}, i31 %{{.+}})
-// LIN32: define{{.*}} void @ParamPassing3(i15 signext %{{.+}}, i31 signext %{{.+}})
-// WIN32: define dso_local void @ParamPassing3(i15 signext %{{.+}}, i31 signext %{{.+}})
+// LIN32: define{{.*}} void @ParamPassing3(i15 %{{.+}}, i31 %{{.+}})
+// WIN32: define dso_local void @ParamPassing3(i15 %{{.+}}, i31 %{{.+}})
 // NACL: define{{.*}} void @ParamPassing3(i15 %{{.+}}, i31 %{{.+}})
 // NVPTX64: define{{.*}} void @ParamPassing3(i15 signext %{{.+}}, i31 signext %{{.+}})
 // NVPTX: define{{.*}} void @ParamPassing3(i15 signext %{{.+}}, i31 signext %{{.+}})
 // SPARCV9: define{{.*}} void @ParamPassing3(i15 signext %{{.+}}, i31 signext %{{.+}})
 // SPARC: define{{.*}} void @ParamPassing3(i15 signext %{{.+}}, i31 signext %{{.+}})
 // MIPS64: define{{.*}} void @ParamPassing3(i15 signext %{{.+}}, i31 signext %{{.+}})
 // MIPS: define{{.*}} void @ParamPassing3(i15 signext %{{.+}}, i31 signext %{{.+}})
 // SPIR64: define{{.*}} spir_func void @ParamPassing3(i15 signext %{{.+}}, i31 signext %{{.+}})

clang/test/CodeGen/function-attributes.c

 // RUN: %clang_cc1 -no-opaque-pointers -triple i386-unknown-unknown -emit-llvm -disable-llvm-passes -Os -o - %s | FileCheck %s
 // RUN: %clang_cc1 -no-opaque-pointers -triple i386-unknown-unknown -emit-llvm -disable-llvm-passes -Os -std=c99 -o - %s | FileCheck %s
 // RUN: %clang_cc1 -no-opaque-pointers -triple x86_64-unknown-unknown -emit-llvm -disable-llvm-passes -Os -std=c99 -o - %s | FileCheck %s
 // CHECK: define{{.*}} signext i8 @f0(i32 noundef %x) [[NUW:#[0-9]+]]
 // CHECK: define{{.*}} zeroext i8 @f1(i32 noundef %x) [[NUW]]
-// CHECK: define{{.*}} void @f2(i8 noundef signext %x) [[NUW]]
-// CHECK: define{{.*}} void @f3(i8 noundef zeroext %x) [[NUW]]
+// CHECK: define{{.*}} void @f2(i8 noundef %x) [[NUW]]
+// CHECK: define{{.*}} void @f3(i8 noundef %x) [[NUW]]
 // CHECK: define{{.*}} signext i16 @f4(i32 noundef %x) [[NUW]]
 // CHECK: define{{.*}} zeroext i16 @f5(i32 noundef %x) [[NUW]]
-// CHECK: define{{.*}} void @f6(i16 noundef signext %x) [[NUW]]
-// CHECK: define{{.*}} void @f7(i16 noundef zeroext %x) [[NUW]]
+// CHECK: define{{.*}} void @f6(i16 noundef %x) [[NUW]]
+// CHECK: define{{.*}} void @f7(i16 noundef %x) [[NUW]]
 
 signed char f0(int x) { return x; }
 
 unsigned char f1(int x) { return x; }
 
 void f2(signed char x) { }
 
 void f3(unsigned char x) { }

clang/test/CodeGen/mangle-windows.c

 // CHECK: define dso_local x86_fastcallcc void @"\01@f7@4"
 // X64: define dso_local void @f7(
 
 void __fastcall f8(long long a) {}
 // CHECK: define dso_local x86_fastcallcc void @"\01@f8@8"
 // X64: define dso_local void @f8(
 
 void __fastcall f9(long long a, char b, char c, short d) {}
-// CHECK: define dso_local x86_fastcallcc void @"\01@f9@20"(i64 noundef %a, i8 noundef signext %b, i8 noundef signext %c, i16 noundef signext %d)
+// CHECK: define dso_local x86_fastcallcc void @"\01@f9@20"(i64 noundef %a, i8 noundef %b, i8 noundef %c, i16 noundef %d)
 // X64: define dso_local void @f9(
 
 void f12(void) {}
 // CHECK: define dso_local void @f12(
 // X64: define dso_local void @f12(
 
 void __vectorcall v1(void) {}
 // CHECK: define dso_local x86_vectorcallcc void @"\01v1@@0"(

clang/test/CodeGen/matrix-type-builtins.c

void column_major_load_with_stride_math_int(int *Ptr, int S) {
   // CHECK64-NEXT:   [[STRIDE_EXT:%.*]] = sext i32 [[STRIDE]] to i64
   // CHECK64-NEXT:   [[PTR:%.*]] = load i32*, i32** %Ptr.addr, align 8
   // CHECK64-NEXT:   call <80 x i32> @llvm.matrix.column.major.load.v80i32.i64(i32* align 4 [[PTR]], i64 [[STRIDE_EXT]], i1 false, i32 4, i32 20)
 
   ix4x20_t m_c = __builtin_matrix_column_major_load(Ptr, 4, 20, S + 32);
 }
 
 void column_major_load_with_stride_math_s_int(int *Ptr, short S) {
-  // COMMON-LABEL:  define{{.*}} void @column_major_load_with_stride_math_s_int(i32* %Ptr, i16 signext %S)
+  // COMMON-LABEL:  define{{.*}} void @column_major_load_with_stride_math_s_int(i32* %Ptr, i16 %S)
   // COMMON:         [[S:%.*]] = load i16, i16* %S.addr, align 2
   // COMMON-NEXT:    [[S_EXT:%.*]] = sext i16 [[S]] to i32
   // COMMON-NEXT:    [[STRIDE:%.*]] = add nsw i32 [[S_EXT]], 32
   // CHECK32-NEXT:   [[PTR:%.*]] = load i32*, i32** %Ptr.addr, align 4
   // CHECK32-NEXT:   %matrix = call <80 x i32> @llvm.matrix.column.major.load.v80i32.i32(i32* align 4 [[PTR]], i32 [[STRIDE]], i1 false, i32 4, i32 20)
   //
   // CHECK64-NEXT:   [[STRIDE_EXT:%.*]] = sext i32 [[STRIDE]] to i64
   // CHECK64-NEXT:   [[PTR:%.*]] = load i32*, i32** %Ptr.addr, align 8
void column_major_store_with_stride_math_int(int *Ptr, int S) {
   // CHECK64-NEXT:   [[IDX:%.*]] = sext i32 [[ADD]] to i64
   // CHECK64-NEXT:   call void @llvm.matrix.column.major.store.v80i32.i64(<80 x i32> [[M]], i32* align 4 [[PTR]], i64 [[IDX]], i1 false, i32 4, i32 20)
 
   ix4x20_t m;
   __builtin_matrix_column_major_store(m, Ptr, S + 32);
 }
 
 void column_major_store_with_stride_math_s_int(int *Ptr, short S) {
-  // COMMON-LABEL: define{{.*}} void @column_major_store_with_stride_math_s_int(i32* %Ptr, i16 signext %S)
+  // COMMON-LABEL: define{{.*}} void @column_major_store_with_stride_math_s_int(i32* %Ptr, i16 %S)
   // COMMON:         [[M:%.*]] = load <80 x i32>, <80 x i32>* {{.*}}, align 4
   // CHECK32-NEXT:   [[PTR:%.*]] = load i32*, i32** %Ptr.addr, align 4
   // CHECK64-NEXT:   [[PTR:%.*]] = load i32*, i32** %Ptr.addr, align 8
   // COMMON-NEXT:    [[S:%.*]] = load i16, i16* %S.addr, align 2
   // COMMON-NEXT:    [[EXT:%.*]] = sext i16 [[S]] to i32
   // COMMON-NEXT:    [[ADD:%.*]] = add nsw i32 [[EXT]], 2
   // CHECK32-NEXT:   call void @llvm.matrix.column.major.store.v80i32.i32(<80 x i32> [[M]], i32* align 4 [[PTR]], i32 [[ADD]], i1 false, i32 4, i32 20)
   //

clang/test/CodeGen/matrix-type-operators.c

void subtract_compound_matrix_matrix_unsigned_long_long(ullx4x2_t a, ullx4x2_t b) {
   // CHECK-NEXT:  [[A:%.*]] = load <8 x i64>, <8 x i64>* {{.*}}, align 8
   // CHECK-NEXT:  [[RES:%.*]] = sub <8 x i64> [[A]], [[B]]
   // CHECK-NEXT:  store <8 x i64> [[RES]], <8 x i64>* {{.*}}, align 8
 
   a -= b;
 }
 
 void add_matrix_scalar_int_short(ix9x3_t a, short vs) {
-  // CHECK-LABEL: define{{.*}} void @add_matrix_scalar_int_short(<27 x i32> noundef %a, i16 noundef signext %vs)
+  // CHECK-LABEL: define{{.*}} void @add_matrix_scalar_int_short(<27 x i32> noundef %a, i16 noundef %vs)
   // CHECK:        [[MATRIX:%.*]] = load <27 x i32>, <27 x i32>* [[MAT_ADDR:%.*]], align 4
   // CHECK-NEXT:   [[SCALAR:%.*]] = load i16, i16* %vs.addr, align 2
   // CHECK-NEXT:   [[SCALAR_EXT:%.*]] = sext i16 [[SCALAR]] to i32
   // CHECK-NEXT:   [[SCALAR_EMBED:%.*]] = insertelement <27 x i32> poison, i32 [[SCALAR_EXT]], i32 0
   // CHECK-NEXT:   [[SCALAR_EMBED1:%.*]] = shufflevector <27 x i32> [[SCALAR_EMBED]], <27 x i32> poison, <27 x i32> zeroinitializer
   // CHECK-NEXT:   [[RES:%.*]] = add <27 x i32> [[MATRIX]], [[SCALAR_EMBED1]]
   // CHECK-NEXT:   store <27 x i32> [[RES]], <27 x i32>* [[MAT_ADDR]], align 4
 
   a = a + vs;
 }
 
 void add_compound_matrix_scalar_int_short(ix9x3_t a, short vs) {
-  // CHECK-LABEL: define{{.*}} void @add_compound_matrix_scalar_int_short(<27 x i32> noundef %a, i16 noundef signext %vs)
+  // CHECK-LABEL: define{{.*}} void @add_compound_matrix_scalar_int_short(<27 x i32> noundef %a, i16 noundef %vs)
   // CHECK:       [[SCALAR:%.*]] = load i16, i16* %vs.addr, align 2
   // CHECK-NEXT:  [[SCALAR_EXT:%.*]] = sext i16 [[SCALAR]] to i32
   // CHECK-NEXT:  [[MATRIX:%.*]] = load <27 x i32>, <27 x i32>* %0, align 4
   // CHECK-NEXT:  [[SCALAR_EMBED:%.*]] = insertelement <27 x i32> poison, i32 [[SCALAR_EXT:%.*]], i32 0
   // CHECK-NEXT:  [[SCALAR_EMBED1:%.*]] = shufflevector <27 x i32> [[SCALAR_EMBED]], <27 x i32> poison, <27 x i32> zeroinitializer
   // CHECK-NEXT:  [[RES:%.*]] = add <27 x i32> [[MATRIX]], [[SCALAR_EMBED1]]
   // CHECK-NEXT:  store <27 x i32> [[RES]], <27 x i32>* [[MAT_ADDR]], align 4
 
   a += vs;
 }
 
 void subtract_compound_matrix_scalar_int_short(ix9x3_t a, short vs) {
-  // CHECK-LABEL: define{{.*}} void @subtract_compound_matrix_scalar_int_short(<27 x i32> noundef %a, i16 noundef signext %vs)
+  // CHECK-LABEL: define{{.*}} void @subtract_compound_matrix_scalar_int_short(<27 x i32> noundef %a, i16 noundef %vs)
   // CHECK:       [[SCALAR:%.*]] = load i16, i16* %vs.addr, align 2
   // CHECK-NEXT:  [[SCALAR_EXT:%.*]] = sext i16 [[SCALAR]] to i32
   // CHECK-NEXT:  [[MATRIX:%.*]] = load <27 x i32>, <27 x i32>* %0, align 4
   // CHECK-NEXT:  [[SCALAR_EMBED:%.*]] = insertelement <27 x i32> poison, i32 [[SCALAR_EXT:%.*]], i32 0
   // CHECK-NEXT:  [[SCALAR_EMBED1:%.*]] = shufflevector <27 x i32> [[SCALAR_EMBED]], <27 x i32> poison, <27 x i32> zeroinitializer
   // CHECK-NEXT:  [[RES:%.*]] = sub <27 x i32> [[MATRIX]], [[SCALAR_EMBED1]]
   // CHECK-NEXT:  store <27 x i32> [[RES]], <27 x i32>* [[MAT_ADDR]], align 4
 
void subtract_compound_matrix_scalar_int_unsigned_long_long(ix9x3_t a, unsigned long long int vulli) {
   // CHECK-NEXT:   [[SCALAR_EMBED1:%.*]] = shufflevector <27 x i32> [[SCALAR_EMBED]], <27 x i32> poison, <27 x i32> zeroinitializer
   // CHECK-NEXT:   [[RES:%.*]] = sub <27 x i32> [[MATRIX]], [[SCALAR_EMBED1]]
   // CHECK-NEXT:   store <27 x i32> [[RES]], <27 x i32>* [[MAT_ADDR]], align 4
 
   a -= vulli;
 }
 
 void add_matrix_scalar_long_long_int_short(ullx4x2_t b, short vs) {
-  // CHECK-LABEL: define{{.*}} void @add_matrix_scalar_long_long_int_short(<8 x i64> noundef %b, i16 noundef signext %vs)
+  // CHECK-LABEL: define{{.*}} void @add_matrix_scalar_long_long_int_short(<8 x i64> noundef %b, i16 noundef %vs)
   // CHECK:         [[SCALAR:%.*]] = load i16, i16* %vs.addr, align 2
   // CHECK-NEXT:    [[SCALAR_EXT:%.*]] = sext i16 [[SCALAR]] to i64
   // CHECK-NEXT:    [[MATRIX:%.*]] = load <8 x i64>, <8 x i64>* {{.*}}, align 8
   // CHECK-NEXT:    [[SCALAR_EMBED:%.*]] = insertelement <8 x i64> poison, i64 [[SCALAR_EXT]], i32 0
   // CHECK-NEXT:    [[SCALAR_EMBED1:%.*]] = shufflevector <8 x i64> [[SCALAR_EMBED]], <8 x i64> poison, <8 x i32> zeroinitializer
   // CHECK-NEXT:    [[RES:%.*]] = add <8 x i64> [[SCALAR_EMBED1]], [[MATRIX]]
   // CHECK-NEXT:    store <8 x i64> [[RES]], <8 x i64>* {{.*}}, align 8
 
   b = vs + b;
 }
 
 void add_compound_matrix_scalar_long_long_int_short(ullx4x2_t b, short vs) {
-  // CHECK-LABEL: define{{.*}} void @add_compound_matrix_scalar_long_long_int_short(<8 x i64> noundef %b, i16 noundef signext %vs)
+  // CHECK-LABEL: define{{.*}} void @add_compound_matrix_scalar_long_long_int_short(<8 x i64> noundef %b, i16 noundef %vs)
   // CHECK:       [[SCALAR:%.*]] = load i16, i16* %vs.addr, align 2
   // CHECK-NEXT:  [[SCALAR_EXT:%.*]] = sext i16 [[SCALAR]] to i64
   // CHECK-NEXT:  [[MATRIX:%.*]] = load <8 x i64>, <8 x i64>* %0, align 8
   // CHECK-NEXT:  [[SCALAR_EMBED:%.*]] = insertelement <8 x i64> poison, i64 [[SCALAR_EXT]], i32 0
   // CHECK-NEXT:  [[SCALAR_EMBED1:%.*]] = shufflevector <8 x i64> [[SCALAR_EMBED]], <8 x i64> poison, <8 x i32> zeroinitializer
   // CHECK-NEXT:  [[RES:%.*]] = add <8 x i64> [[MATRIX]], [[SCALAR_EMBED1]]
   // CHECK-NEXT:  store <8 x i64> [[RES]], <8 x i64>* {{.*}}, align 8
 
   b += vs;
 }
 
 void subtract_compound_matrix_scalar_long_long_int_short(ullx4x2_t b, short vs) {
-  // CHECK-LABEL: define{{.*}} void @subtract_compound_matrix_scalar_long_long_int_short(<8 x i64> noundef %b, i16 noundef signext %vs)
+  // CHECK-LABEL: define{{.*}} void @subtract_compound_matrix_scalar_long_long_int_short(<8 x i64> noundef %b, i16 noundef %vs)
   // CHECK:       [[SCALAR:%.*]] = load i16, i16* %vs.addr, align 2
   // CHECK-NEXT:  [[SCALAR_EXT:%.*]] = sext i16 [[SCALAR]] to i64
   // CHECK-NEXT:  [[MATRIX:%.*]] = load <8 x i64>, <8 x i64>* %0, align 8
   // CHECK-NEXT:  [[SCALAR_EMBED:%.*]] = insertelement <8 x i64> poison, i64 [[SCALAR_EXT]], i32 0
   // CHECK-NEXT:  [[SCALAR_EMBED1:%.*]] = shufflevector <8 x i64> [[SCALAR_EMBED]], <8 x i64> poison, <8 x i32> zeroinitializer
   // CHECK-NEXT:  [[RES:%.*]] = sub <8 x i64> [[MATRIX]], [[SCALAR_EMBED1]]
   // CHECK-NEXT:  store <8 x i64> [[RES]], <8 x i64>* {{.*}}, align 8
 

clang/test/CodeGen/ms-inline-asm.c

// CHECK-LABEL: define{{.*}} void @t40
   __asm fld a
 // CHECK: fld dword ptr $1
   __asm fistp i
 // CHECK: fistp dword ptr $0
 // CHECK: "=*m,*m,~{dirflag},~{fpsr},~{flags}"(i32* elementtype(i32) %{{.*}}, float* elementtype(float) %{{.*}})
 }
 
 void t41(unsigned short a) {
-// CHECK-LABEL: define{{.*}} void @t41(i16 noundef zeroext %a)
+// CHECK-LABEL: define{{.*}} void @t41(i16 noundef %a)
   __asm mov cs, a;
 // CHECK: mov cs, $0
   __asm mov ds, a;
 // CHECK: mov ds, $1
   __asm mov es, a;
 // CHECK: mov es, $2
   __asm mov fs, a;
 // CHECK: mov fs, $3

clang/test/CodeGen/regcall.c

 
 void __attribute__((regcall)) v1b(int a, int b) {}
 // Win32: define dso_local x86_regcallcc void @__regcall3__v1b(i32 inreg noundef %a, i32 inreg noundef %b)
 // Win64: define dso_local x86_regcallcc void @__regcall3__v1b(i32 noundef %a, i32 noundef %b)
 // Lin32: define{{.*}} x86_regcallcc void @__regcall3__v1b(i32 inreg noundef %a, i32 inreg noundef %b)
 // Lin64: define{{.*}} x86_regcallcc void @__regcall3__v1b(i32 noundef %a, i32 noundef %b)
 
 void __regcall v2(char a, char b) {}
-// Win32: define dso_local x86_regcallcc void @__regcall3__v2(i8 inreg noundef signext %a, i8 inreg noundef signext %b)
+// Win32: define dso_local x86_regcallcc void @__regcall3__v2(i8 inreg noundef %a, i8 inreg noundef %b)
 // Win64: define dso_local x86_regcallcc void @__regcall3__v2(i8 noundef %a, i8 noundef %b)
-// Lin32: define{{.*}} x86_regcallcc void @__regcall3__v2(i8 inreg noundef signext %a, i8 inreg noundef signext %b)
-// Lin64: define{{.*}} x86_regcallcc void @__regcall3__v2(i8 noundef signext %a, i8 noundef signext %b)
+// Lin32: define{{.*}} x86_regcallcc void @__regcall3__v2(i8 inreg noundef %a, i8 inreg noundef %b)
+// Lin64: define{{.*}} x86_regcallcc void @__regcall3__v2(i8 noundef %a, i8 noundef %b)
 
 struct Small { int x; };
 void __regcall v3(int a, struct Small b, int c) {}
 // Win32: define dso_local x86_regcallcc void @__regcall3__v3(i32 inreg noundef %a, i32 %b.0, i32 inreg noundef %c)
 // Win64: define dso_local x86_regcallcc void @__regcall3__v3(i32 noundef %a, i32 %b.coerce, i32 noundef %c)
 // Lin32: define{{.*}} x86_regcallcc void @__regcall3__v3(i32 inreg noundef %a, i32 inreg %0, i32 %b.0, i32 inreg noundef %c)
 // Lin64: define{{.*}} x86_regcallcc void @__regcall3__v3(i32 noundef %a, i32 %b.coerce, i32 noundef %c)
 

clang/test/CodeGen/vectorcall.c

 // RUN: %clang_cc1 -no-opaque-pointers -emit-llvm %s -o - -ffreestanding -triple=i386-pc-win32       | FileCheck %s --check-prefix=X32
 // RUN: %clang_cc1 -no-opaque-pointers -emit-llvm %s -o - -ffreestanding -triple=x86_64-pc-win32     | FileCheck %s --check-prefix=X64
 
 void __vectorcall v1(int a, int b) {}
 // X32: define dso_local x86_vectorcallcc void @"\01v1@@8"(i32 inreg noundef %a, i32 inreg noundef %b)
 // X64: define dso_local x86_vectorcallcc void @"\01v1@@16"(i32 noundef %a, i32 noundef %b)
 
 void __vectorcall v2(char a, char b) {}
-// X32: define dso_local x86_vectorcallcc void @"\01v2@@8"(i8 inreg noundef signext %a, i8 inreg noundef signext %b)
+// X32: define dso_local x86_vectorcallcc void @"\01v2@@8"(i8 inreg noundef %a, i8 inreg noundef %b)
 // X64: define dso_local x86_vectorcallcc void @"\01v2@@16"(i8 noundef %a, i8 noundef %b)
 
 struct Small { int x; };
 void __vectorcall v3(int a, struct Small b, int c) {}
 // X32: define dso_local x86_vectorcallcc void @"\01v3@@12"(i32 inreg noundef %a, i32 %b.0, i32 inreg noundef %c)
 // X64: define dso_local x86_vectorcallcc void @"\01v3@@24"(i32 noundef %a, i32 %b.coerce, i32 noundef %c)
 
 struct Large { int a[5]; };

clang/test/CodeGenCXX/exceptions.cpp

A *a() {
 
     // CHECK98:      call void @__clang_call_terminate(i8* {{%.*}}) [[NR_NUW]]
     return new(foo(),bar()) A(5);
   }
 
   // rdar://problem/8439196
   A *b(bool cond) {
 
-    // CHECK:    define{{( dso_local)?}} [[A:%.*]]* @_ZN5test31bEb(i1 zeroext
+    // CHECK:    define{{( dso_local)?}} [[A:%.*]]* @_ZN5test31bEb(i1
     // CHECK:      [[SAVED0:%.*]] = alloca i8*
     // CHECK-NEXT: [[SAVED1:%.*]] = alloca i8*
     // CHECK-NEXT: [[CLEANUPACTIVE:%.*]] = alloca i1
 
     // CHECK:      [[COND:%.*]] = trunc i8 {{.*}} to i1
     // CHECK-NEXT: store i1 false, i1* [[CLEANUPACTIVE]]
     // CHECK-NEXT: br i1 [[COND]]
     return (cond ?

clang/test/CodeGenCXX/ext-int.cpp

void BitfieldAssignment() {
   // CHECK: %[[SETC:.+]] = or i8 %[[CLEARC]], 64
 }
 
 enum AsEnumUnderlyingType : _BitInt(9) {
   A,B,C
 };
 
 void UnderlyingTypeUsage(AsEnumUnderlyingType Param) {
-  // LIN: define{{.*}} void @_Z19UnderlyingTypeUsage20AsEnumUnderlyingType(i9 signext %
+  // LIN: define{{.*}} void @_Z19UnderlyingTypeUsage20AsEnumUnderlyingType(i9 %
   // WIN64: define dso_local void @"?UnderlyingTypeUsage@@YAXW4AsEnumUnderlyingType@@@Z"(i9 %
-  // WIN32: define dso_local void @"?UnderlyingTypeUsage@@YAXW4AsEnumUnderlyingType@@@Z"(i9 signext %
+  // WIN32: define dso_local void @"?UnderlyingTypeUsage@@YAXW4AsEnumUnderlyingType@@@Z"(i9 %
   AsEnumUnderlyingType Var;
   // CHECK: alloca i9, align 2
   // CHECK: store i9 %{{.*}}, align 2
 }
 
 unsigned _BitInt(33) ManglingTestRetParam(unsigned _BitInt(33) Param) {
 // LIN64: define{{.*}} i64 @_Z20ManglingTestRetParamDU33_(i64 %
 // LIN32: define{{.*}} i33 @_Z20ManglingTestRetParamDU33_(i33 %

clang/test/CodeGenCXX/microsoft-abi-eh-cleanups.cpp

 // WIN32: }
 
 // Test putting the cleanups inside a conditional.
 int CouldThrow();
 int HasConditionalCleanup(bool cond) {
   return (cond ? TakesTwo(A(), A()) : CouldThrow());
 }
 
-// WIN32-LABEL: define dso_local noundef i32 @"?HasConditionalCleanup@@YAH_N@Z"(i1 noundef zeroext %{{.*}}) {{.*}} {
+// WIN32-LABEL: define dso_local noundef i32 @"?HasConditionalCleanup@@YAH_N@Z"(i1 noundef %{{.*}}) {{.*}} {
 // WIN32:   store i1 false
 // WIN32:   br i1
 // WIN32:   call i8* @llvm.stacksave()
 // WIN32:   call x86_thiscallcc noundef %struct.A* @"??0A@@QAE@XZ"(%struct.A* {{[^,]*}} %{{.*}})
 // WIN32:   store i1 true
 // WIN32:   invoke x86_thiscallcc noundef %struct.A* @"??0A@@QAE@XZ"(%struct.A* {{[^,]*}} %{{.*}})
 // WIN32:   call noundef i32 @"?TakesTwo@@YAHUA@@0@Z"
 //

clang/test/CodeGenCXX/new-overflow.cpp

 // RUN: %clang_cc1 -no-opaque-pointers -std=c++14 -triple i386-unknown-unknown %s -emit-llvm -o - | FileCheck %s
 
 // rdar://problem/9246208
 
 // Basic test.
 namespace test0 {
   struct A {
     A();
     int x;
   };
 
   typedef A elt;
 
-  // CHECK:    define{{.*}} [[A:%.*]]* @_ZN5test04testEs(i16 noundef signext
+  // CHECK:    define{{.*}} [[A:%.*]]* @_ZN5test04testEs(i16 noundef
   // CHECK:      [[N:%.*]] = sext i16 {{%.*}} to i32
   // CHECK-NEXT: [[T0:%.*]] = call { i32, i1 } @llvm.umul.with.overflow.i32(i32 [[N]], i32 4)
   // CHECK-NEXT: [[T1:%.*]] = extractvalue { i32, i1 } [[T0]], 1
   // CHECK-NEXT: [[T2:%.*]] = extractvalue { i32, i1 } [[T0]], 0
   // CHECK-NEXT: [[T3:%.*]] = select i1 [[T1]], i32 -1, i32 [[T2]]
   // CHECK-NEXT: call noalias noundef nonnull i8* @_Znaj(i32 noundef [[T3]])
   // CHECK:      getelementptr inbounds {{.*}}, i32 [[N]]
   elt *test(short s) {
     return new elt[s];
   }
 }
 
 // test0 with a nested array.
 namespace test1 {
   struct A {
     A();
     int x;
   };
 
   typedef A elt[100];
 
-  // CHECK:    define{{.*}} [100 x [[A:%.*]]]* @_ZN5test14testEs(i16 noundef signext
+  // CHECK:    define{{.*}} [100 x [[A:%.*]]]* @_ZN5test14testEs(i16 noundef
   // CHECK:      [[N:%.*]] = sext i16 {{%.*}} to i32
   // CHECK-NEXT: [[T0:%.*]] = call { i32, i1 } @llvm.umul.with.overflow.i32(i32 [[N]], i32 400)
   // CHECK-NEXT: [[T1:%.*]] = extractvalue { i32, i1 } [[T0]], 1
   // CHECK-NEXT: [[T2:%.*]] = extractvalue { i32, i1 } [[T0]], 0
   // CHECK-NEXT: [[T3:%.*]] = mul i32 [[N]], 100
   // CHECK-NEXT: [[T4:%.*]] = select i1 [[T1]], i32 -1, i32 [[T2]]
   // CHECK-NEXT: call noalias noundef nonnull i8* @_Znaj(i32 noundef [[T4]])
   // CHECK:      getelementptr inbounds {{.*}}, i32 [[T3]]
   elt *test(short s) {
     return new elt[s];
   }
 }
 
 // test1 with an array cookie.
 namespace test2 {
   struct A {
     A();
     ~A();
     int x;
   };
 
   typedef A elt[100];
 
-  // CHECK:    define{{.*}} [100 x [[A:%.*]]]* @_ZN5test24testEs(i16 noundef signext
+  // CHECK:    define{{.*}} [100 x [[A:%.*]]]* @_ZN5test24testEs(i16 noundef
   // CHECK:      [[N:%.*]] = sext i16 {{%.*}} to i32
   // CHECK-NEXT: [[T0:%.*]] = call { i32, i1 } @llvm.umul.with.overflow.i32(i32 [[N]], i32 400)
   // CHECK-NEXT: [[T1:%.*]] = extractvalue { i32, i1 } [[T0]], 1
   // CHECK-NEXT: [[T2:%.*]] = extractvalue { i32, i1 } [[T0]], 0
   // CHECK-NEXT: [[T3:%.*]] = mul i32 [[N]], 100
   // CHECK-NEXT: [[T4:%.*]] = call { i32, i1 } @llvm.uadd.with.overflow.i32(i32 [[T2]], i32 4)
   // CHECK-NEXT: [[T5:%.*]] = extractvalue { i32, i1 } [[T4]], 1
   // CHECK-NEXT: [[T6:%.*]] = or i1 [[T1]], [[T5]]

 // test0 with a 1-byte element.
 namespace test4 {
   struct A {
     A();
   };
 
   typedef A elt;
 
-  // CHECK:    define{{.*}} [[A:%.*]]* @_ZN5test44testEs(i16 noundef signext
+  // CHECK:    define{{.*}} [[A:%.*]]* @_ZN5test44testEs(i16 noundef
   // CHECK:      [[N:%.*]] = sext i16 {{%.*}} to i32
   // CHECK-NEXT: call noalias noundef nonnull i8* @_Znaj(i32 noundef [[N]])
   // CHECK:      getelementptr inbounds {{.*}}, i32 [[N]]
   elt *test(short s) {
     return new elt[s];
   }
 }
 

 namespace test6 {
   struct A {
     A();
     int x;
   };
 
   typedef A elt;
 
-  // CHECK:    define{{.*}} [[A:%.*]]* @_ZN5test64testEt(i16 noundef zeroext
+  // CHECK:    define{{.*}} [[A:%.*]]* @_ZN5test64testEt(i16 noundef
   // CHECK:      [[N:%.*]] = zext i16 {{%.*}} to i32
   // CHECK-NEXT: [[T0:%.*]] = call { i32, i1 } @llvm.umul.with.overflow.i32(i32 [[N]], i32 4)
   // CHECK-NEXT: [[T1:%.*]] = extractvalue { i32, i1 } [[T0]], 1
   // CHECK-NEXT: [[T2:%.*]] = extractvalue { i32, i1 } [[T0]], 0
   // CHECK-NEXT: [[T3:%.*]] = select i1 [[T1]], i32 -1, i32 [[T2]]
   // CHECK-NEXT: call noalias noundef nonnull i8* @_Znaj(i32 noundef [[T3]])
   // CHECK:      getelementptr inbounds {{.*}}, i32 [[N]]
   elt *test(unsigned short s) {
     return new elt[s];
   }
 }
 
 // test1 with an unsigned size.
 namespace test7 {
   struct A {
     A();
     int x;
   };
 
   typedef A elt[100];
 
-  // CHECK:    define{{.*}} [100 x [[A:%.*]]]* @_ZN5test74testEt(i16 noundef zeroext
+  // CHECK:    define{{.*}} [100 x [[A:%.*]]]* @_ZN5test74testEt(i16 noundef
   // CHECK:      [[N:%.*]] = zext i16 {{%.*}} to i32
   // CHECK-NEXT: [[T0:%.*]] = call { i32, i1 } @llvm.umul.with.overflow.i32(i32 [[N]], i32 400)
   // CHECK-NEXT: [[T1:%.*]] = extractvalue { i32, i1 } [[T0]], 1
   // CHECK-NEXT: [[T2:%.*]] = extractvalue { i32, i1 } [[T0]], 0
   // CHECK-NEXT: [[T3:%.*]] = mul i32 [[N]], 100
   // CHECK-NEXT: [[T4:%.*]] = select i1 [[T1]], i32 -1, i32 [[T2]]
   // CHECK-NEXT: call noalias noundef nonnull i8* @_Znaj(i32 noundef [[T4]])
   // CHECK:      getelementptr inbounds {{.*}}, i32 [[T3]]

clang/test/CodeGenCXX/virtual-bases.cpp

 // CHECK-LABEL: define{{.*}} void @_ZN1BC2Ev(%struct.B* {{[^,]*}} %this, i8** noundef %vtt) unnamed_addr
 // CHECK-LABEL: define{{.*}} void @_ZN1BC1Ev(%struct.B* {{[^,]*}} %this) unnamed_addr
 B::B() { }
 
 struct C : virtual A {
   C(bool);
 };
 
-// CHECK-LABEL: define{{.*}} void @_ZN1CC2Eb(%struct.C* {{[^,]*}} %this, i8** noundef %vtt, i1 noundef zeroext %0) unnamed_addr
-// CHECK-LABEL: define{{.*}} void @_ZN1CC1Eb(%struct.C* {{[^,]*}} %this, i1 noundef zeroext %0) unnamed_addr
+// CHECK-LABEL: define{{.*}} void @_ZN1CC2Eb(%struct.C* {{[^,]*}} %this, i8** noundef %vtt, i1 noundef %0) unnamed_addr
+// CHECK-LABEL: define{{.*}} void @_ZN1CC1Eb(%struct.C* {{[^,]*}} %this, i1 noundef %0) unnamed_addr
 C::C(bool) { }
 
 // PR6251
 namespace PR6251 {
 
 // Test that we don't call the A<char> constructor twice.
 
 template<typename T>

clang/test/CodeGenObjC/property-atomic-bool.m

 // RUN: %clang_cc1 -no-opaque-pointers -triple x86_64-apple-macosx10 -emit-llvm -x objective-c %s -o - | FileCheck %s
 
 // CHECK: define internal zeroext i1 @"\01-[A0 p]"(
 // CHECK:   %[[ATOMIC_LOAD:.*]] = load atomic i8, i8* %{{.*}} seq_cst, align 1
 // CHECK:   %[[TOBOOL:.*]] = trunc i8 %[[ATOMIC_LOAD]] to i1
 // CHECK:   ret i1 %[[TOBOOL]]
 
-// CHECK: define internal void @"\01-[A0 setP:]"({{.*}} i1 noundef zeroext {{.*}})
+// CHECK: define internal void @"\01-[A0 setP:]"({{.*}} i1 noundef {{.*}})
 // CHECK:   store atomic i8 %{{.*}}, i8* %{{.*}} seq_cst, align 1
 // CHECK:   ret void
 
 // CHECK: define internal zeroext i1 @"\01-[A1 p]"(
 // CHECK:   %[[ATOMIC_LOAD:.*]] = load atomic i8, i8* %{{.*}} unordered, align 1
 // CHECK:   %[[TOBOOL:.*]] = trunc i8 %load to i1
 // CHECK:   ret i1 %[[TOBOOL]]
 
-// CHECK: define internal void @"\01-[A1 setP:]"({{.*}} i1 noundef zeroext %p)
+// CHECK: define internal void @"\01-[A1 setP:]"({{.*}} i1 noundef %p)
 // CHECK:   store atomic i8 %{{.*}}, i8* %{{.*}} unordered, align 1
 // CHECK:   ret void
 
 @interface A0
 @property(nonatomic) _Atomic(_Bool) p;
 @end
 @implementation A0
 @end

clang/test/OpenMP/target_codegen_global_capture.cpp

 // CHECK2-LABEL: define {{[^@]+}}@.omp_offloading.requires_reg
 // CHECK2-SAME: () #[[ATTR3:[0-9]+]] {
 // CHECK2-NEXT:  entry:
 // CHECK2-NEXT:    call void @__tgt_register_requires(i64 1)
 // CHECK2-NEXT:    ret void
 //
 //
 // CHECK3-LABEL: define {{[^@]+}}@_Z3foossss
-// CHECK3-SAME: (i16 noundef signext [[A:%.*]], i16 noundef signext [[B:%.*]], i16 noundef signext [[C:%.*]], i16 noundef signext [[D:%.*]]) #[[ATTR0:[0-9]+]] {
+// CHECK3-SAME: (i16 noundef [[A:%.*]], i16 noundef [[B:%.*]], i16 noundef [[C:%.*]], i16 noundef [[D:%.*]]) #[[ATTR0:[0-9]+]] {
 // CHECK3-NEXT:  entry:
 // CHECK3-NEXT:    [[A_ADDR:%.*]] = alloca i16, align 2
 // CHECK3-NEXT:    [[B_ADDR:%.*]] = alloca i16, align 2
 // CHECK3-NEXT:    [[C_ADDR:%.*]] = alloca i16, align 2
 // CHECK3-NEXT:    [[D_ADDR:%.*]] = alloca i16, align 2
 // CHECK3-NEXT:    [[B_CASTED:%.*]] = alloca i32, align 4
 // CHECK3-NEXT:    [[SB_CASTED:%.*]] = alloca i32, align 4
 // CHECK3-NEXT:    [[C_CASTED:%.*]] = alloca i32, align 4

 // CHECK3-NEXT:    [[CONV3:%.*]] = fpext float [[TMP5]] to double
 // CHECK3-NEXT:    [[ADD4:%.*]] = fadd double [[CONV3]], 1.000000e+00
 // CHECK3-NEXT:    [[CONV5:%.*]] = fptrunc double [[ADD4]] to float
 // CHECK3-NEXT:    store float [[CONV5]], float* [[TMP2]], align 4
 // CHECK3-NEXT:    ret void
 //
 //
 // CHECK3-LABEL: define {{[^@]+}}@_Z3barssss
-// CHECK3-SAME: (i16 noundef signext [[A:%.*]], i16 noundef signext [[B:%.*]], i16 noundef signext [[C:%.*]], i16 noundef signext [[D:%.*]]) #[[ATTR0]] {
+// CHECK3-SAME: (i16 noundef [[A:%.*]], i16 noundef [[B:%.*]], i16 noundef [[C:%.*]], i16 noundef [[D:%.*]]) #[[ATTR0]] {
 // CHECK3-NEXT:  entry:
 // CHECK3-NEXT:    [[A_ADDR:%.*]] = alloca i16, align 2
 // CHECK3-NEXT:    [[B_ADDR:%.*]] = alloca i16, align 2
 // CHECK3-NEXT:    [[C_ADDR:%.*]] = alloca i16, align 2
 // CHECK3-NEXT:    [[D_ADDR:%.*]] = alloca i16, align 2
 // CHECK3-NEXT:    store i16 [[A]], i16* [[A_ADDR]], align 2
 // CHECK3-NEXT:    store i16 [[B]], i16* [[B_ADDR]], align 2
 // CHECK3-NEXT:    store i16 [[C]], i16* [[C_ADDR]], align 2

 // CHECK3-NEXT:    [[CONV3:%.*]] = fpext float [[TMP5]] to double
 // CHECK3-NEXT:    [[ADD4:%.*]] = fadd double [[CONV3]], 1.000000e+00
 // CHECK3-NEXT:    [[CONV5:%.*]] = fptrunc double [[ADD4]] to float
 // CHECK3-NEXT:    store float [[CONV5]], float* [[TMP2]], align 4
 // CHECK3-NEXT:    ret void
 //
 //
 // CHECK3-LABEL: define {{[^@]+}}@_Z5tbar2ssss
-// CHECK3-SAME: (i16 noundef signext [[A:%.*]], i16 noundef signext [[B:%.*]], i16 noundef signext [[C:%.*]], i16 noundef signext [[D:%.*]]) #[[ATTR0]] {
+// CHECK3-SAME: (i16 noundef [[A:%.*]], i16 noundef [[B:%.*]], i16 noundef [[C:%.*]], i16 noundef [[D:%.*]]) #[[ATTR0]] {
 // CHECK3-NEXT:  entry:
 // CHECK3-NEXT:    [[A_ADDR:%.*]] = alloca i16, align 2
 // CHECK3-NEXT:    [[B_ADDR:%.*]] = alloca i16, align 2
 // CHECK3-NEXT:    [[C_ADDR:%.*]] = alloca i16, align 2
 // CHECK3-NEXT:    [[D_ADDR:%.*]] = alloca i16, align 2
 // CHECK3-NEXT:    store i16 [[A]], i16* [[A_ADDR]], align 2
 // CHECK3-NEXT:    store i16 [[B]], i16* [[B_ADDR]], align 2
 // CHECK3-NEXT:    store i16 [[C]], i16* [[C_ADDR]], align 2
 // CHECK3-NEXT:    store i16 [[D]], i16* [[D_ADDR]], align 2
 // CHECK3-NEXT:    [[TMP0:%.*]] = load i16, i16* [[A_ADDR]], align 2
 // CHECK3-NEXT:    [[TMP1:%.*]] = load i16, i16* [[B_ADDR]], align 2
 // CHECK3-NEXT:    [[TMP2:%.*]] = load i16, i16* [[C_ADDR]], align 2
 // CHECK3-NEXT:    [[TMP3:%.*]] = load i16, i16* [[D_ADDR]], align 2
 // CHECK3-NEXT:    [[CALL:%.*]] = call noundef i32 @_Z4tbarIsEiT_S0_S0_S0_(i16 noundef signext [[TMP0]], i16 noundef signext [[TMP1]], i16 noundef signext [[TMP2]], i16 noundef signext [[TMP3]])
 // CHECK3-NEXT:    ret i32 [[CALL]]
 //
 //
 // CHECK3-LABEL: define {{[^@]+}}@_Z4tbarIsEiT_S0_S0_S0_
-// CHECK3-SAME: (i16 noundef signext [[A:%.*]], i16 noundef signext [[B:%.*]], i16 noundef signext [[C:%.*]], i16 noundef signext [[D:%.*]]) #[[ATTR0]] comdat {
+// CHECK3-SAME: (i16 noundef [[A:%.*]], i16 noundef [[B:%.*]], i16 noundef [[C:%.*]], i16 noundef [[D:%.*]]) #[[ATTR0]] comdat {
 // CHECK3-NEXT:  entry:
 // CHECK3-NEXT:    [[A_ADDR:%.*]] = alloca i16, align 2
 // CHECK3-NEXT:    [[B_ADDR:%.*]] = alloca i16, align 2
 // CHECK3-NEXT:    [[C_ADDR:%.*]] = alloca i16, align 2
 // CHECK3-NEXT:    [[D_ADDR:%.*]] = alloca i16, align 2
 // CHECK3-NEXT:    store i16 [[A]], i16* [[A_ADDR]], align 2
 // CHECK3-NEXT:    store i16 [[B]], i16* [[B_ADDR]], align 2
 // CHECK3-NEXT:    store i16 [[C]], i16* [[C_ADDR]], align 2

 // CHECK3-LABEL: define {{[^@]+}}@.omp_offloading.requires_reg
 // CHECK3-SAME: () #[[ATTR3:[0-9]+]] {
 // CHECK3-NEXT:  entry:
 // CHECK3-NEXT:    call void @__tgt_register_requires(i64 1)
 // CHECK3-NEXT:    ret void
 //
 //
 // CHECK4-LABEL: define {{[^@]+}}@_Z3foossss
-// CHECK4-SAME: (i16 noundef signext [[A:%.*]], i16 noundef signext [[B:%.*]], i16 noundef signext [[C:%.*]], i16 noundef signext [[D:%.*]]) #[[ATTR0:[0-9]+]] {
+// CHECK4-SAME: (i16 noundef [[A:%.*]], i16 noundef [[B:%.*]], i16 noundef [[C:%.*]], i16 noundef [[D:%.*]]) #[[ATTR0:[0-9]+]] {
 // CHECK4-NEXT:  entry:
 // CHECK4-NEXT:    [[A_ADDR:%.*]] = alloca i16, align 2
 // CHECK4-NEXT:    [[B_ADDR:%.*]] = alloca i16, align 2
 // CHECK4-NEXT:    [[C_ADDR:%.*]] = alloca i16, align 2
 // CHECK4-NEXT:    [[D_ADDR:%.*]] = alloca i16, align 2
 // CHECK4-NEXT:    [[B_CASTED:%.*]] = alloca i32, align 4
 // CHECK4-NEXT:    [[SB_CASTED:%.*]] = alloca i32, align 4
 // CHECK4-NEXT:    [[C_CASTED:%.*]] = alloca i32, align 4

 // CHECK4-NEXT:    [[CONV3:%.*]] = fpext float [[TMP5]] to double
 // CHECK4-NEXT:    [[ADD4:%.*]] = fadd double [[CONV3]], 1.000000e+00
 // CHECK4-NEXT:    [[CONV5:%.*]] = fptrunc double [[ADD4]] to float
 // CHECK4-NEXT:    store float [[CONV5]], float* [[TMP2]], align 4
 // CHECK4-NEXT:    ret void
 //
 //
 // CHECK4-LABEL: define {{[^@]+}}@_Z3barssss
-// CHECK4-SAME: (i16 noundef signext [[A:%.*]], i16 noundef signext [[B:%.*]], i16 noundef signext [[C:%.*]], i16 noundef signext [[D:%.*]]) #[[ATTR0]] {
+// CHECK4-SAME: (i16 noundef [[A:%.*]], i16 noundef [[B:%.*]], i16 noundef [[C:%.*]], i16 noundef [[D:%.*]]) #[[ATTR0]] {
 // CHECK4-NEXT:  entry:
 // CHECK4-NEXT:    [[A_ADDR:%.*]] = alloca i16, align 2
 // CHECK4-NEXT:    [[B_ADDR:%.*]] = alloca i16, align 2
 // CHECK4-NEXT:    [[C_ADDR:%.*]] = alloca i16, align 2
 // CHECK4-NEXT:    [[D_ADDR:%.*]] = alloca i16, align 2
 // CHECK4-NEXT:    store i16 [[A]], i16* [[A_ADDR]], align 2
 // CHECK4-NEXT:    store i16 [[B]], i16* [[B_ADDR]], align 2
 // CHECK4-NEXT:    store i16 [[C]], i16* [[C_ADDR]], align 2

 // CHECK4-NEXT:    [[CONV3:%.*]] = fpext float [[TMP5]] to double
 // CHECK4-NEXT:    [[ADD4:%.*]] = fadd double [[CONV3]], 1.000000e+00
 // CHECK4-NEXT:    [[CONV5:%.*]] = fptrunc double [[ADD4]] to float
 // CHECK4-NEXT:    store float [[CONV5]], float* [[TMP2]], align 4
 // CHECK4-NEXT:    ret void
 //
 //
 // CHECK4-LABEL: define {{[^@]+}}@_Z5tbar2ssss
-// CHECK4-SAME: (i16 noundef signext [[A:%.*]], i16 noundef signext [[B:%.*]], i16 noundef signext [[C:%.*]], i16 noundef signext [[D:%.*]]) #[[ATTR0]] {
+// CHECK4-SAME: (i16 noundef [[A:%.*]], i16 noundef [[B:%.*]], i16 noundef [[C:%.*]], i16 noundef [[D:%.*]]) #[[ATTR0]] {
 // CHECK4-NEXT:  entry:
 // CHECK4-NEXT:    [[A_ADDR:%.*]] = alloca i16, align 2
 // CHECK4-NEXT:    [[B_ADDR:%.*]] = alloca i16, align 2
 // CHECK4-NEXT:    [[C_ADDR:%.*]] = alloca i16, align 2
 // CHECK4-NEXT:    [[D_ADDR:%.*]] = alloca i16, align 2
 // CHECK4-NEXT:    store i16 [[A]], i16* [[A_ADDR]], align 2
 // CHECK4-NEXT:    store i16 [[B]], i16* [[B_ADDR]], align 2
 // CHECK4-NEXT:    store i16 [[C]], i16* [[C_ADDR]], align 2
 // CHECK4-NEXT:    store i16 [[D]], i16* [[D_ADDR]], align 2
 // CHECK4-NEXT:    [[TMP0:%.*]] = load i16, i16* [[A_ADDR]], align 2
 // CHECK4-NEXT:    [[TMP1:%.*]] = load i16, i16* [[B_ADDR]], align 2
 // CHECK4-NEXT:    [[TMP2:%.*]] = load i16, i16* [[C_ADDR]], align 2
 // CHECK4-NEXT:    [[TMP3:%.*]] = load i16, i16* [[D_ADDR]], align 2
 // CHECK4-NEXT:    [[CALL:%.*]] = call noundef i32 @_Z4tbarIsEiT_S0_S0_S0_(i16 noundef signext [[TMP0]], i16 noundef signext [[TMP1]], i16 noundef signext [[TMP2]], i16 noundef signext [[TMP3]])
 // CHECK4-NEXT:    ret i32 [[CALL]]
 //
 //
 // CHECK4-LABEL: define {{[^@]+}}@_Z4tbarIsEiT_S0_S0_S0_
-// CHECK4-SAME: (i16 noundef signext [[A:%.*]], i16 noundef signext [[B:%.*]], i16 noundef signext [[C:%.*]], i16 noundef signext [[D:%.*]]) #[[ATTR0]] comdat {
+// CHECK4-SAME: (i16 noundef [[A:%.*]], i16 noundef [[B:%.*]], i16 noundef [[C:%.*]], i16 noundef [[D:%.*]]) #[[ATTR0]] comdat {
 // CHECK4-NEXT:  entry:
 // CHECK4-NEXT:    [[A_ADDR:%.*]] = alloca i16, align 2
 // CHECK4-NEXT:    [[B_ADDR:%.*]] = alloca i16, align 2
 // CHECK4-NEXT:    [[C_ADDR:%.*]] = alloca i16, align 2
 // CHECK4-NEXT:    [[D_ADDR:%.*]] = alloca i16, align 2
 // CHECK4-NEXT:    store i16 [[A]], i16* [[A_ADDR]], align 2
 // CHECK4-NEXT:    store i16 [[B]], i16* [[B_ADDR]], align 2
 // CHECK4-NEXT:    store i16 [[C]], i16* [[C_ADDR]], align 2